Basically, use-modules is for any bigger program than examples/hello.scm or examples/filter.scm. When we create a big module, load will import too many stuff that we can't organize. With use-modules, we write:

(use-modules (stdlib list))

(list 1 2 3)

We only import list into the current scope, which is helpful for the real world project.

Minimal reproduce example:

(+ 1 -1)
#|
result:
  Can not found variable: -1
|#

• if
• cond
  form: cond clause clause ...
  clause: (predicate expression …) or (else expression expression …)

  (cond ((> 3 2) 'greater)
    ((< 3 2) 'less))                  ⇒  greater
  
  (cond ((> 3 3) 'greater)
    ((< 3 3) 'less)
    (#t 'equal))                    ⇒  equal

• case

  (case (* 2 3)
     ((2 3 5 7) 'prime)
        ((1 4 6 8 9) 'composite))            ⇒  composite
  
  (case (car '(c d))
     ((a) 'a)
     ((b) 'b))                            ⇒  unspecified
  
  (case (car '(c d))
     ((a e i o u) 'vowel)
     ((w y) 'semivowel)
     (else 'consonant))                   ⇒  consonant

ref: https://www.gnu.org/software/mit-scheme/documentation/mit-scheme-ref/Conditionals.html

For now, we can write (load "stdlib.scm") is because we work under this project root. However, users won't always work like that and it's very inconvenience.

To avoid this situation, we have to provide a default place to install these standard libraries.

The current problem is the lib/ is rely on the executing file path when you run little-scheme out of the source directory without a prepared library then the init process failed.

To solve this we have to embed the lib/ into binary.

• special form: let ((variable init) …) expression expression …

  (let ((x 2) (y 3))
    (* x y))                              ⇒  6
  
  (let ((x 2) (y 3))
    (let ((foo (lambda (z) (+ x y z)))
          (x 7))
      (foo 4)))                           ⇒  9

• special form: let* ((variable init) …) expression expression …

  (let ((x 2) (y 3))
    (let* ((x 7)
           (z (+ x y)))
      (* z x)))                           ⇒  70

• special form: letrec ((variable init) …) expression expression …

  (letrec ((even?
            (lambda (n)
              (if (zero? n)
                  #t
                  (odd? (- n 1)))))
           (odd?
            (lambda (n)
              (if (zero? n)
                  #f
                  (even? (- n 1))))))
    (even? 88))                           ⇒  #t

ref

• https://www.gnu.org/software/mit-scheme/documentation/mit-scheme-ref/Lexical-Binding.html
• https://docs.racket-lang.org/reference/let.html#%28form._%28%28lib._racket%2Fprivate%2Fletstx-scheme..rkt%29._letrec%29%29

Now every command in little scheme has no options, however, it would be a thing in the near future. We can cut the argument list by break.

Right now eval function takes too many responsibilities. That make add function such as call/cc
or compiling became quite hard. To solve this, we would add a transform layer to ensure the special form such as let let* letrec can be converted to lambda first.

Then do calculus-conversion and CPS-conversion would be easier.

TODO(order is not important):

• desugar let
  PR: #42
• Calculus conversion
  • http://matt.might.net/articles/compiling-scheme-to-c/
  • http://churchturing.org/y/90-min-scc.pdf
• CPS conversion
  • http://matt.might.net/articles/cps-conversion/

In Scheme, the comment can be:

; single line

(#or)

#|
Multiple lines
|#

ref: https://www.gnu.org/software/mit-scheme/documentation/mit-scheme-ref/Comments.html

When we have the following form, at before we would get little-scheme: src/Scheme/Interpreter.hs:(179,1)-(190,30): Non-exhaustive patterns in function apply because the apply function do not cover all cases, to fix that, we should cover and report we are calling some not a function.

(0 1)
;;; => Applying a not function value: 0

• S expression parsing

Reproduce:

1. little-scheme
2. run #a
3. got: Can not found variable: #a

This is because I mixing syntax of #f and #t with the normal identifier, but they are different in the scheme definition. Should separate their parser.

When implementing cond and case, I didn't correctly implement clause.

clause should like let:

(let ((x 2))
  1
  x)

can have multiple expressions as the body!

But for now

(cond (#t 1 2))

would break the interpreter.

Right now the following program:

(write 1)

has stdout result:

1
#t 

Which is not as expected, the expression in the program file shouldn't be print out.

just a try, if stack is better than swap to stack.

Well, just like elz, and anyway this is a toy project. Rather than improving this, make a new one actually faster from my perspective XD.

Right now little-scheme only supports integer, should also support:

• reals: 3.14
• rationals: 3/10
• complex: 3+1.1i

With related functions: https://www.gnu.org/software/mit-scheme/documentation/mit-scheme-ref/Numerical-operations.html

To C or LLVM IR

TODO:

• closure conversion
• CPS conversion

ref:

• http://matt.might.net/articles/compiling-scheme-to-c/
• http://churchturing.org/y/90-min-scc.pdf

ref:

• https://dkandalov.github.io/call-with-current-continuation
• https://ds26gte.github.io/tyscheme/index-Z-H-15.html
• https://www.sczyh30.com/posts/Functional-Programming/call-with-current-continuation/
• https://jlongster.com/Whats-in-a-Continuation

When compiling with wall flag, GHC points out in Interpreter.hs has a Defined but not used variable, and it evaluates a key object in case form for comparing it with objects in case. It seems like a bug.

src/Scheme/Interpreter.hs:69:7: warning: [-Wunused-matches]
    Defined but not used: ‘result’
   |
69 |       result <- eval env key
   |

For a lexical binding program such as:

(let ((x 1) (y 2))
  (+ x y))

Find a binding is a little bit hard.

If we allow [ ]:

(let ([x 1] [y 2])
  (+ x y))

We can find the binding by [ ] without thinking about the parenthesis.

An example from racket:

(define-syntax-rule (swap x y)
  (let ([tmp x])
    (set! x y)
    (set! y tmp)))

(list (swap 2 1))
;;; result: `(1 2)`

Reference

https://docs.racket-lang.org/guide/macros.html

Found bazel is better than CMake, at least more readable.

Current AST was some S expression like:

data Expr =
  List [Expr]
  | Number

Which make transformer hard to skip branch.

Right now little scheme requires little-scheme init to explicit prepare libraries. It should automatically prepare environment when do not have one.

Would need:

• embedded lib/* into binary so that we can remove code base and still safely
• update Main function to do lazy preparing

And then some dependencies would duplicate so ref to https://stackoverflow.com/questions/10163604/how-to-reduce-duplication-in-the-build-depends-fields-of-a-cabal-file

We can create common dependencies to share between source code and tests.

https://schemers.org/Documents/Standards/R5RS/

An example take from racket reference:

(struct point (x y) #:inspector #f)
(point 3 5)
(struct celsius (temp)
  #:guard (λ (temp name)
      (unless (and (real? temp) (>= temp -273.15))
         (error "not a valid temperature"))
      temp))
(celsius -275)
;;; result: not a valid temperature

But I'm not sure we need such a complex definition for struct.

Reference

https://docs.racket-lang.org/reference/define-struct.html

For example, the following code leads Can not found variable: y:

((lambda (x) y) 1)

However, in a bigger program, we can't get location would cause debugging hard.

To avoid this we have to record the location of expression, in the case is (0, 14), create an error: file.scm (0, 14): Can not found variable: y