[Richard Suchenwirth] 2002-12-16 - For people experienced in other languages, it may be interesting to compare code snippets between [Tcl and other languages], to demonstrate similarities and differences. Please add more from your experience!

'''[C]'''
 void countdown(int n) {         | proc countdown {n} {
    int i;                       |
    for(i=n; i>0; i--) {         |    for {set i $n} {$i>0} {incr i -1} {
       printf("%d...\n", i);     |        puts $i...
    }                            |    }
 }                               | }

'''[C]'''  /* The above could be: */
 void countdown(int n) {
    for (; n>0; n--)
       printf("%d...\n",n);
 }

   * Everything is a command in Tcl. Function definitions are done with the [proc] command, assignments with the [set] command, in/decrementation of integers with the [incr] command.
   * Retrieving the value of a variable goes with prefixed $ sign - while mentioning the name of a variable it is not used
   * Variable type rarely matters and is not declared. Only [incr] would complain if its first argument is not an integer
   * Formatting values into strings goes in simple cases by straight string concatenation like in $i.... for stronger control, [format] is comparable to ''sprintf''
   * [puts], unlike ''printf()'', needs no explicit newline.

[AM] The above proc could look like this in Fortran (90):

  subroutine countdown( n ) 
     integer :: n
     integer :: i
     do i = n,1,-1
        write(*,*) i, '...'
     enddo
  endsubroutine 

The main difference with either C or Tcl is that in Fortran the do-loop is very different kind of
control construct: it is really an iteration over a ''predefined'' set of values, whereas in C and Tcl
the three parts gouverning the iteration can be almost anything. (The Fortran control variable can be an integer only).

'''[Scheme]'''
 (define foo 42)                 | set foo 42
 (define (square x) (* x x))     | proc square x {expr $x * $x}
 (define bar (square foo))       | set bar [square $foo]
 (define grill '(square foo))    | set grill {square $foo}
   * Functions are also defined with the [proc] command. Their result is the last executed command in the body
   * Arithmetics is not done with prefix functions, but Infix-style like in C, in the argument(s) to the [expr] command
   * [set] is used for variables, [proc] for functions - no unified ''define'' in Tcl (except if you write one - see the [Scheme] page ;-)
   * Tcl commands on toplevel are not enclosed in parens. Embedded commands like the first call to ''square'' go into brackets for eager evaluation; the equivalent to quoting is curly braces around a string
 (define (abs x)                 | proc abs x {
   (cond ((> x 0) x)             |    expr { $x > 0?  $x :
         ((= x 0) 0)             |           $x == 0? 0 :
         ((< x 0) (- x))))       |           $x < 0?  -$x}
                                 | }
                                 | or: proc abs x {expr abs($x)}
   * [expr] can, with the ?: operator, operate like ''cond''
   * It also has built-in math functions that can be exported in a one-liner as shown ([Importing expr functions])
   * Tcl needs less parens (which often amount to braces or brackets)
 (define (abs x)                 | proc abs x {
  (if (< x 0)                    |    if {$x < 0} {
      (- x)                      |        expr -$x
      x))                        |    } else {return $x}
   * [If],[for],[while] take a test expression in infix notation, as used for [expr]
   * The branches of an [if] must be commands - in place of the ''[return] x'' one might write ''set x''

----
[TV] The C code from above:

 int countdown(n)
 int n;
 {
    int i;
    for (i=n; i>0; i--) {
       printf("%d...\n", i);
    }
 }

in more traditional, non-cross source file argument checking, non-ansi notation, can also be represented in assembly code. For the above, using the gnu C compiler under cygwin, the following assembly can be generated, which looks obfuscated, because of the complex or hard to see through variable space and stack handling:

 LC0:
         .ascii "%d...\12\0"
 .globl _countdown
         .def    _countdown;     .scl    2;      .type   32;     .endef
 _countdown:
         pushl   %ebp
         movl    %esp, %ebp
         subl    $24, %esp
         movl    8(%ebp), %eax
         movl    %eax, -4(%ebp)
 L10:
         cmpl    $0, -4(%ebp)
         jg      L13
         jmp     L11
 L13:
         movl    -4(%ebp), %eax
         movl    %eax, 4(%esp)
         movl    $LC0, (%esp)
         call    _printf
         leal    -4(%ebp), %eax
         decl    (%eax)
         jmp     L10
 L11:
         leave
         ret



----
[Tcl and other languages]
----

See also [BOOK Programming Language Examples Alike Cookbook],
http://www.merd.net/pixel/language-study/scripting-language/
and [CL]'s 
ill-maintained personal notes on language comparison
[http://phaseit.net/claird/comp.lang.misc/language_comparisons.html].