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

Scheme is a lexically-scoped, block structured, dynamically typed, mostly functional language. It is a variant of Lisp. It has first-class procedures with block structure and indefinite extent. Parameter passing is by value, but all values are references. It has first-class continuations to allow the construction of new control abstractions. It has lexically-scoped ("hygienic") macros to allow definition of of new syntactic forms, or redefinition of old ones.
An Introduction to Scheme and its Implementation

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
tcl-scheme, by Ian Bicking
a translation of Tcl into Guile/Scheme


Structure and Interpretation of Computer programs, by Harold Abelson, Gerald Jay Sussman, Julie Sussman
Monadic Programming in Scheme


Portable Scheme interface to Tk
Chicken/Tk, by Wolf-Dieter Busch
An interface to Tk, based on scheme_wish
scheme_wish, by Sven Hartrumpf
a portable interface between Scheme and Tcl/Tk
Scheme Tk
a free R4RS Scheme interpreter that can access Tk. Concretely, it can be seen as the standard Tk package where Tcl has been replaced by a Scheme interpreter
Scheme Widget Library
a graphics package for Chez Scheme , based on Tk


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

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
% define {+ x y} {expr {$x+$y}}
% + $x $x

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

silas 2018-11-14: LISP has the quote operator ('), as described above, but also has the backquote operator (`) that does what (in Scheme parlance) is called quasi-quotation. It will not eval anything unless lists followed by commas. Take the following Scheme code as an example:

(define (nl) (display "\n"))

(define x 10)
(define v '(display x))
(display v)
(eval v)

(define a 20)
(define y `(display ,(+ a 10)))
(display y)
(eval y)

; Output is:
; (display x)
; 10
; (display 30)
; 30

In Tcl I've stumbled upon situations where I needed something similar. Usually people use eval "..." and escape \$ and [ when don't want it to be evaluated, but it can lead to more or less unreadable code. I wrote a small method called xset that works just like set, but replaces variables that start with @:

proc xset {var body} {
    # Look for own @ identifiers in $body
    set my_identifiers [regexp -inline -all {@[[:alpha:]]+} $body]
    set my_identifiers [lsort -unique $my_identifiers]
    set map_list [list]

    # Builds the map_list variable
    foreach my_ident $my_identifiers {
        set ident [string map [list "@" ""] $my_ident]
        upvar 1 $ident x

        # If upvar'ed variable does not exist, raise an error.
        if {[catch {lappend map_list $my_ident $x}]} {
            set raw_name [string map [list "@" ""] $my_ident]
            return -code error \
                   -errorinfo "can't read $raw_name: no such variable"

    # Make substitutions, set and return $body.
    upvar 1 $var x
    set body [string map $map_list $body]
    set x $body
    return $body

And example to that would be:

set one 1
xset test {
    set one "test"
    set a $one
    set b @one
puts $test

# outputs:
# set one "test"
# set a $one
# set b 1

How would you implement quasi-quotation in Tcl?