lasp 0.3.1 → 0.3.2

checksums.yaml

@@ -1,7 +1,7 @@
 ---
 SHA1:
-  metadata.gz: 381e41bcebb8866b57ce8e12c1fae2e6f0ec399b
-  data.tar.gz: fb12d78b778f646298d85db2563d83d6e8d92308
+  metadata.gz: fe53c128ac7fb00e1dcf9e1e89db3596e9557690
+  data.tar.gz: c7a42762434a1192b531bc980fc65ba5b84d06f9
 SHA512:
-  metadata.gz: de8fa110484e874537da3c2e328205ed8fe5b209556eff571bd9aea2dc5679ff916f121dcdca6caac59a04d6d21fd0cc45ba1b971dfa5eff65c9e345464cd6d3
-  data.tar.gz: d7005142bca0d159e3af25515bb61698fb97a76e6968abfec82a2112509c3fd80a0b425284acc4fb240a3bd2dcdbf1b3ef34adc78ecb02ece89e8c604bdca318
+  metadata.gz: 18a21269e6682b786c215d16b286ea6ff4533de458dea3099536e9f1b8f709c8cf568f0725a527c398469ccd941213f1c4a8c86f8b6c23f954a8f88c1e64cc44
+  data.tar.gz: 315b73b00df83f029848a3b36dd8b7e3a7fb03bf22109cd4298adff8b6b57eb6bee8afa9c81ba665735d6e5a6962a05f36943feb6481e42419cbdaf86f4f5f20

data/CHANGELOG.md

@@ -1,5 +1,10 @@
 # Läsp changelog
 
+## v0.3.2
+
+Fix bug in `do` - it accidentally returned part of the AST, now it correctly
+returns the result of the last expression.
+
 ## v0.3.1
 
 Make readline support actually work once released to rubygems by implementing it directly in Ruby.

data/EXAMPLES.md

@@ -10,6 +10,7 @@
 ;
 ; In this document output is shown with ;; and normal comments with ;.
 
+; --- Data types ---
 ; Number types
 1
 1.5
@@ -29,7 +30,8 @@ nil
 (list 1 2 3) ;; => [1, 2, 3]
 (list)       ;; => []
 
-; Basic function call
+; --- Basic function calls ---
+
 ; inc is a function that increments its argument, and 1 is the single argument
 (inc 1) ;; => 2
 
@@ -46,7 +48,7 @@ nil
 ; Boolean inversion
 (not true) ;; => false
 
-; List operations
+; --- List operations ---
 
 (head (list 1 2 3))  ;; => 1
 (first (list 1 2 3)) ;; => 1
@@ -78,7 +80,9 @@ nil
 ; Ranges
 (range 1 10) ;; => [1, 2, 3, 4, 5, 6, 7, 8, 9]
 
-; Hash-maps
+; --- Hash-maps ---
+
+; Create a hash-map
 (hash-map :one 1 :two 2) ;; => {"one"=>1, "two"=>2}
 
 ; get also works with hash-maps
@@ -90,6 +94,8 @@ nil
 ; dissoc removes values
 (dissoc (hash-map :one 1 :two 2) :one) ;; => {"two"=>2}
 
+; --- More complex functions ---
+
 ; Apply a function to all items in a list
 (map inc (list 1 2 3)) ;; => [2, 3, 4]
 
@@ -107,9 +113,16 @@ nil
 ; Filtering
 (filter odd? (list 1 2 3)) ;; => [1, 3]
 
-; Variables
-(def x (list 1 2 3)) ;; => [1, 2, 3]
-x                    ;; => [1, 2, 3]
+; --- Variables ---
+
+; Define and evaluate a variable
+(def x (list 1 2 3))
+x ;; => [1, 2, 3]
+
+; Use it in a function
+(sum x) ;; => 6
+
+--- Misc ---
 
 ; Outputting to the terminal
 (println "hello world!")
@@ -129,7 +142,8 @@ x                    ;; => [1, 2, 3]
 ;; nope!
 ;; => nil
 
-; Functions
+; --- Creating functions ---
+
 ; 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))
