lasp 0.8.0 → 0.9.0

data/lib/lasp/interpreter.rb

@@ -0,0 +1,79 @@
+require "lasp/fn"
+require "lasp/macro"
+require "lasp/errors"
+
+module Lasp
+  class Interpreter
+    def self.eval(form, env)
+      new.eval(form, env)
+    end
+
+    def eval(form, env)
+      case form
+      when Symbol then resolve_symbol(form, env)
+      when Array  then eval_form(form, env)
+      else form
+      end
+    end
+
+    private
+
+    def eval_form(form, env)
+      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 :quote then quote_special_form(tail, env)
+      when :macro then macro_special_form(tail, env)
+      else call_function(head, tail, env)
+      end
+    end
+
+    def resolve_symbol(symbol, env)
+      env.fetch(symbol)
+    rescue KeyError
+      raise NameError, "#{symbol} is not present in this context"
+    end
+
+    def call_function(symbol, args, env)
+      fn = eval(symbol, env)
+
+      case fn
+      when Macro then eval(fn.(*args), env)
+      else fn.(*args.map { |form| eval(form, env) })
+      end
+    end
+
+    def def_special_form(form, env)
+      key, value = form
+      fail ArgumentError, "you can only def symbols" unless Symbol === key
+      env[key] = eval(value, env)
+    end
+
+    def fn_special_form(form, env)
+      params, func = form
+      Fn.new(params, func, env)
+    end
+
+    def do_special_form(form, env)
+      form.map { |form| eval(form, env) }.last
+    end
+
+    def if_special_form(form, env)
+      conditional, true_form, false_form = form
+      eval(conditional, env) ? eval(true_form, env) : 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
+end

data/lib/lasp/params.rb

@@ -1,3 +1,5 @@
+require "lasp/errors"
+
 module Lasp
   class Params
     attr_reader :param_list
@@ -14,7 +16,7 @@ module Lasp
 
     def rest
       unless variadic?
-        fail ArgumentError, "A non-variadic function does not have rest-arguments"
+        fail LaspError, "a non-variadic function does not have rest-arguments"
       end
       param_list.last
     end
@@ -46,27 +48,34 @@ module Lasp
     private
 
     def validate_params!
+      validate_list!
       validate_single_ampersand!
       validate_single_rest_parameter!
       validate_unique_parameter_names!
     end
 
+    def validate_list!
+      unless Array === param_list
+        fail SyntaxError, "parameters must be a list"
+      end
+    end
+
     def validate_unique_parameter_names!
       unless param_list.uniq.length == param_list.length
-        fail ArgumentError, "Parameter names have to be unique."
+        fail SyntaxError, "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
+      invalid_rest_argument_usage! unless param_list.select { |p| p == :& }.length <= 1
     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
+      invalid_rest_argument_usage! if variadic? && param_list[-2] != :&
+    end
+
+    def invalid_rest_argument_usage!
+      fail SyntaxError, "rest-arguments may only be used once, at the end, with a single binding"
     end
   end
 end

data/lib/lasp/parser.rb

@@ -1,5 +1,9 @@
 module Lasp
   class Parser
+    def self.parse(program)
+      new.parse(program)
+    end
+
     def parse(program)
       build_ast(tokenize(sanitize(program)))
     end
@@ -14,18 +18,24 @@ module Lasp
       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)
+      case token
+      when "(" then form(tokens)
+      when "'" then quote(tokens)
+      else atom(token)
+      end
+    end
+
+    def form(tokens)
+      form = []
+      while tokens.first != ")"
+        form << build_ast(tokens)
       end
+      tokens.shift
+      form
+    end
+
+    def quote(tokens)
+      [:quote] << build_ast(tokens)
     end
 
     def atom(token)
@@ -36,7 +46,7 @@ module Lasp
       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
+      when /:([^\s]+)/     then String($1) # Symbol style strings are actually just strings
       else token.to_sym
       end
     end

data/lib/lasp/repl.rb

@@ -1,43 +1,64 @@
 require "lasp"
 require "lasp/parser"
-require "lasp/representation"
 require "readline"
 
 module Lasp
