Version 43 of Scheme

Updated 2014-05-12 16:15:17 by pooryorick

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

Reference

Structure and Interpretation of Computer programs , by Harold Abelson , Gerald Jay Sussman , Julie Sussman

See Also

Muddy Scheme
a Scheme implementation in Tcl
Playing Scheme
Tcl and LISP
Playing LISP
Serial summing
Cameron Laird's personal notes on Scheme

Description

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!)


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.


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...