Forth And Csample

There was some discussion in the ChuckMoore page that Forth is no more difficult to read than C. Here's some sample Forth code, and some C code that does the same thing. You be the judge. The Forth source is from the ExampleForthCode page, but the comments (other than stack comments, which serve to identify input-output parameters) are removed.

Forth

    : star ( - ) [char] * emit ;
    : stars ( n - ) 0 do star loop cr ;
    : square ( n - ) dup 0 do dup stars loop drop ;
    : triangle ( n - ) 1 do i stars loop ;
    : tower ( n - ) dup triangle square ;
    : main ( - ) cr 7 stars cr 3 triangle cr 6 tower ;

    void stars(int n) {
      for (int i=0; i<n; i++) putchar('*');
      putchar('\n');
    }

    void square(int n) {
      for (int i=0; i<n; i++) stars(n);
    }

    void triangle(int n) {
      for (int i=0; i<n; i++) stars(i);
    }

    void tower(int n) {
      triangle(n-1);
      square(n);
    }

    void main() {
      stars(7);
      triangle(3);
      tower(6);
    }

I have a little bit of Forth experience and significantly more C experience, but I would say that the example above does support the statement that "Forth is no more difficult to read than C". However, I would also say that this example is so trivial as to be almost meaningless -- there is hardly anything here but the basic syntax that you'd get on day one of learning any language.

The above C code ignores several C shortcuts. Using "while" instead of "for" makes the code more readable to a C programmer(how?). In addition, the single-statement functions and non-looping functions can be written legibly on one line (although some C purists might disagree). It's legible, but less legible than the multi-line versions.

Here is the simplified C code. Except for "n--", it should be understandable even by someone who does not know C.

    void stars(int n) {
      while (n-- > 0) putchar('*');
      putchar('\n');
    }

    void square(int n)   { int i=n; while (i-- > 0) stars(n); }

    void triangle(int n) { int i=n; while (i-- > 0) stars(i); }

    void tower(int n)    { triangle(n-1); square(n); }

    void main() {
      stars(7);
      triangle(3);
      tower(6);
    }

Nice, but the triangle looks upside-down from the other versions.

To translate the above (incorrect) code back into Forth:

 : stars ( n -- )       begin dup while 1- [char] * emit repeat drop cr ;
 : square ( n -- )      dup begin dup while 1- over stars repeat 2drop ;
 : triangle ( n -- )    begin dup while dup stars 1- repeat drop ;
 : tower ( n -- )       dup 1- triangle square ;
 : main                 cr 7 stars 3 triangle 6 tower ;

Note that many Forth dialects support an explicit counted loop form too, despite it not being ANSI-compliant:

 : square ( n -- )      dup for dup stars next drop ;

To correct the triangle upside-down bug,

 : triangle ( n -- )    1 begin 2dup >= while dup stars 1+ repeat 2drop ;
 : tower ( n -- )       dup 1- triangle square ;

Also, if your coding conventions favor readability over conciseness, then a naive coder would ''really' write square as:

 : row ( n x -- n x )    over stars ;
 : square ( n -- )       dup begin dup while row 1- repeat 2drop ;

A more experienced Forth coder would see the general pattern:

begin dup while ... 1- repeat

occur all over the place. So she can refactor the whole construct into a higher-order function:

 : asNecessary ( ... n xt -- ... )
   >r begin dup while r@ execute 1- repeat drop r> drop ;

 : .*                      [char] * emit ;
 : stars ( n -- )          ['] .* asNecessary cr ;
 : row ( n x -- n x )      over stars ;
 : square ( n -- )         dup ['] row asNecessary drop ;
 : row ( n x -- n x )      swap dup stars 1+ swap ;   ( hooray for HyperStaticGlobalEnvironments! )
 : triangle ( n -- )       0 swap ['] row asNecessary drop ;
 : tower ( n -- )          dup 1- triangle square ;
 : main                    cr 7 stars 3 triangle 6 tower ;

If you're even more advanced, you can write words to permit code blocks right inside of Forth colon-definitions. We employ knowledge of immediate-words to extend the compiler, plus knowledge of run-time string evaluation to implement text-substitution macros.

 ( Add code quotations to GForth; odds are good it'll work elsewhere too. )
 variable quotedCode
 : $(           S" ahead [ :noname " evaluate ; immediate
 : $)           S" ; quotedCode ! ] then [ quotedCode @ ] literal " evaluate ; immediate

 : stars        $( [char] * emit $) asNecessary cr ;
 : square       dup $( over stars $) asNecessary drop ;
 : triangle     1 swap $( swap dup stars 1+ swap $) asNecessary drop ;
 : tower        dup 1- triangle square ;
 : main         cr 7 stars  3 triangle  6 tower ;

So, with only 2 lines of "blood, sweat, and tears", easily tucked away into a library, to define a new language feature, plus one higher-order function, the remainder of the program actually becomes substantially more readable and maintainable than any C version posted here to date.

--SamuelFalvo?

First of all, you really need to stop simulating DO/FOR loops with WHILE loops. Especially on a page demonstrating the readability of Forth. Secondly, while code quotations are awesome, I really don't think that this example is more readable with them. This code should be written like so (the standard words are in uppercase only for strict ANSI compliance):

 \ Just in case your system doesn't have FOR loops.
 [UNDEFINED] FOR [IF] : FOR  0 POSTPONE LITERAL POSTPONE DO ; IMMEDIATE
 SYNONYM NEXT LOOP
 [THEN]

 \ Also, asNeccesary is traditionally defined as 
 : times ( i*x xt n -- j*x )  FOR  DUP EXECUTE  NEXT  DROP ;
 : star  [CHAR] * EMIT ;
 : stars  ( n -- )  FOR star NEXT CR ;
 : square  ( n -- )  DUP  FOR  DUP stars  NEXT  DROP ;
 : triangle ( n - ) 1 DO I stars LOOP ;
 : tower  ( n -- )  DUP triangle square ;
 : go   CR 7 stars  3 triangle  6 tower ;

---

I'm new to Factor, but here's an attempt at a port

 : star ( -- ) "*" write ;
 : stars ( n -- ) [ star ] times nl ;
 : square ( n -- ) dup [ stars ] curry times ;
 : triangle ( n -- ) iota [ 1 + stars ] each ;
 : tower ( n -- ) [ triangle ] [ square ] bi ;
 : main ( -- ) nl 7 stars nl 3 triangle nl 6 tower ;