https://github.com/lemonpi/clisp

Lisp interpreter in C++
https://github.com/lemonpi/clisp

Last synced: 6 days ago
JSON representation

Lisp interpreter in C++

• Host: GitHub
• URL: https://github.com/lemonpi/clisp
• Owner: LemonPi
• Created: 2014-08-23T22:39:26.000Z (about 10 years ago)
• Default Branch: master
• Last Pushed: 2015-01-18T00:30:23.000Z (almost 10 years ago)
• Last Synced: 2024-04-14T07:49:48.481Z (7 months ago)
• Language: C++
• Size: 4.42 MB
• Stars: 4
• Watchers: 2
• Forks: 2
• Open Issues: 0
• Metadata Files:
  • Readme: README.md

Awesome Lists containing this project

README

        
### Clisp

---------------------

A lightweight (~550 lines of code) Lisp interpreter with Scheme dialect.

I was inspired to make this after watching all the [SICP](http://ocw.mit.edu/courses/electrical-engineering-and-computer-science/6-001-structure-and-interpretation-of-computer-programs-spring-2005/video-lectures/) lectures.

Features:

 - file inclusion e.g. (include test.scm), can be nested inside files 

 - optimized tail recursion

 - first class procedures and by extension higher order procedures

 - lexical scoping so you don't have to worry about local variables clashing in called procedures

 - free typed arguments, e.g. (define (add x) ...) x is expected by the semantics to be a list, but not enforced

 - local binding (essentially giving code blocks) with keyword let

 - ; comments 

 


I originally intended to include the boost parts required, but as you can see from include\_list, 

you're better off getting the proper boost distribution. 

To compensate, this repository contains

a binary built on Ubuntu 14.04 which should work on most Unix based machines.

Example:

```

(include funcs.scm)     ; don't do this! recursive inclusion is bad D:

(define (if test a b) (cond ((test) a) (else b)))

(define compose (lambda (f g)   ; fundamental higher order procedure

        (lambda (x)

                (f (g x)))))

(define expt (lambda (x n)      ; exponential 

              (cond ((= n 1) x)

                    (else (* x 

                             (expt x (- n 1)))))))

(define nth-power (lambda (n)

        (lambda (x)

                (expt x n))))

(define square (nth-power 2))

(define cube (nth-power 3))

(define square_and_cube (compose square cube))

(define (add x)

        (cond ((empty? x) 0)

              (else (+ (car x) (add (cdr x))))))

(begin (do something) (do somethingelse) result)    ; basic sequencing

(define (add4 n)

        (let ((x 4)) (+ x n)))  ; basic local binding

(cat 'something 'somethingelse)

(square 5)

(add (1 2 3 4))

```

Tips:

 - build by typing "make" in the same directory

 - build benchmark version by replacing main.cpp with timing.cpp in makefile

 - list parameters (such as x for add above) treated same as 'normal' parameters

 - interpret files with `./clisp [filename] [-p]`, add -p or -print option to force printing of file evaluation, silent by default (assumes a lot of definitions)

    - include files with (include filename), which can be nested

 - build debug information (with step by step info) by changing build target and source in makefile to "testing" and "testing.cpp" respectively

 - requires a compiler supporting C++11

 - uses boost::variant (link above)

 - keywords (so far): define, lambda, cond, cons, cdr, list, else, and, or, not, empty?, include, begin

 - use 'quote to signify string

     - `string` will raise an error if it's not defined, but `'string` will return string

 - use cat primitive instead of + to concatenate strings

 - expressions can extend over different lines, terminated by appropriate )!