lasp 0.7.0 → 0.8.0

checksums.yaml

@@ -1,7 +1,7 @@
 ---
 SHA1:
-  metadata.gz: c6fb8d2312d17d1d15be5e17ad26569f839789b3
-  data.tar.gz: 7c473de16a4e3c017af92fa423ef976c04b369ce
+  metadata.gz: 1eca69fd40314669d431772d434b59de33dc9695
+  data.tar.gz: 4a99615567d3b848585e9e330f3cebaa1a1f6fc8
 SHA512:
-  metadata.gz: b4a30a116ecfeefb43ea5f02c2dd11c4686da9d338625d70ecaa11cad37284b3de0a4e7110d80fda135da9ece294902a839b715676dfc3084eaba8863ca89c6a
-  data.tar.gz: 2d39bb873b1698e27f462c141185561582cf8749a8cc920b97041658b657207018ae7f28b2d485afe6c189c1ee5f63f2f80833222f4ac0f0c6a4ff9958763ab0
+  metadata.gz: 42594879ac26a139dc2a39b1dd9990314cbd65efa6f44acbb8d99f303e359863eccac73ae59a06dd54c77921d4094b6a156ccf83dd7022caa54d0250956ae828
+  data.tar.gz: 8831f6fa41e43311dd348de39dda2876b129d1c09853c000f76a4ad2d5a9ff7e62c1b2334d309b9da0657ad5d330eee5e2461df5bacd2ce5decf8c08f63d9e34

data/CHANGELOG.md

@@ -1,6 +1,40 @@
 # Läsp changelog
 
-## v0.7.0
+## v0.8.0 - 2016-02-04
+
+### Added
+
+- Macro system
+    - `quote` special form to defer evaluation
+    - `macro` special form that works like a function but receives its arguments before evaluation
+    - `'` syntax sugar for quoting, `'f` becomes `(quote f)`
+- Variadic functions
+    - Both functions and macros can now accept rest-arguments with an `&`
+- Additions to core library
+    - `require`
+    - `apply`
+- Additions to standard library
+    - `nil?`
+    - `not=`
+    - `second`
+    - macros
+        - `defn`
+        - `defm`
+        - `macroexpand`
+- Lispy looking datastructures
+    - The REPL now displays `[:f, 12, 34]` as `(f 12 34)`
+
+### Changed
+
+- Rename `hash-map` to `dict`
+- `pipe` now uses rest-arguments instead of taking a list of functions
+
+### Fixed
+
+- Parentheses inside strings are now handled correctly
+- Negative numbers parsed correctly instead of appearing as symbols
+
+## v0.7.0 - 2016-01-18
 
 - Arity is now enforced in function calls and will throw errors when mismatched
 - Add methods to stdlib:
@@ -17,19 +51,19 @@
     - Return nil when pressing Ctrl+D (this used to cause an error)
 - Many refactorings
 
-## v0.6.0
+## v0.6.0 - 2016-01-17
 
 - `<` and `>` now return false when given a list of equal items, they all **have to** increase or decrease.
 - Add `<=` and `>=` to the core library.
 - Fix stack overflowing when using `range` with an upper bound less than the lower bound, this now returns an empty list.
 
-## v0.5.0
+## v0.5.0 - 2015-09-24
 
 - Merge `lasp-repl` command into `lasp`, it starts when not provided with a filename.
 - Don't send env to functions implemented as Ruby procs, it was never used.
 - Specs as default rake task.
 
-## v0.4.0
+## v0.4.0 - 2015-08-09
 
 Implicit do-blocks around files. You can now do this...:
 
@@ -45,12 +79,12 @@ anything after would seemingly inexplicably not be run.
 
 **This is only enabled in files, not every form of evaluation.**
 
-## v0.3.2
+## v0.3.2 - 2015-08-09
 
 Fix bug in `do` - it accidentally returned part of the AST, now it correctly
 returns the result of the last expression.
 
-## v0.3.1
+## v0.3.1 - 2015-08-09
 
 Make readline support actually work once released to rubygems by implementing it directly in Ruby.
 
@@ -58,11 +92,11 @@ It does not seem to remember history between runs like rlwrap did, but trying
 to deploy an interactive bash script to rubygems is just too much of a headache
 and this is almost as nice with just a single line of Ruby.
 
