lasp 0.8.0 → 0.9.0

data/EXAMPLES.md

@@ -3,13 +3,13 @@
 A complete list of the available functions can be found in the README.
 
 Since Läsp is very similar to Clojure, you can get pretty decent syntax
-highlighting by just setting your editor to treat .lasp files as .clj
+highlighting by just setting your editor to treat `.lasp` files as `.clj`
 
-In this document output is shown with ;; and normal comments with ;.
+In this document output is shown with `;;` and normal comments with `;`.
 
 ## Data types
 
-```lisp
+```clojure
 ; Number types
 1
 1.5
@@ -19,23 +19,28 @@ true
 false
 nil
 
-; Strings
+; Text
 "hello world!" ;; => "hello world!"
 
-; Symbol-style strings (not its own type)
+; Symbol-style text (not its own type)
 :hey ;; => "hey"
 
 ; Lists
-(list 1 2 3) ;; => [1, 2, 3]
-(list)       ;; => []
+(list 1 2 3) ;; => (1 2 3)
+(list)       ;; => ()
 ```
 
 ## Basic function calls
 
-```lisp
+```clojure
 ; inc is a function that increments its argument, and 1 is the single argument
 (inc 1) ;; => 2
 
+; Outputting to the terminal
+(println "hello world!")
+;; hello world!
+;; => nil
+
 ; Simple maths functions take any number of arguments
 (/ 20 2)     ;; => 10
 (+ 1 3 5)    ;; => 9
@@ -52,7 +57,7 @@ nil
 
 ## List operations
 
-```lisp
+```clojure
 (head (list 1 2 3))  ;; => 1
 (first (list 1 2 3)) ;; => 1
 
@@ -86,7 +91,7 @@ nil
 
 ## Dictionaries
 
-```lisp
+```clojure
 ; Create a dict
 (dict :one 1 :two 2) ;; => {"one" 1, "two" 2}
 
@@ -102,7 +107,7 @@ nil
 
 ## More complex functions
 
-```lisp
+```clojure
 ; Apply a function to all items in a list
 (map inc (list 1 2 3)) ;; => (2 3 4)
 
@@ -123,7 +128,7 @@ nil
 
 ## Variables
 
-```lisp
+```clojure
 ; Define and evaluate a variable
 (def x (list 1 2 3))
 x ;; => (1 2 3)
@@ -132,20 +137,13 @@ x ;; => (1 2 3)
 (sum x) ;; => 6
 ```
 
-## Misc
+## If
 
