🚀 go-pugleaf

On 1/1/11 2:04 AM, girosenth wrote:
> How to improve the readability of (any) LISP or any highlevel
> functional language to the level of FORTH ?
>
> There are many people who have trivia complaints about parens in lisp,
> but I dont.
>
> LISP is a prefix notation.
>
> sequence of operations would look like this on operands (ops) :
>
> (f ops (g ops (h ops (j ops (k ops (l ops ))...))))
>
> How do you make it readable ?
> How do you home to the center or centers ?
>
> (f (g (h (j (k (l ops)))...)))
>
> is easy to read or
>
> ops l k j h g f

[snip]

> Is there a postfix functional language that also gets rid of parens
> and is not as primitive as FORTH or POSTSCRIPT ?

Forth remains only as primitive as you want it to be.

Consider the list compression example later in this thread:

     Example:
     ?- compress([a,a,a,a,b,c,c,a,a,d,e,e,e,e],X).
     X = [a,b,c,a,d,e]

To solve this using Forth I took an existing dynamic string library 
class and added one method as follows:

\ Create a subclass of string with a compress method
:class string++ <super string+
  \ compress: will return a new string object
  :m compress: ( -- newStr )
     self heap: ( newStr) 0 self at: { newStr lastChar }
     0 0 newStr new:
     lastChar newStr +:
     self size: 1
     ?DO i self at: dup lastChar <>
          IF dup newStr +: THEN
          to lastChar
      LOOP newStr ;m
;class

string++ s \ declare a string object named s

\ 1st copy&paste the input list from the Example
\ and place it into s
s" a,a,a,a,b,c,c,a,a,d,e,e,e,e" s new:

\ 2nd, remove all commas
s" ,"  0 0 s replall:

\ 3rd, do the compression and save the output object in x
s compress: value x

\ We are done:
x p:
abcade  \ Q.E.D


\ Or, if one insists on pretty printing
: e ( idx -- ) x at: emit ;
: print ( obj -- )
   [char] [ emit 0 e
   size: 1 DO [char] , emit i e LOOP
   [char] ] emit ;

x print
[a,b,c,a,d,e]  \ Q.E.D

\ return heap memory
s free:
x free:

If I find the compress method to be repeatedly useful in various 
problems I would keep it as part of my class library.  I may code a 
compress method that is more general and perhaps also for ordered 
collections.  I am confident that there are (many) other solutions to 
the above using more "primitive" Forth techniques.

We also have some extensive postfix arithmetic routines that prove 
useful when translating, for example, Fortran equations.  But I won't 
get into that here.

-Doug