-## v0.3.0
+## v0.3.0 - 2015-08-09
 
 Add readline support in the REPL using rlwrap, this makes the REPL a **lot** nicer to use.
 
-## v0.2.0
+## v0.2.0 - 2015-08-08
 
 Add support for hash-maps with the following added functions to the core library:
 
@@ -73,10 +107,10 @@ Add support for hash-maps with the following added functions to the core library
 
 Also adds exit instructions to the REPL welcome message.
 
-## v0.1.1
+## v0.1.1 - 2015-08-02
 
 Fix broken `lasp` executable.
 
-## v0.1.0
+## v0.1.0 - 2015-08-01
 
 First release.

data/EXAMPLES.md

@@ -1,16 +1,15 @@
 # Examples
 
+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
+
+In this document output is shown with ;; and normal comments with ;.
+
+## Data types
+
 ```lisp
-; Notes:
-;
-; 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
-;
-; In this document output is shown with ;; and normal comments with ;.
-
-; --- Data types ---
 ; Number types
 1
 1.5
@@ -29,13 +28,15 @@ nil
 ; Lists
 (list 1 2 3) ;; => [1, 2, 3]
 (list)       ;; => []
+```
 
-; --- Basic function calls ---
+## Basic function calls
 
+```lisp
 ; inc is a function that increments its argument, and 1 is the single argument
 (inc 1) ;; => 2
 
-; Simple maths functions takes any number of arguments
+; Simple maths functions take any number of arguments
 (/ 20 2)     ;; => 10
 (+ 1 3 5)    ;; => 9
 (* 2 5 6 10) ;; => 600
@@ -47,16 +48,18 @@ nil
 
 ; Boolean inversion
 (not true) ;; => false
+```
 
-; --- List operations ---
+## List operations
 
+```lisp
 (head (list 1 2 3))  ;; => 1
 (first (list 1 2 3)) ;; => 1
 
-(tail (list 1 2 3)) ;; => [2, 3]
-(rest (list 1 2 3)) ;; => [2, 3]
+(tail (list 1 2 3)) ;; => (2 3)
+(rest (list 1 2 3)) ;; => (2 3)
 
-(cons 0 (list 1 2 3)) ;; => [0, 1, 2, 3]
+(cons 0 (list 1 2 3)) ;; => (0 1 2 3)
 
 (nth 1 (list 1 2 3)) ;; => 2
 (nth 3 (list 1 2 3)) ;; => nil
@@ -66,38 +69,42 @@ nil
 (get 3 (list 1 2 3)) ;; => nil
 
 ; assoc returns a new array with the specified index updated
-(assoc (list 1 2 3) 0 "one") ;; => ["one", 2, 3]
+(assoc (list 1 2 3) 0 "one") ;; => ("one" 2 3)
 
 (last (list 1 2 3)) ;; => 3
 
-(take 2 (list 1 2 3)) ;; => [1, 2]
-(drop 2 (list 1 2 3)) ;; => [3]
+(take 2 (list 1 2 3)) ;; => (1 2)
+(drop 2 (list 1 2 3)) ;; => (3)
 
 (max (list 1 3 2)) ;; => 3
 
-(reverse (list 1 2 3)) ;; => [3, 2, 1]
+(reverse (list 1 2 3)) ;; => (3 2 1)
 
 ; Ranges
-(range 1 10) ;; => [1, 2, 3, 4, 5, 6, 7, 8, 9]
+(range 1 10) ;; => (1 2 3 4 5 6 7 8 9)
+```
 
-; --- Hash-maps ---
+## Dictionaries
 
-; Create a hash-map
-(hash-map :one 1 :two 2) ;; => {"one"=>1, "two"=>2}
+```lisp
+; Create a dict
+(dict :one 1 :two 2) ;; => {"one" 1, "two" 2}
 
-; get also works with hash-maps
-(get :one (hash-map :one 1 :two 2)) ;; => 1
+; get also works with dicts
+(get :one (dict :one 1 :two 2)) ;; => 1
 
-; assoc works with hash-maps too
-(assoc (hash-map :one 1 :two 2) :three 3) ;; => {"one"=>1, "two"=>2, "three"=>3}
+; assoc works with dicts too
+(assoc (dict :one 1 :two 2) :three 3) ;; => {"one" 1, "two" 2, "three" 3}
 
 ; dissoc removes values
-(dissoc (hash-map :one 1 :two 2) :one) ;; => {"two"=>2}
+(dissoc (dict :one 1 :two 2) :one) ;; => {"two" 2}
+```
 