-  module_function
-
-  def repl
-    trap("SIGINT") { puts "\n\nBye!"; exit }
-
-    puts "((( Läsp v#{Lasp::VERSION} REPL (ctrl+c to exit) )))\n\n"
-    loop do
-      begin
-        history = true
-        input   = Readline.readline("lasp> ", history).to_s
-        input   = autoclose_parentheses(input)
-        result  = Lasp::execute(input)
-        puts "   => #{result.inspect}"
-      rescue
-        puts "   !> #{$!}"
+  class Repl
+    def self.run
+      new.run
+    end
+
+    def run
+      trap("SIGINT") { puts "\n\nBye!"; exit }
+
+      puts "((( Läsp v#{Lasp::VERSION} REPL (ctrl+c to exit) )))\n\n"
+      loop do
+        begin
+          history = true
+          input   = Readline.readline(prompt, history).to_s
+          input   = autoclose_parentheses(input)
+          result  = Lasp::execute(input)
+          print_result(result)
+        rescue => error
+          print_error(error)
+        end
       end
     end
-  end
 
-  def autoclose_parentheses(input)
-    tokens     = Parser.new.tokenize(input)
-    num_opens  = tokens.select { |t| t == "(" }.count
-    num_closes = tokens.select { |t| t == ")" }.count
+    private
+
+    def autoclose_parentheses(input)
+      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
+
+        print_info "Appending #{missing_closes} missing closing parentheses:"
+        corrected_input = input + (")" * missing_closes)
+        print_info "#{corrected_input}"
 
-    if num_opens > num_closes
-      missing_closes = num_opens - num_closes
+        corrected_input
+      else
+        input
+      end
+    end
+
+    def prompt
+      "lasp> "
+    end
 
-      puts "   ?> Appending #{missing_closes} missing closing parentheses:"
-      corrected_input = input + (")" * missing_closes)
-      puts "   ?> #{corrected_input}"
+    def print_error(error)
+      puts "   !> #{error.class}: #{error.message}"
+    end
+
+    def print_info(message)
+      puts "   ?> #{message}"
+    end
 
-      corrected_input
-    else
-      input
+    def print_result(result)
+      puts "   => #{result.inspect}"
     end
   end
 end

data/lib/lasp/stdlib.lasp

@@ -1,168 +1,172 @@
-(require "./lib/lasp/stdmacros.lasp")
+(require "stdmacros.lasp")
 
 ; Aliases
 (def first head)
 (def rest tail)
 
 ; Increment a number by one
-(def inc (fn (x) (+ x 1)))
+(defn inc (x) (+ x 1))
 
 ; Decrement a number by one
-(def dec (fn (x) (- x 1)))
+(defn dec (x) (- x 1))
 
 ; Is it nil?
-(def nil? (fn (arg) (= nil arg)))
+(defn nil? (arg) (= nil arg))
 
 ; If a list is empty
-(def empty?
-  (fn (coll)
-    (nil? (head coll))))
+(defn empty?
+  (coll)
+  (nil? (head coll)))
 
 ; If all arguments are not equal
-(def not=
-  (fn (& args)
-    (not (apply = args))))
+(defn not= (& args)
+  (not (apply = args)))
 
 ; The second item in a list
-(def second
-  (fn (coll)
-    (head (tail coll))))
+(defn second (coll)
+  (head (tail coll)))
 
 ; Modulus
-(def mod
-  (fn (x y) (- x (* (/ x y) y))))
+(defn mod (x y)
+  (- x (* (/ x y) y)))
 
 ; Returns a function that does the opposite of the given function
-(def complement
-  (fn (f) (fn (x) (not (f x)))))
+(defn complement (f)
+  (fn (x) (not (f x))))
 
 ; If a number is even
-(def even?
-  (fn (x) (zero? (mod x 2))))
+(defn even? (x)
+  (zero? (mod x 2)))
 
 ; If a number is odd
 (def odd? (complement even?))
 
 ; If a number is zero
-(def zero?
-  (fn (x) (= 0 x)))
+(defn zero? (x)
+  (= 0 x))
 
 ; Length of a list
-(def len
-  (fn (coll)
-    (if (empty? coll)
-      0
-      (inc (len (tail coll))))))
+(defn len (coll)
+  (if (empty? coll)
+    0
+    (inc (len (tail coll)))))
 
 ; Gets an item in a list by index
-(def nth
-  (fn (index coll)
-    (if (zero? index)
-      (head coll)
-      (nth (dec index) (tail coll)))))
+(defn nth (index coll)
+  (if (zero? index)
+    (head coll)
+    (nth (dec index) (tail coll))))
 
 ; Last item in list
-(def last
-  (fn (coll)
-    (nth (dec (len coll)) coll)))
+(defn last (coll)
+  (nth (dec (len coll)) coll))
 
 ; Reverses a list
-(def reverse
-  (fn (coll)
-    (reduce (fn (acc item) (cons item acc)) (list) coll)))
+(defn reverse (coll)
+  (reduce
+    (fn (acc item) (cons item acc))
+    (list)
+    coll))
 
 ; Apply f to all items in list
