https://github.com/sasagawa888/elxlisp
Lisp1.5 interpreter/compier
https://github.com/sasagawa888/elxlisp
elixir lisp
Last synced: 2 months ago
JSON representation
Lisp1.5 interpreter/compier
- Host: GitHub
- URL: https://github.com/sasagawa888/elxlisp
- Owner: sasagawa888
- License: other
- Created: 2019-10-19T00:01:39.000Z (over 5 years ago)
- Default Branch: master
- Last Pushed: 2020-06-15T23:26:01.000Z (almost 5 years ago)
- Last Synced: 2025-03-01T13:37:59.692Z (3 months ago)
- Topics: elixir, lisp
- Language: Elixir
- Homepage:
- Size: 110 KB
- Stars: 16
- Watchers: 5
- Forks: 4
- Open Issues: 1
-
Metadata Files:
- Readme: README.md
- License: license.txt
Awesome Lists containing this project
README
# Elxlisp
Lisp 1.5 M-expression.
Also S-expression is available with invoke option.
## Installation
make clone from GitHub
## invoke
- mix elxlisp (sequential and M-expression)
- mix elxlisp seq (sequential and M-expression)
- mix elxlisp para (parallel and M-expression)
- mix elxlisp sexp (sequential and S-expression)
- mix elxlisp mexp (sequential and M-expression)
## example
```elixir
mix elxlisp
Lisp 1.5 in Elixir M-expression in sequential
? cons[A;B]
(A . B)
? car[(A B C)]
A
? third[x]=car[cdr[cdr[x]]]
third
? third[(1 2 3)]
3
? load["test.meta"]
t
? fact[10]
3628800
? intersection[(A B C);(D C A)]
(A C)
? quit[]
goodbye
```
## environment is association list
```elixir
Lisp 1.5 in Elixir M-expression in sequential
? eval[(cons x y);((x . 1)(y . 2))]
(1 . 2)
?
```
## parallel
When invoke in parallel, evlis function runs in parallel.
Fibonacci runs faster in parallel. See test.meta
```
Lisp 1.5 in Elixir M-expression in sequential
? load["test.meta"]
T
? time[fib[30]]
"time: 3455959 micro second"
"-------------"
832040
? quit[]
"goodbye"
$ mix elxlisp para
Lisp 1.5 in Elixir in parallel
? load["test.meta"]
T
? time[fib[30]]
"time: 2168482 micro second"
"-------------"
832040
?
```
## compiler
```elixir
Lisp 1.5 in Elixir M-expression in sequential
? compile["test.meta"]
ok
? load["test.o"]
T
? time[fib[30]]
"time: 23140 micro second"
"-------------"
832040
? time[tarai[12;6;0]]
"time: 105260 micro second"
"-------------"
12
? time[ack[3;9]]
"time: 98380 micro second"
"-------------"
4093
?
```
## data type
- integer
- float
- string
- symbol
- list
## special form
- cond
[p1->e1;p2->e2...]
- if
- defun
foo[x] = boo[x]
- setq
- quote
- lambda
- function
- time print execute time (micro second)
## primitive
- car
- cdr
- cons
- plus
- difference
- times
- quotient
- recip
- remainder
- divide
- expt
- add1
- sub1
- null
- length
- operate
- eq
- equal
- greaterp
- eqgreaterp
- lessp
- eqlessp
- max
- min
- logor
- logand
- leftshift
- numberp
- floatp
- onep
- zerop
- minusp
- listp
- symbolp
- read
- eval
- apply
- print
- prin1
- putprop
- get
- set
- quit
- reverse
- member
- append
- mapcar
- maplist
- and
- or
- load
if extension of file is "meta" then load file as M-expression.
if extension of file is "lsp" then load file as S-expression.
if extension of file is "o" then load file as compiled code.
- compile compile file and generate file with extension "o"
- trace
- untrace
## Acknowledgment
special thanks Dr. John McCarthy
## Reference document
[Lisp 1.5 programmer's manual](http://www.softwarepreservation.org/projects/LISP/book/LISP%201.5%20Programmers%20Manual.pdf)