-; --- More complex functions ---
+## More complex functions
 
+```lisp
 ; Apply a function to all items in a list
-(map inc (list 1 2 3)) ;; => [2, 3, 4]
+(map inc (list 1 2 3)) ;; => (2 3 4)
 
 ; Accumulate a value with a function
 ; The function (here +) will receive a memo (the running total)
@@ -111,19 +118,23 @@ nil
 (reduce * 1 (list 1 2 3)) ;; => 6
 
 ; Filtering
-(filter odd? (list 1 2 3)) ;; => [1, 3]
+(filter odd? (list 1 2 3)) ;; => (1 3)
+```
 
-; --- Variables ---
+## Variables
 
+```lisp
 ; Define and evaluate a variable
 (def x (list 1 2 3))
-x ;; => [1, 2, 3]
+x ;; => (1 2 3)
 
 ; Use it in a function
 (sum x) ;; => 6
+```
 
---- Misc ---
+## Misc
 
+```lisp
 ; Outputting to the terminal
 (println "hello world!")
 ;; hello world!
@@ -141,25 +152,51 @@ x ;; => [1, 2, 3]
   (println "nope!"))
 ;; nope!
 ;; => nil
+```
 
-; --- Creating functions ---
+## Creating functions
 
+```lisp
 ; 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))
 
-; You can call it just like one of the named functions
+; You can call it just like one of the named functions by placing the entire
+; fn-form at the first position
 ((fn (x) (+ 10 x)) 50) ;; => 60
 
-; You can give it a name yourself
+; You can give it a name by defining it
 (def add-ten (fn (x) (+ 10 x)))
 (add-ten 50) ;; => 60
 
 (def square (fn (x) (* x x)))
 (square 5) ;; => 25
 
-; --- Count the amount of 5:s in a list ---
+; Arity is enforced when calling a function, this yields an error:
+(square 5 2) ;; !> wrong number of arguments (2 for 1)
+
+
+; Rest arguments are passed in as a list to the binding after the &
+(def last-argument
+  (fn (& args)
+    (last args)))
+
+(last-argument 1 2)   ;; => 2
+(last-argument 1 2 3) ;; => 3
+
+; You can also have mandatory positional arguments and rest arguments at the same time
+(def add-first-two
+  (fn (a b & args)
+    (+ a b)))
+
+(add-first-two 1 2)   ;; => 3
+(add-first-two 1 2 3) ;; => 3
+(add-first-two 1)     ;; !> wrong number of arguments (1 for 2+)
+```
 
+### Count the amount of 5:s in a list
+
+```lisp
 ; The list we will operate on
 (def fives (list 1 5 2 3 5 8 5)) ; 5 occurs 3 times.
 
@@ -171,19 +208,19 @@ x ;; => [1, 2, 3]
   0            ; (2) We start counting from 0
   fives)       ; (3) We operate over the previously defined `fives` list.
 ;; => 3
+```
 
-; --- Print a beautiful pyramid ---
+### Print a beautiful pyramid
 
+```lisp
 ; Print one row in the pyramid
 (def print-row
-  (fn
-    (length)
+  (fn (length)
     (println (* "#" length)))) ; We use the fact that the host platform (Ruby) can multiply strings
 
 ; Print the entire pyramid
 (def print-pyramid
-  (fn
-    (height current-width)
+  (fn (height current-width)
     (if (= current-width height)
       nil
       (do
@@ -201,10 +238,11 @@ x ;; => [1, 2, 3]
 ;; #######
 ;; ########
 ;; #########
+```
 
+## Interoperability
 