-(def map
-  (fn (f coll)
-    (if (nil? (head coll))
-      coll
-      (cons
-        (f (head coll))
-        (map f (tail coll))))))
+(defn map (f coll)
+  (if (nil? (head coll))
+    coll
+    (cons
+      (f (head coll))
+      (map f (tail coll)))))
 
 ; Go through a list passing an accumulator and each item of the list through f
-; f(acc item)
-(def reduce
-  (fn (f acc coll)
-    (if (empty? coll)
-      acc
-      (reduce f (f acc (head coll)) (tail coll)))))
+; f has the signature (acc item)
+(defn reduce (f acc coll)
+  (if (empty? coll)
+    acc
+    (reduce f (f acc (head coll)) (tail coll))))
 
 ; Filter a list of items based on a function
-(def filter
-  (fn (f coll)
-    (reduce
-      (fn (acc item) (if (f item) (cons item acc) acc))
-      (list)
-      (reverse coll))))
+(defn filter (f coll)
+  (reduce
+    (fn (acc item) (if (f item) (cons item acc) acc))
+    (list)
+    (reverse coll)))
 
 ; Sum of all items in a list
-(def sum
-  (fn (coll)
-    (reduce + 0 coll)))
+(defn sum (coll)
+  (reduce + 0 coll))
 
-; Take x items from list
-(def take
-  (fn (num coll)
-    (if (zero? num)
-      (list)
-      (cons (head coll) (take (dec num) (tail coll))))))
+; Take n items from list
+(defn take (n coll)
+  (if (zero? n)
+    (list)
+    (cons (head coll) (take (dec n) (tail coll)))))
 
 ; Drop x items from list
-(def drop
-  (fn (num coll)
-    (if (zero? num)
-      coll
-      (drop (dec num) (tail coll)))))
+(defn drop (num coll)
+  (if (zero? num)
+    coll
+    (drop (dec num) (tail coll))))
 
 ; Exclusive range
-(def range
-  (fn (from to)
-    (if (>= from to)
-      (list)
-      (cons from (range (inc from) to)))))
+(defn range (from to)
+  (if (>= from to)
+    (list)
+    (cons from (range (inc from) to))))
 
 ; Highest value in list
-(def max
-  (fn (coll)
-    (reduce
-      (fn (acc item) (if (< acc item) item acc))
-      (head coll)
-      (tail coll))))
+(defn max (coll)
+  (reduce
+    (fn (acc item) (if (< acc item) item acc))
+    (head coll)
+    (tail coll)))
 
 ; Lowest value in list
-(def min
-  (fn (coll)
-    (reduce
-      (fn (acc item) (if (> acc item) item acc))
-      (head coll)
-      (tail coll))))
+(defn min (coll)
+  (reduce
+    (fn (acc item) (if (> acc item) item acc))
+    (head coll)
+    (tail coll)))
+
+; The naming suggests that it is an implementation detail of `every`, that
+; needs to be named to allow recursion. If it has value in itself, it should be
+; renamed and documented.
+(defn every* (n coll acc)
+  (if (empty? coll)
+    acc
+    (every*
+      n
+      (drop n coll)
+      (cons (first coll) acc))))
+
+; Every Nth item in list
+(defn every (n coll)
+  (reverse (every* n coll (list))))
 
 ; Takes a method from Ruby-land and returns a Lasp function
-(def ruby-method
-  (fn (meth)
-    (fn (arg)
-      (. arg meth))))
+(defn ruby-method (meth)
+  (fn (arg) (. arg meth)))
 
-; Convert string to list
-(def str->list (ruby-method :chars))
 
-; Convert list to string
-(def list->str (ruby-method :join))
+; Conversion functions
+(def text->list (ruby-method :chars)) ; Convert text to list
+(def list->text (ruby-method :join))  ; Convert list to text
+(def ->text     (ruby-method :to_s))  ; Convert to text
+(def ->integer  (ruby-method :to_i))  ; Convert to int
+(def ->decimal  (ruby-method :to_f))  ; Convert to decimal
 
-; Convert most things to a string
-(def ->str (ruby-method :to_s))
 
 ; Pass a value in order through a list of functions
-(def pipe
-  (fn (item & fns)
-    (if (empty? fns)
-      item
-      ; 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 str->list reverse list->str)))
+(defn pipe (item & fns)
+  (if (empty? fns)
+    item
+    ; 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 text
+(defn reverse-text (text)
+  (pipe text text->list reverse list->text))
+
+; Reads an answer to a question
+(defn prompt (question)
+  (print question)
+  (readln))