-```lisp
-; Outputting to the terminal
-(println "hello world!")
-;; hello world!
-;; => nil
-
-; If
+```clojure
 (if (< 4.9 5)
-  (println "yep!")
-  (println "nope!"))
-;; yep!
-;; => nil
+  "under"
+  "over")
+;; => "under"
 
 (if (< 5.1 5)
   (println "yep!")
@@ -156,7 +154,7 @@ x ;; => (1 2 3)
 
 ## Creating functions
 
-```lisp
+```clojure
 ; A function has 2 forms, one with the parameters and one with the body.
 ; Here's a function that adds 10 to its argument
 (fn (x) (+ 10 x))
@@ -192,11 +190,18 @@ x ;; => (1 2 3)
 (add-first-two 1 2)   ;; => 3
 (add-first-two 1 2 3) ;; => 3
 (add-first-two 1)     ;; !> wrong number of arguments (1 for 2+)
+
+
+; Defining a function is a very common thing to do, therefore there is a shorthand.
+; This will do the same thing as the example above:
+(defn add-first-two
+  (a b & args)
+  (+ a b))
 ```
 
 ### Count the amount of 5:s in a list
 
-```lisp
+```clojure
 ; The list we will operate on
 (def fives (list 1 5 2 3 5 8 5)) ; 5 occurs 3 times.
 
@@ -212,20 +217,20 @@ x ;; => (1 2 3)
 
 ### Print a beautiful pyramid
 
-```lisp
+```clojure
 ; Print one row in the pyramid
-(def print-row
-  (fn (length)
-    (println (* "#" length)))) ; We use the fact that the host platform (Ruby) can multiply strings
+(defn print-row
+  (length)
+  (println (* "#" length))) ; We use the fact that the host platform (Ruby) can multiply text
 
 ; Print the entire pyramid
-(def print-pyramid
-  (fn (height current-width)
+(defn print-pyramid
+  (height current-width)
     (if (= current-width height)
       nil
       (do
         (print-row current-width)
-        (print-pyramid height (inc current-width))))))
+        (print-pyramid height (inc current-width)))))
 
 ; Do it!
 (print-pyramid 10 1)
@@ -242,10 +247,28 @@ x ;; => (1 2 3)
 
 ## Interoperability
 
-```lisp
+```clojure
 ; The . function allows for Ruby interoperability.
 (. "01011101" :to_i 2) ;; => 93
 
 (def parse_binary (fn (bin) (. bin :to_i 2)))
 (parse_binary "01011101") ;; => 93
 ```
+
+## Macros
+
+Since Läsp code is just lists, it is quite easy to write code that restructures
+those lists before they are executed - this is what macros do. If you would
+like to make a function that takes a form that performs maths in a more natural
+order like `(1 + 2)`, then you can accomplish it with macros:
+
+```clojure
+(def infix
+  (macro (form)
+    (list (second form) (first form) (last form))))
+
+; This will be restructured to `(+ 4 5)` before it is run.
+(infix (4 + 5)) ; => 9
+```
+
+Refer to the [macro](DOCUMENTATION.md#macro) section in the documentation for a more detailed explanation.

data/README.md

@@ -19,6 +19,10 @@ gem install lasp
 
 # If it doesn't work you might need to sudo
 sudo gem install lasp
+
+# You can update to the latest version the same way:
+gem update lasp
+sudo gem update lasp
 ```
 
 ## Running
@@ -35,6 +39,9 @@ lasp path/to/program.lasp
 
 ## The language
 
+Please reference the [documentation](DOCUMENTATION.md) for specific definitions
+and examples of all available functions.
+
 ### Examples
 
 More advanced examples can be found in [EXAMPLES.md](EXAMPLES.md), you can also
@@ -53,17 +60,6 @@ x ;; => 6
 (inc 5) ;; => 6
 ```
 
-### Data types
-
-Supports these datatypes (implemented as their Ruby counterparts)
-
-- integer
-- float
-- boolean
-- nil
-- string
-- list
-- dict
 
 ### Comments
 
@@ -74,87 +70,6 @@ Comments start with a `;` and end at the end of a line
 (+ 1 2) ; This is also a comment
 ```
 
-### Functions in corelib
-
-Implemented as Ruby lambdas.
-
-- `+`
-- `-`
-- `*`
-- `/`
-- `<`
-- `>`
-- `<=`
-- `>=`
-- `=`
-- `list`
-- `head`
-- `tail`
-- `cons`
-- `dict`
-- `get`
-- `assoc`
-- `dissoc`
-- `not`
-- `println`
-- `apply`
-- `.`
-- `require`
-
-### Special forms
-
-Implemented as special cases while evaluating.
-
-- `def`
-- `fn`
-- `do`
-- `if`
-- `quote`
-- `macro`
-
-### Functions in stdlib
-
-Implemented in Läsp itself.
-
-- `first` (alias of `head`)
-- `rest` (alias of `tail`)
-- `inc`
-- `dec`
-- `nil?`
-- `empty?`
-- `not=`
-- `second`
-- `mod`
-- `complement`
-- `even?`
-- `odd?`
-- `zero?`
-- `len`
-- `nth`
-- `last`
-- `reverse`
-- `map`
-- `reduce`
-- `filter`
-- `sum`
-- `take`
-- `drop`
-- `range`
-- `max`
-- `min`
-- `ruby-method`
-- `str->list`
-- `list->str`
-- `->str`
-- `pipe`
-- `reverse-str`
-
-## Macros in stdlib
-
-- `defn`
-- `defm`
-- `macroexpand`
-
 ## Developing
 
 ### Run the specs

data/bin/lasp

@@ -7,5 +7,5 @@ Lasp::load_stdlib!
 if ARGV.first
   Lasp::execute_file(ARGV.first)
 else
-  Lasp::repl
+  Lasp::Repl.run
 end

data/lib/lasp.rb

@@ -1,6 +1,8 @@
 require "lasp/version"
-require "lasp/eval"
+require "lasp/env"
 require "lasp/parser"
+require "lasp/interpreter"
+require "lasp/ext"
 
 module Lasp
   STDLIB_PATH = File.expand_path("../lasp/stdlib.lasp", __FILE__)
@@ -12,7 +14,7 @@ module Lasp
   end
 
   def execute(program, env = global_env)
-    Lasp::eval(Parser.new.parse(program), env)
+    Interpreter.eval(Parser.parse(program), env)
   end
 
   def load_stdlib!

data/lib/lasp/corelib.rb

@@ -2,27 +2,29 @@ require "lasp"
 
 module Lasp
   CORELIB = {
-    :+          => -> (*args)         { args.reduce(:+)                          },
-    :-          => -> (*args)         { args.reduce(:-)                          },
-    :*          => -> (*args)         { args.reduce(:*)                          },
-    :/          => -> (*args)         { args.reduce(:/)                          },
-    :<          => -> (*args)         { args.each_cons(2).all? { |a, b| a < b }  },
-    :>          => -> (*args)         { args.each_cons(2).all? { |a, b| a > b }  },
-    :<=         => -> (*args)         { args.each_cons(2).all? { |a, b| a <= b } },
-    :>=         => -> (*args)         { args.each_cons(2).all? { |a, b| a >= b } },
-    :"="        => -> (*args)         { args.uniq.count == 1                     },
-    :list       => -> (*args)         { args                                     },
-    :head       => -> (list)          { list.first                               },
-    :tail       => -> (list)          { list.drop(1)                             },
-    :cons       => -> (item, list)    { [item] + list                            },
-    :dict       => -> (*args)         { Hash[*args]                              },
-    :get        => -> (key, a)        { a[key]                                   },
-    :assoc      => -> (a, key, val)   { a.dup.tap { |a| a[key] = val  }          },
-    :dissoc     => -> (a, key)        { a.dup.tap { |a| a.delete(key) }          },
-    :not        => -> (arg)           { !arg                                     },
-    :println    => -> (output)        { puts output                              },
-    :apply      => -> (f, list)       { f.call(*list)                            },
-    :"."        => -> (obj, m, *args) { obj.send(m, *args)                       },
-    :require    => -> (path)          { Lasp::execute_file(path)                 },
+    :+          => -> (*args)         { args.reduce(:+)                            },
+    :-          => -> (*args)         { args.reduce(:-)                            },
+    :*          => -> (*args)         { args.reduce(:*)                            },
+    :/          => -> (*args)         { args.reduce(:/)                            },
+    :<          => -> (*args)         { args.each_cons(2).all? { |a, b| a < b  }   },
+    :>          => -> (*args)         { args.each_cons(2).all? { |a, b| a > b  }   },
+    :<=         => -> (*args)         { args.each_cons(2).all? { |a, b| a <= b }   },
+    :>=         => -> (*args)         { args.each_cons(2).all? { |a, b| a >= b }   },
+    :"="        => -> (*args)         { args.uniq.count == 1                       },
+    :list       => -> (*args)         { args                                       },
+    :head       => -> (list)          { list.first                                 },
+    :tail       => -> (list)          { list.drop(1)                               },
+    :cons       => -> (item, list)    { [item] + list                              },
+    :dict       => -> (*args)         { Hash[*args]                                },
+    :get        => -> (key, a)        { a[key]                                     },
+    :assoc      => -> (a, key, val)   { a.dup.tap { |a| a[key] = val  }            },
+    :dissoc     => -> (a, key)        { a.dup.tap { |a| a.delete(key) }            },
+    :not        => -> (arg)           { !arg                                       },
+    :print      => -> (output)        { STDOUT.print(output)                       },
+    :println    => -> (output)        { STDOUT.puts(output)                        },
+    :readln     => -> ()              { STDIN.gets.chomp                           },
+    :apply      => -> (f, list)       { f.call(*list)                              },
+    :"."        => -> (obj, m, *args) { obj.send(m, *args)                         },
+    :require    => -> (p)             { execute_file(File.expand_path(p, __dir__)) },
   }
 end

data/lib/lasp/errors.rb

@@ -1,3 +1,6 @@
 module Lasp
-  SyntaxError = Class.new(StandardError)
+  LaspError     = Class.new(StandardError)
+  SyntaxError   = Class.new(LaspError)
+  ArgumentError = Class.new(LaspError)
+  NameError     = Class.new(LaspError)
 end

data/lib/lasp/ext.rb

@@ -0,0 +1,33 @@
+class Array
+  def to_s
+    "(#{ map(&:inspect).join(" ") })"
+  end
+
+  def inspect
+    to_s
+  end
+
+  def call(index)
+    self[index]
+  end
+end
+
+class Hash
+  def to_s
+    "{#{ map { |pair| pair.map(&:inspect).join(" ") }.join(", ") }}"
+  end
+
+  def inspect
+    to_s
+  end
+
+  def call(index)
+    self[index]
+  end
+end
+
+class Symbol
+  def inspect
+    to_s
+  end
+end

data/lib/lasp/fn.rb

@@ -1,4 +1,4 @@
-require "lasp/eval"
+require "lasp/interpreter"
 require "lasp/params"
 require "lasp/errors"
 
@@ -13,7 +13,7 @@ module Lasp
     end
 
     def call(*args)
-      Lasp::eval(body, env_with_args(args))
+      Interpreter.eval(body, env_with_args(args))
     end
 
     def inspect