-; --- Interoperability ---
-
+```lisp
 ; The . function allows for Ruby interoperability.
 (. "01011101" :to_i 2) ;; => 93
 

data/README.md

@@ -1,8 +1,14 @@
 # Läsp
 
-A very simple programming language implemented in Ruby.
+A Lisp implementation in Ruby.
 
-It is just a toy Lisp implementation and should not be used seriously by anyone.
+## Features
+
+- Very concise [core library](lib/lasp/corelib.rb) written in Ruby
+- [Standard library](lib/lasp/stdlib.lisp) written in Läsp itself
+- Interactive REPL with auto-closing of missing trailing parentheses
+- Fully functional macro system
+- Interoperability with Ruby
 
 ## Installation
 
@@ -57,7 +63,7 @@ Supports these datatypes (implemented as their Ruby counterparts)
 - nil
 - string
 - list
-- hash-map
+- dict
 
 ### Comments
 
@@ -85,13 +91,15 @@ Implemented as Ruby lambdas.
 - `head`
 - `tail`
 - `cons`
-- `hash-map`
+- `dict`
 - `get`
 - `assoc`
 - `dissoc`
 - `not`
 - `println`
+- `apply`
 - `.`
+- `require`
 
 ### Special forms
 
@@ -101,6 +109,8 @@ Implemented as special cases while evaluating.
 - `fn`
 - `do`
 - `if`
+- `quote`
+- `macro`
 
 ### Functions in stdlib
 
@@ -110,7 +120,10 @@ Implemented in Läsp itself.
 - `rest` (alias of `tail`)
 - `inc`
 - `dec`
+- `nil?`
 - `empty?`
+- `not=`
+- `second`
 - `mod`
 - `complement`
 - `even?`
@@ -136,6 +149,12 @@ Implemented in Läsp itself.
 - `pipe`
 - `reverse-str`
 
+## Macros in stdlib
+
+- `defn`
+- `defm`
+- `macroexpand`
+
 ## Developing
 
 ### Run the specs

data/lib/lasp/corelib.rb

@@ -1,3 +1,5 @@
+require "lasp"
+
 module Lasp
   CORELIB = {
     :+          => -> (*args)         { args.reduce(:+)                          },
@@ -13,12 +15,14 @@ module Lasp
     :head       => -> (list)          { list.first                               },
     :tail       => -> (list)          { list.drop(1)                             },
     :cons       => -> (item, list)    { [item] + list                            },
-    :"hash-map" => -> (*args)         { Hash[*args]                              },
+    :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)                 },
   }
 end

data/lib/lasp/errors.rb

@@ -0,0 +1,3 @@
+module Lasp
+  SyntaxError = Class.new(StandardError)
+end

data/lib/lasp/eval.rb

@@ -1,5 +1,6 @@
-require "lasp/parser"
 require "lasp/env"
+require "lasp/fn"
+require "lasp/macro"
 
 module Lasp
   module_function
@@ -16,18 +17,23 @@ module Lasp
     head, *tail = *form
 
     case head
-    when :def then def_special_form(tail, env)
-    when :fn  then fn_special_form(tail, env)
-    when :do  then do_special_form(tail, env)
-    when :if  then if_special_form(tail, env)
-    when Proc then head.(*tail)
+    when :def   then def_special_form(tail, env)
+    when :fn    then fn_special_form(tail, env)
+    when :do    then do_special_form(tail, env)
+    when :if    then if_special_form(tail, env)
+    when :quote then quote_special_form(tail, env)
+    when :macro then macro_special_form(tail, env)
     else call_function(head, tail, env)
     end
   end
 
   def call_function(symbol, args, env)
     fn = Lasp::eval(symbol, env)
-    fn.(*args.map { |form| Lasp::eval(form, env) })
+
+    case fn
+    when Macro then Lasp::eval(fn.(*args), env)
+    else fn.(*args.map { |form| Lasp::eval(form, env) })
+    end
   end
 
   def def_special_form(form, env)
@@ -37,12 +43,7 @@ module Lasp
 
   def fn_special_form(form, env)
     params, func = form
-    -> (*args) {
-      unless args.count == params.count
-        fail ArgumentError, "wrong number of arguments (#{args.count} for #{params.count})"
-      end
-      Lasp::eval(func, env.merge(Hash[params.zip(args)]))
-    }
+    Fn.new(params, func, env)
   end
 
   def do_special_form(form, env)
@@ -53,4 +54,13 @@ module Lasp
     conditional, true_form, false_form = form
     Lasp::eval(conditional, env) ? Lasp::eval(true_form, env) : Lasp::eval(false_form, env)
   end
+
+  def quote_special_form(form, _)
+    form.first
+  end
+
+  def macro_special_form(form, env)
+    params, func = form
+    Macro.new(params, func, env)
+  end
 end

data/lib/lasp/fn.rb

@@ -0,0 +1,49 @@
+require "lasp/eval"
+require "lasp/params"
+require "lasp/errors"
+
+module Lasp
+  class Fn
+    attr_reader :params, :body, :env
+
+    def initialize(params, body, env)
+      @params = Params.new(params)
+      @body   = body
+      @env    = env
+    end
+
+    def call(*args)
+      Lasp::eval(body, env_with_args(args))
+    end
+
+    def inspect
+      class_name = self.class.name.split("::").last
+      "#<#{class_name} #{params}>"
+    end
+
+    private
+
+    def env_with_args(args)
+      enforce_arity!(args)
+
+      params_with_args = params
+                           .ordered
+                           .zip(args.take(params.length))
+                           .to_h
+
+      if params.variadic?
+        params_with_args[params.rest] = args.drop(params.length)
+      end
+
+      env.merge(params_with_args)
+    end
+
+    def enforce_arity!(args)
+      wrong_number_of_args!(args) unless params.matches_arity?(args.length)
+    end
+
+    def wrong_number_of_args!(args)
+      fail ArgumentError, "wrong number of arguments (#{args.length} for #{params.arity})"
+    end
+  end
+end

data/lib/lasp/macro.rb

@@ -0,0 +1,8 @@
+require "lasp/fn"
+
+module Lasp
+  class Macro < Fn
+    # All that's needed is the type marker to let eval
+    # know to pass in the arguments unevaluated.
+  end
+end

data/lib/lasp/parameters.rb

@@ -0,0 +1,93 @@
+module Lasp
+  module Parameters
+    def self.new(params)
+      if params.include?(:&)
+        RestParameters.new(params)
+      else
+        FixedParameters.new(params)
+      end
+    end
+
+    class FixedParameters
+      attr_reader :parameter_list
+
+      def initialize(parameter_list)
+        @parameter_list = parameter_list
+        valid_signature!
+      end
+
+      def to_h(args)
+        enforce_arity!(args)
+        Hash[parameter_list.zip(args)]
+      end
+
+      def to_s
+        "(" + parameter_list.join(" ") + ")"
+      end
+
+      private
+
+      def enforce_arity!(args)
+        if args.count != arity
+          fail ArgumentError, "wrong number of arguments (#{args.count} for #{arity})"
+        end
+      end
+
+      def valid_signature!
+        if duplicate_parameter?
+          fail SyntaxError, "Parameter names have to be unique. a is used more than once"
+        end
+      end
+
+      def duplicate_parameter?
+        parameter_list.uniq.length != parameter_list.length
+      end
+
+      def arity
+        parameter_list.count
+      end
+    end
+
+    class RestParameters < FixedParameters
+      def to_h(args)
+        enforce_arity!(args)
+
+        ordered = parameter_list[0, minimum_arguments]
+        rest    = parameter_list.last
+
+        env = ordered.zip(args.take(ordered.length))
+        env << [ rest, args.drop(ordered.length) ]
+
+        Hash[env]
+      end
+
+      private
+
+      def valid_signature!
+        if multiple_rest_arguments? || ampersand_not_second_to_last?
+          fail SyntaxError, "Rest-arguments may only be used once, at the end, with a single binding."
+        end
+        super
+      end
+
+      def multiple_rest_arguments?
+        parameter_list.select { |b| b == :& }.length > 1
+      end
+
+      def ampersand_not_second_to_last?
+        parameter_list.find_index(:&) != minimum_arguments
+      end
+
+      def minimum_arguments
+        parameter_list.count - 2
+      end
+
+      def enforce_arity!(args)
+        if args.count < minimum_arguments
+          fail ArgumentError, "wrong number of arguments (#{args.count} for #{minimum_arguments}+)"
+        end
+      end
+    end
+
+  end
+end

data/lib/lasp/params.rb

@@ -0,0 +1,72 @@
+module Lasp
+  class Params
+    attr_reader :param_list
+
+    def initialize(param_list)
+      @param_list = param_list
+
+      validate_params!
+    end
+
+    def ordered
+      param_list.take_while { |p| p != :& }
+    end
+
+    def rest
+      unless variadic?
+        fail ArgumentError, "A non-variadic function does not have rest-arguments"
+      end
+      param_list.last
+    end
+
+    def variadic?
+      param_list.include?(:&)
+    end
+
+    def arity
+      ordered.length.to_s + (variadic? ? "+" : "")
+    end
+
+    def matches_arity?(num_args)
+      if variadic?
+        num_args >= length
+      else
+        num_args == length
+      end
+    end
+
+    def length
+      ordered.length
+    end
+
+    def to_s
+      "(" + param_list.join(" ") + ")"
+    end
+
+    private
+
+    def validate_params!
+      validate_single_ampersand!
+      validate_single_rest_parameter!
+      validate_unique_parameter_names!
+    end
+
+    def validate_unique_parameter_names!
+      unless param_list.uniq.length == param_list.length
+        fail ArgumentError, "Parameter names have to be unique."
+      end
+    end
+
+    def validate_single_ampersand!
+      unless param_list.select { |p| p == :& }.length <= 1
+        fail ArgumentError, "Rest-arguments may only be used once, at the end, with a single binding."
+      end
+    end
+
+    def validate_single_rest_parameter!
+      if variadic? && param_list[-2] != :&
+        fail ArgumentError, "Rest-arguments may only be used once, at the end, with a single binding."
+      end
+    end
+  end
+end

data/lib/lasp/parser.rb

@@ -1,47 +1,48 @@
 module Lasp
-  module_function
+  class Parser
+    def parse(program)
+      build_ast(tokenize(sanitize(program)))
+    end
 
-  def parse(program)
-    build_ast(tokenize(sanitize(program)))
-  end
+    def tokenize(string)
+      string.scan(/(?:(?:[^\s"()']|"[^"]*")+|[()'])/)
+    end
 
-  def build_ast(tokens)
-    return if tokens.empty?
-    token = tokens.shift
+    private
 
-    if token == "("
-      form = []
-      while tokens.first != ")"
-        form << build_ast(tokens)
+    def build_ast(tokens)
+      return if tokens.empty?
+      token = tokens.shift
+
+      if token == "("
+        form = []
+        while tokens.first != ")"
+          form << build_ast(tokens)
+        end
+        tokens.shift
+        form
+      elsif token == "'"
+        [:quote] << build_ast(tokens)
+      else
+        atom(token)
       end
-      tokens.shift
-      form
-    else
-      atom(token)
     end
-  end
 
-  def tokenize(string)
-    string
-      .gsub("(", " ( ")
-      .gsub(")", " ) ")
-      .scan(/(?:[^\s"]|"[^"]*")+/)
-  end
-
-  def atom(token)
-    case token
-    when "true"        then true
-    when "false"       then false
-    when "nil"         then nil
-    when /\A\d+\z/     then Integer(token)
-    when /\A\d+.\d+\z/ then Float(token)
-    when /"(.*)"/      then String($1)
-    when /:(\w+)/      then String($1) # Symbol style strings are actually just strings
-    else token.to_sym
+    def atom(token)
+      case token
+      when "true"          then true
+      when "false"         then false
+      when "nil"           then nil
+      when /\A-?\d+\z/     then Integer(token)
+      when /\A-?\d+.\d+\z/ then Float(token)
+      when /"(.*)"/        then String($1)
+      when /:(\w+)/        then String($1) # Symbol style strings are actually just strings
+      else token.to_sym
+      end
     end
-  end
 
-  def sanitize(string)
-    string.gsub(/;.*$/, "")
+    def sanitize(string)
+      string.gsub(/;.*$/, "")
+    end
   end
 end

data/lib/lasp/repl.rb

@@ -1,4 +1,6 @@
 require "lasp"
+require "lasp/parser"
+require "lasp/representation"
 require "readline"
 
 module Lasp
@@ -22,8 +24,9 @@ module Lasp
   end
 
   def autoclose_parentheses(input)
-    num_opens  = input.chars.select { |c| c == "(" }.count
-    num_closes = input.chars.select { |c| c == ")" }.count
+    tokens     = Parser.new.tokenize(input)
+    num_opens  = tokens.select { |t| t == "(" }.count
+    num_closes = tokens.select { |t| t == ")" }.count
 
     if num_opens > num_closes
       missing_closes = num_opens - num_closes

data/lib/lasp/representation.rb

@@ -0,0 +1,17 @@
+class Array
+  def inspect
+    "(#{ map(&:inspect).join(" ") })"
+  end
+end
+
+class Symbol
+  def inspect
+    to_s
+  end
+end
+
+class Hash
+  def inspect
+    "{#{ map { |pair| pair.map(&:inspect).join(" ")}.join(", ") }}"
+  end
+end

data/lib/lasp/stdlib.lasp

@@ -1,3 +1,5 @@
+(require "./lib/lasp/stdmacros.lasp")
+
 ; Aliases
 (def first head)
 (def rest tail)
@@ -8,10 +10,23 @@
 ; Decrement a number by one
 (def dec (fn (x) (- x 1)))
 
+; Is it nil?
+(def nil? (fn (arg) (= nil arg)))
+
 ; If a list is empty
 (def empty?
   (fn (coll)
-    (= nil (head coll))))
+    (nil? (head coll))))
+
+; If all arguments are not equal
+(def not=
+  (fn (& args)
+    (not (apply = args))))
+
+; The second item in a list
+(def second
+  (fn (coll)
+    (head (tail coll))))
 
 ; Modulus
 (def mod
@@ -59,7 +74,7 @@
 ; Apply f to all items in list
 (def map
   (fn (f coll)
-    (if (= nil (head coll))
+    (if (nil? (head coll))
       coll
       (cons
         (f (head coll))
@@ -140,12 +155,14 @@
 
 ; Pass a value in order through a list of functions
 (def pipe
-  (fn (item fns)
+  (fn (item & fns)
     (if (empty? fns)
       item
-      (pipe ((head fns) item) (tail fns)))))
+      ; Note that you need to take special care when recursing with rest
+      ; arguments, hence the use of apply.
+      (apply pipe (cons ((head fns) item) (tail fns))))))
 
 ; Reverses a string
 (def reverse-str
   (fn (str)
-    (pipe str (list str->list reverse list->str))))
+    (pipe str str->list reverse list->str)))

data/lib/lasp/stdmacros.lasp

@@ -0,0 +1,38 @@
+; Shorthand for defining macros
+;
+;   (defm m (form) (reverse form))
+; expands to:
+;   (def m (macro (form) (reverse form)))
+(def defm
+  (macro (name params body)
+         (list 'def name
+               (list 'macro params body))))
+
+; Shorthand for defining functions
+;
+;   (defn f (x) (+ x 1))
+; expands to:
+;   (def f (fn (x) (do (+ x 1))))
+(defm defn
+  (name params & body)
+  (list 'def name
+        (list 'fn params (cons 'do body))))
+
+; See unevaluated form the macro expands to for debugging macros
+;
+; This simply uses the fact that `apply` already has this effect
+; of expanding macros and makes the syntax a bit nicer, you can
+; also just use `apply` directly as shown below.
+;
+; Example:
+;     (macroexpand (defn f (x) (+ 1 x)))
+;
+; expands to:
+;     (apply defn (quote (f (x) (+ 1 x))))
+;
+; which in is evaulated and returns this form:
+;     (def f (fn (x) (do (+ 1 x))))
+(defm macroexpand
+  (form)
+  (list 'apply (first form)
+        (list 'quote (rest form))))

data/lib/lasp/version.rb

@@ -1,3 +1,3 @@
 module Lasp
-  VERSION = "0.7.0"
+  VERSION = "0.8.0"
 end

data/lib/lasp.rb

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

metadata

@@ -1,14 +1,14 @@
 --- !ruby/object:Gem::Specification
 name: lasp
 version: !ruby/object:Gem::Version
-  version: 0.7.0
+  version: 0.8.0
 platform: ruby
 authors:
 - Jimmy Börjesson
 autorequire: 
 bindir: bin
 cert_chain: []
-date: 2016-01-18 00:00:00.000000000 Z
+date: 2016-02-04 00:00:00.000000000 Z
 dependencies:
 - !ruby/object:Gem::Dependency
   name: bundler
@@ -58,10 +58,17 @@ files:
 - lib/lasp.rb
 - lib/lasp/corelib.rb
 - lib/lasp/env.rb
+- lib/lasp/errors.rb
 - lib/lasp/eval.rb
+- lib/lasp/fn.rb
+- lib/lasp/macro.rb
+- lib/lasp/parameters.rb
+- lib/lasp/params.rb
 - lib/lasp/parser.rb
 - lib/lasp/repl.rb
+- lib/lasp/representation.rb
 - lib/lasp/stdlib.lasp
+- lib/lasp/stdmacros.lasp
 - lib/lasp/version.rb
 homepage: https://github.com/alcesleo/lasp
 licenses: