Version 40 of Scheme

Updated 2012-09-17 09:58:10 by LkpPo

A derivate of Lisp. A programming language with even less syntax than Tcl itself. (but special forms and the like...? RS)


wdb I strongly disagree that Scheme has less syntax than Tcl! Reason: the symbols have a value per se. Tcl has no symbols as $varname is just a shortcut for [set varname] where varname is just a constant, and the procedure addressed by set carries all the semantics. In Tcl, the command list unknown returns unknown because it is a constant. In Scheme, (list unknown) throws an error unless a symbol unknown is defined. If you want to list an unknown symbol, indeed, you need the special form (quote unknown) resp. its shortcut 'unknown.

  • In Lisp, the special form quote is essential.
  • In Tcl, it is not necessary as it can be defined as a regular procedure as follows:
 proc quote x {
    set x
 }

(Thank you, RS, for the hint with the combinator Identity!)


See Playing Scheme | Tcl and LISP | Playing LISP | Serial summing.

There's a TkScheme. [maybe more than one?]

wdb: There is a Tk connection to the Scheme implementation Chicken [L1 ]. Its successor [L2 ] is called PS/TK http://sourceforge.net/projects/pstk/ (maintained by Phil Bewig) and is maintained by Nils M. Holm [L3 ]. Nils told me that PS/TK works with PLT Scheme on Win, on Scheme 48, and on Gambit.

The classic Scheme book is SICP.

http://phaseit.net/claird/comp.lang.scheme/scheme.html


One interesting difference is that setting of (only global?) variables and function definition both are done with define, which creates a lambda if its first element is a list. Just for experimenting, here's how to have that in Tcl:

 proc define {what how} {
     if {[llength $what]==1} {
          uplevel 1 set $what [list $how]
     } else {
          proc [lindex $what 0] [lrange $what 1 end] $how
     }
 }
 % define x 42
 42
 % define {+ x y} {expr {$x+$y}}
 % + $x $x
 84

This prevents us from having spaces in variable names (not a big problem), but presents the function name and arguments in one list, similar to how it will later be called - people sometimes wonder why we define proc foo {x y} {..} but call it foo $x $y...