README.md

   1 scheme.forth.jl
   2 ---------------
   3
   4 A hobby Scheme interpreter for FORTH 83. Specifically it is targeted at
   5 [forth.jl](http://github.com/tgvaughan/forth.jl) which is an implementation of
   6 FORTH on top of [Julia](http://www.julialang.org), hence the name.  It began
   7 life as a fairly direct port of Peter Micheaux's [Bootstrap
   8 Scheme](https://github.com/petermichaux/bootstrap-scheme) (as described in
   9 [this wonderful series of blog
  10 posts](http://peter.michaux.ca/articles/scheme-from-scratch-introduction)) from
  11 C to forth, but also includes variadic compound function support, mark-sweep
  12 garbage collection, quasiquotation, and a basic (non-hygienic) macro
  13 system.
  14
  15 In future, I plan to also implement a more complete numerical tower to bring it closer to
  16 [R5RS](http://www.schemers.org/Documents/Standards/R5RS/).
  17
  18 The goal is for the interpreter to be complete enough to be used to complete
  19 the majority of the exercises found in [SICP](http://sarabander.github.io/sicp/).
  20
  21 Running the interpreter
  22 =======================
  23
  24 To run this Scheme interpreter, first open Julia from the src directory contained
  25 in this repository.  If you've not done so already, install forth.jl using the
  26 following command:
  27
  28     julia> Pkg.clone("https://github.com/tgvaughan/forth.jl")
  29
  30 Then, import and run the Forth system:
  31
  32     julia> import forth
  33     julia> forth.run()
  34     Welcome to forth.jl!
  35
  36 Once Forth is running, execute the Scheme source and fire up the
  37 REPL using the following commands:
  38
  39     include scheme.4th  ok
  40     scheme repl
  41     Welcome to scheme.forth.jl!
  42     Use Ctrl-D to exit.
  43
  44     >
  45
  46 At this point you can start entering Scheme commands.  For example,
  47
  48     > (define (factorial n)
  49         (if (= n 0)
  50           1
  51           (* n (factorial (- n 1)))))
  52     ; ok
  53     > (factorial 5)
  54     ; 120
  55
  56 Metacircular Evaluator
  57 ======================
  58
  59 Of course, one of the things you can do in Scheme (or of course any programming
  60 language, this is the fundamental thing) is implement an interpreter for
  61 another programming language.  The examples directory in this repository
  62 contains a verbatim copy of the source for the "metacircular" scheme interpreter
  63 from SICP. To load it, use the following command:
  64
  65     > (load "../examples/metacirc.scm")
  66     ; ok
  67
  68 Be prepared to wait a couple of minutes. When the interpreter finally loads, enter
  69 the following command to run it:
  70
  71     > (driver-loop)
  72
  73 You'll then be greeted by the following prompt:
  74
  75     ;; M-Eval input:
  76
  77 At this point you can start entering Scheme commands... but be prepared to wait
  78 a _long_ time for the result.  For instance, the following example from SICP
  79 defines and demonstrates a recursive list append procedure:
  80
  81     (define (append x y)
  82        (if (null? x)
  83            y
  84            (cons (car x)
  85                  (append (cdr x) y))))
  86
  87      ;;; M-Eval value:
  88      ok
  89
  90      ;;; M-Eval input:
  91      (append '(a b c) '(d e f))
  92
  93      ;;; M-Eval value:
  94      (a b c d e f)
  95
  96 Be prepared to wait 20 min or more for the final result to be printed.  (Given
  97 that at this point we have a program running in a Scheme interpreter running
  98 inside another Scheme interpreter which is itself running on a Forth system
  99 that is implemented in Julia, this should not be a surprise.)
 100
 101 License
 102 =======
 103
 104 This software is free (as in freedom) and is distributed under the terms
 105 of version 3 of the GNU General Public License.  A copy of this license
 106 is included in this repository in the file COPYING.