README
¶
Go Lisp Interpreter
This repository contains a small Lisp-like language interpreter implemented in Golang.
(fmt.Println "Hello, World!")
Features
This Go Lisp Interpreter offers the following features:
-
Easy Interoperability with Golang: You can easily call Go code from within this Lisp language. Simply use
interp.Use(lisp.Symbols.All)orinterp.Use(lisp.Symbols.Fmt)to add symbols to the root scope. These example symbols are collections of stdlib functions exported as a map of functions. To mix Lisp and Go code, useinterp.EvalWithMap("(+ x 1)", lisp.ScopeMap{ "x": 1 }), which evaluates toint64(2). Alternatively, the methodInterpreter.EvalWithValues(string, any...)allows you to provide a series of values that will be bound to_0,_1, and so on. It's important to note that these bindings do not override globals with the same name, as a new scope is created. -
Lists: The language supports lists represented as
[1 2 3]. -
Maps: Maps can be created using the syntax
{ #name "John" #surname "Smith" }. -
Property Chaining: Property chaining is supported using the dot notation. For example, you can compute the length of a vector with
(math.Sqrt (+ (^ v.x 2) (^ v.y 2) (^ v.z 2))). -
Quasi-quotes: Quasi-quotes are denoted by the symbols
#for quoting and$for interpolation. For instance,#(a b 1.0 [3 $(+ 3 1) 5] $(+ 1 2 3))evaluates to#(a b 1 [3 4 5] 6). This feature allows for convenient construction of data structures or DSLs. As an example, an HTML DSL could be defined as follows:#(div { #class "card" } (img { #src $author.profile-image-url #alt "example image" }) (div { #class "title" } $author.full-name) (div { #class "description" } $author.bio) -
Lexical Scoping: Lexical scoping is not yet implemented in the current version.
Documentation
¶
Index ¶
Examples ¶
Constants ¶
This section is empty.
Variables ¶
This section is empty.
Functions ¶
func ParseExpression ¶
Types ¶
type Interpreter ¶
type Interpreter struct {
Root *Scope
}
func NewInterpreter ¶
func NewInterpreter() *Interpreter
func (*Interpreter) Eval ¶
func (i *Interpreter) Eval(program string) (any, error)
Example (Plus) ¶
interp := lisp.NewInterpreter()
v, err := interp.Eval(`(+ 1 2 3)`)
if err != nil {
log.Fatal(err)
}
fmt.Println(lisp.Show(v))
Output: 6
Example (Println) ¶
interp := lisp.NewInterpreter()
v, err := interp.Eval(`(fmt.Println "Hello, World!")`)
if err != nil {
log.Fatal(err)
}
fmt.Println(lisp.Show(v))
Output: Hello, World! (14 ())
Example (Quasiquote) ¶
interp := lisp.NewInterpreter()
v, err := interp.Eval(`#(a b 1.0 [3 $(+ 3 1) 5] $(+ 1 2 3))`)
if err != nil {
log.Fatal(err)
}
fmt.Println(lisp.Show(v))
Output: #(a b 1 [3 4 5] 6)
Example (Quote1) ¶
interp := lisp.NewInterpreter()
v, err := interp.Eval(`#"example"`)
if err != nil {
log.Fatal(err)
}
fmt.Println(lisp.Show(v))
Output: #"example"
Example (Quote2) ¶
interp := lisp.NewInterpreter()
v, err := interp.Eval(`#(+ 1 2 3)`)
if err != nil {
log.Fatal(err)
}
fmt.Println(lisp.Show(v))
Output: #(+ 1 2 3)
Example (String) ¶
interp := lisp.NewInterpreter()
v, err := interp.Eval(`"example"`)
if err != nil {
log.Fatal(err)
}
fmt.Println(lisp.Show(v))
Output: "example"
func (*Interpreter) Execute ¶
func (i *Interpreter) Execute(program string) error
Example (List) ¶
interp := lisp.NewInterpreter()
err := interp.Execute(`
(set! a [1 2 3])
(fmt.Println a)
(fmt.Println a.0)
(fmt.Println a.1)
(fmt.Println a.2)
`)
if err != nil {
log.Fatal(err)
}
Output: [1 2 3] 1 2 3
Example (Map) ¶
interp := lisp.NewInterpreter()
err := interp.Execute(`
(set! v {#a 1 #b 2 #c (+ 1 2)})
(fmt.Println v)
(fmt.Println v.0)
(fmt.Println v.1)
(fmt.Println v.2)
`)
if err != nil {
log.Fatal(err)
}
Output: {#a 1 #b 2 #c 3} (#a 1) (#b 2) (#c 3)
type TokenizeError ¶
func (TokenizeError) Error ¶
func (e TokenizeError) Error() string
Source Files
Directories