lasp 0.6.0 → 0.7.0

checksums.yaml

@@ -1,7 +1,7 @@
 ---
 SHA1:
-  metadata.gz: d33419ed01e48e150efc416ec315d24df18ee6b9
-  data.tar.gz: 2c9c32ff5dad6abe4fab2f55fdeb0e9ab3cf36b2
+  metadata.gz: c6fb8d2312d17d1d15be5e17ad26569f839789b3
+  data.tar.gz: 7c473de16a4e3c017af92fa423ef976c04b369ce
 SHA512:
-  metadata.gz: 9c38c3f9008608f4bec13175e7e03fe545e6767d2292fa9f3d75eca7151068c520ffe2e0e4546fc15a438adc409223a369e11b9db43ed3ea386193d8de19cb07
-  data.tar.gz: efd637931a8d72b480384118186df5060e975e1bd1b60afac9e628060631204ddf4005f5cc0f76f93d15b5628030df1024c62130bb8cd8a58f2d4848bd693c5a
+  metadata.gz: b4a30a116ecfeefb43ea5f02c2dd11c4686da9d338625d70ecaa11cad37284b3de0a4e7110d80fda135da9ece294902a839b715676dfc3084eaba8863ca89c6a
+  data.tar.gz: 2d39bb873b1698e27f462c141185561582cf8749a8cc920b97041658b657207018ae7f28b2d485afe6c189c1ee5f63f2f80833222f4ac0f0c6a4ff9958763ab0

data/CHANGELOG.md

@@ -1,5 +1,22 @@
 # Läsp changelog
 
+## v0.7.0
+
+- Arity is now enforced in function calls and will throw errors when mismatched
+- Add methods to stdlib:
+    - `zero?`
+    - `list->str`
+    - `str->list`
+    - `->str`
+    - `reverse-str`
+    - `ruby-method`
+    - `pipe`
+- REPL improvements:
+    - Automatically close trailing parentheses
+    - Change error prompt from `*>` to `!>`
+    - Return nil when pressing Ctrl+D (this used to cause an error)
+- Many refactorings
+
 ## v0.6.0
 
 - `<` and `>` now return false when given a list of equal items, they all **have to** increase or decrease.

data/README.md

@@ -78,6 +78,8 @@ Implemented as Ruby lambdas.
 - `/`
 - `<`
 - `>`
+- `<=`
+- `>=`
 - `=`
 - `list`
 - `head`
@@ -113,6 +115,7 @@ Implemented in Läsp itself.
 - `complement`
 - `even?`
 - `odd?`
+- `zero?`
 - `len`
 - `nth`
 - `last`
@@ -126,6 +129,12 @@ Implemented in Läsp itself.
 - `range`
 - `max`
 - `min`
+- `ruby-method`
+- `str->list`
+- `list->str`
+- `->str`
+- `pipe`
+- `reverse-str`
 
 ## Developing
 

data/lib/lasp/eval.rb

@@ -4,33 +4,53 @@ require "lasp/env"
 module Lasp
   module_function
 
-  def eval(ast, env)
-    case ast
-    when Symbol then env.fetch(ast)
-    when Array  then eval_form(ast, env)
-    else ast
+  def eval(form, env)
+    case form
+    when Symbol then env.fetch(form)
+    when Array  then eval_form(form, env)
+    else form
     end
   end
 
   def eval_form(form, env)
     head, *tail = *form
 