@@ -140,4 +154,60 @@ x                    ;; => [1, 2, 3]
 ; You can give it a name yourself
 (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 ---
+
+; The list we will operate on
+(def fives (list 1 5 2 3 5 8 5)) ; 5 occurs 3 times.
+
+(reduce        ; Reduce takes a function(1), a starting value(2) and a list(3).
+  (fn (acc x)  ; (1) The function in turn takes an accumulator and an item in the list.
+    (if (= x 5)  ; If the item is five:
+      (inc acc)  ; We increment the accumulator and move on to the next item.
+      acc))      ; Otherwise we return the total as is.
+  0            ; (2) We start counting from 0
+  fives)       ; (3) We operate over the previously defined `fives` list.
+;; => 3
+
+; --- Print a beautiful pyramid ---
+
+; 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
+
+; Print the entire pyramid
+(def print-pyramid
+  (fn
+    (height current-width)
+    (if (= current-width height)
+      nil
+      (do
+        (print-row current-width)
+        (print-pyramid height (inc current-width))))))
+
+; Do it!
+(print-pyramid 10 1)
+;; #
+;; ##
+;; ###
+;; ####
+;; #####
+;; ######
+;; #######
+;; ########
+;; #########
+
+
+; --- Interoperability ---
+
+; The . function allows for Ruby interoperability.
+(. "01011101" :to_i 2) ;; => 93
+
+(def parse_binary (fn (bin) (. bin :to_i 2)))
+(parse_binary "01011101") ;; => 93
 ```

data/lib/lasp/corelib.rb

@@ -1,22 +1,22 @@
 module Lasp
   CORELIB = {
-    :+          => -> (_, *args)       { args.reduce(:+)                 },
-    :-          => -> (_, *args)       { args.reduce(:-)                 },
-    :*          => -> (_, *args)       { args.reduce(:*)                 },
-    :/          => -> (_, *args)       { args.reduce(:/)                 },
-    :<          => -> (_, *args)       { args.sort == args               },
-    :>          => -> (_, *args)       { args.sort.reverse == args       },
-    :"="        => -> (_, *args)       { args.uniq.count == 1            },
-    :list       => -> (_, *args)       { args                            },
-    :head       => -> (_, list)        { list.first                      },
-    :tail       => -> (_, list)        { list.drop(1)                    },
-    :cons       => -> (_, item, list)  { [item] + list                   },
-    :"hash-map" => -> (_, *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                     },
-    :"."        => -> (_, obj, meth)   { obj.send(meth)                  }
+    :+          => -> (_, *args)         { args.reduce(:+)                 },
+    :-          => -> (_, *args)         { args.reduce(:-)                 },
+    :*          => -> (_, *args)         { args.reduce(:*)                 },
+    :/          => -> (_, *args)         { args.reduce(:/)                 },
+    :<          => -> (_, *args)         { args.sort == args               },
+    :>          => -> (_, *args)         { args.sort.reverse == args       },
+    :"="        => -> (_, *args)         { args.uniq.count == 1            },
+    :list       => -> (_, *args)         { args                            },
+    :head       => -> (_, list)          { list.first                      },
+    :tail       => -> (_, list)          { list.drop(1)                    },
+    :cons       => -> (_, item, list)    { [item] + list                   },
+    :"hash-map" => -> (_, *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                     },
+    :"."        => -> (_, obj, m, *args) { obj.send(m, *args)              },
   }
 end

data/lib/lasp/eval.rb

@@ -23,7 +23,7 @@ module Lasp
       # Use env from context to properly scope closures
       -> (_, *args) { eval(func, env.merge(Hash[params.zip(args)])) }
     elsif head == :do
-      tail.each do |form| eval(form, env) end
+      tail.map { |form| eval(form, env) }.last
     elsif head == :if
       conditional, true_form, false_form = tail
       eval(conditional, env) ? eval(true_form, env) : eval(false_form, env)

data/lib/lasp/version.rb

@@ -1,3 +1,3 @@
 module Lasp
-  VERSION = "0.3.1"
+  VERSION = "0.3.2"
 end

metadata

@@ -1,7 +1,7 @@
 --- !ruby/object:Gem::Specification
 name: lasp
 version: !ruby/object:Gem::Version
-  version: 0.3.1
+  version: 0.3.2
 platform: ruby
 authors:
 - Jimmy Börjesson