wiiki - ForthAndCsample

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 ;