-    if head == :def
-      key, value = tail
-      env[key] = Lasp::eval(value, env)
-    elsif head == :fn
-      params, func = tail
-      -> (*args) { Lasp::eval(func, env.merge(Hash[params.zip(args)])) }
-    elsif head == :do
-      tail.map { |form| Lasp::eval(form, env) }.last
-    elsif head == :if
-      conditional, true_form, false_form = tail
-      Lasp::eval(conditional, env) ? Lasp::eval(true_form, env) : Lasp::eval(false_form, env)
-    elsif Proc === head
-      head.(*tail)
-    else
-      fn = Lasp::eval(head, env)
-      fn.(*tail.map { |form| Lasp::eval(form, env) })
+    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)
+    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) })
+  end
+
+  def def_special_form(form, env)
+    key, value = form
+    env[key] = Lasp::eval(value, env)
+  end
+
+  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)]))
+    }
+  end
+
+  def do_special_form(form, env)
+    form.map { |form| Lasp::eval(form, env) }.last
+  end
+
+  def if_special_form(form, env)
+    conditional, true_form, false_form = form
+    Lasp::eval(conditional, env) ? Lasp::eval(true_form, env) : Lasp::eval(false_form, env)
+  end
 end

data/lib/lasp/repl.rb

@@ -10,12 +10,31 @@ module Lasp
     puts "((( Läsp v#{Lasp::VERSION} REPL (ctrl+c to exit) )))\n\n"
     loop do
       begin
-        input =  Readline.readline("lasp> ", true)
-        result = Lasp::execute(input)
+        history = true
+        input   = Readline.readline("lasp> ", history).to_s
+        input   = autoclose_parentheses(input)
+        result  = Lasp::execute(input)
         puts "   => #{result.inspect}"
       rescue
-        puts "   *> #{$!}"
+        puts "   !> #{$!}"
       end
     end
   end
+
+  def autoclose_parentheses(input)
+    num_opens  = input.chars.select { |c| c == "(" }.count
+    num_closes = input.chars.select { |c| c == ")" }.count
+
+    if num_opens > num_closes
+      missing_closes = num_opens - num_closes
+
+      puts "   ?> Appending #{missing_closes} missing closing parentheses:"
+      corrected_input = input + (")" * missing_closes)
+      puts "   ?> #{corrected_input}"
+
+      corrected_input
+    else
+      input
+    end
+  end
 end

data/lib/lasp/stdlib.lasp

@@ -11,7 +11,7 @@
 ; If a list is empty
 (def empty?
   (fn (coll)
-    (= (head coll) nil)))
+    (= nil (head coll))))
 
 ; Modulus
 (def mod
@@ -23,11 +23,15 @@
 
 ; If a number is even
 (def even?
-  (fn (x) (= (mod x 2) 0)))
+  (fn (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)))
+
 ; Length of a list
 (def len
   (fn (coll)
@@ -38,7 +42,7 @@
 ; Gets an item in a list by index
 (def nth
   (fn (index coll)
-    (if (= 0 index)
+    (if (zero? index)
       (head coll)
       (nth (dec index) (tail coll)))))
 
@@ -85,14 +89,14 @@
 ; Take x items from list
 (def take
   (fn (num coll)
-    (if (= num 0)
+    (if (zero? num)
       (list)
       (cons (head coll) (take (dec num) (tail coll))))))
 
 ; Drop x items from list
 (def drop
   (fn (num coll)
-    (if (= num 0)
+    (if (zero? num)
       coll
       (drop (dec num) (tail coll)))))
 
@@ -118,3 +122,30 @@
       (fn (acc item) (if (> acc item) item acc))
       (head coll)
       (tail coll))))
+
+; Takes a method from Ruby-land and returns a Lasp function
+(def ruby-method
+  (fn (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))
+
+; 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
+      (pipe ((head fns) item) (tail fns)))))
+
+; Reverses a string
+(def reverse-str
+  (fn (str)
+    (pipe str (list str->list reverse list->str))))

data/lib/lasp/version.rb

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

metadata

@@ -1,14 +1,14 @@
 --- !ruby/object:Gem::Specification
 name: lasp
 version: !ruby/object:Gem::Version
-  version: 0.6.0
+  version: 0.7.0
 platform: ruby
 authors:
 - Jimmy Börjesson
 autorequire: 
 bindir: bin
 cert_chain: []
-date: 2016-01-17 00:00:00.000000000 Z
+date: 2016-01-18 00:00:00.000000000 Z
 dependencies:
 - !ruby/object:Gem::Dependency
   name: bundler