lasp 0.1.1 → 0.2.0

checksums.yaml

@@ -1,7 +1,7 @@
 ---
 SHA1:
-  metadata.gz: dee1734ba4772f9dcfb12147560abb355156f19a
-  data.tar.gz: a19ccfcb3dffdbfa201aa8741c08f1042a3f93b8
+  metadata.gz: 68dbe78c047584740bc6f5347986c79f91509e9f
+  data.tar.gz: 59e1576d2daba17a0a3226d19582e01f5f645f64
 SHA512:
-  metadata.gz: 473d868e6bcb18813bc05822d096a3094b608c6f7c76f302c3e82bf0cb2d78ae8f4a65ec47950d1bfa02326b75ebf3eb46c069178d2e8de63e27d0a3b9e2878d
-  data.tar.gz: 2371be9bb30387b469eb510f7d6acaff16d2784913898e90e7bc677be88d4a4763510f9b74c438e0e7e5664fd089532f5baf8130787d99baf5cadebeae5d1934
+  metadata.gz: 86c24ac9ca3517ce90176832250197d27508dc2ab9fc4823c2e22195b0f9ae9f8f724f0d8e13837bbf17809553f4b06de91c84b3f3a37d667782d801da032931
+  data.tar.gz: 3d20db7ce8ffba5e3e6aba5fffbbfc064fb91f5058910987ee5b0bf26bc0e4373fdd7e064d92883cb1c882e0d99e9d022cd1de53ae00f484c1b88420e15875f9

data/CHANGELOG.md

@@ -1,5 +1,16 @@
 # Läsp changelog
 
+## v0.2.0
+
+Add support for hash-maps with the following added functions to the core library:
+
+- `hash-map`
+- `get`
+- `assoc`
+- `dissoc`
+
+Also adds exit instructions to the REPL welcome message.
+
 ## v0.1.1
 
 Fix broken `lasp` executable.

data/EXAMPLES.md

@@ -0,0 +1,143 @@
+# Examples
+
+```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 ;.
+
+; Number types
+1
+1.5
+
+; Booleans and nil
+true
+false
+nil
+
+; Strings
+"hello world!" ;; => "hello world!"
+
+; Symbol-style strings (not its own type)
+:hey ;; => "hey"
+
+; Lists
+(list 1 2 3) ;; => [1, 2, 3]
+(list)       ;; => []
+
+; Basic function call
+; 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
+(/ 20 2)     ;; => 10
+(+ 1 3 5)    ;; => 9
+(* 2 5 6 10) ;; => 600
+
+; Equality operators also do
+(= 1 5)     ;; => false
+(= 3 3 3)   ;; => true
+(> 3 2 1 0) ;; => true
+
+; Boolean inversion
+(not true) ;; => false
+
+; List operations
+
+(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]
+
+(cons 0 (list 1 2 3)) ;; => [0, 1, 2, 3]
+
+(nth 1 (list 1 2 3)) ;; => 2
+(nth 3 (list 1 2 3)) ;; => nil
+
+; get does the same as nth on lists (although implemented differently)
+(get 1 (list 1 2 3)) ;; => 2
+(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]
+
+(last (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]
+
+; Ranges
+(range 1 10) ;; => [1, 2, 3, 4, 5, 6, 7, 8, 9]
+
+; Hash-maps
+(hash-map :one 1 :two 2) ;; => {"one"=>1, "two"=>2}
+
+; get also works with hash-maps
+(get :one (hash-map :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}
+
+; dissoc removes values
+(dissoc (hash-map :one 1 :two 2) :one) ;; => {"two"=>2}
+
+; Apply a function to all items in a list
+(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)
+; and each item in the list in order. The 0 is the starting value
+(reduce + 0 (list 1 2 3)) ;; => 6
+
+; This is how sum is implemented
+(sum (list 1 2 3)) ;; => 6
+
+; The starting value is important.
+(reduce * 1 (list 1 2 3)) ;; => 6
+
+; Filtering
+(filter odd? (list 1 2 3)) ;; => [1, 3]
+
+; Variables
+(def x (list 1 2 3)) ;; => [1, 2, 3]
+x                    ;; => [1, 2, 3]
+
+; Outputting to the terminal
+(println "hello world!")
+;; hello world!
+;; => nil
+
+; If
+(if (< 4.9 5)
+  (println "yep!")
+  (println "nope!"))
+;; yep!
+;; => nil
+
+(if (< 5.1 5)
+  (println "yep!")
+  (println "nope!"))
+;; nope!
+;; => nil
+
+; 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))
+
+; You can call it just like one of the named functions
+((fn (x) (+ 10 x)) 50) ;; => 60
+
+; You can give it a name yourself
+(def add-ten (fn (x) (+ 10 x)))
+(add-ten 50) ;; => 60
+```

data/README.md

@@ -1,23 +1,50 @@
 # Läsp
 
-A very simple Lisp implementation in Ruby. Run `lasp-repl` to play around with
-it, or `lasp path/to/program.lasp` to execute a Läsp file.
+A very simple programming language implemented in Ruby.
+
+It is just a toy Lisp implementation and should not be used seriously by anyone.
+
+## Installation
+
+It needs Ruby to work, on Mac or most Linux OS:s it's already there and you can simply
+
+```bash
+gem install lasp
+
+# If it doesn't work you might need to sudo
+sudo gem install lasp
+```
+
+## Running
+
+After installing there are two commands available to you:
+
+```bash
+# An interactive prompt that lets you play with the language
+lasp-repl
+
+# Run lasp-files
+lasp path/to/program.lasp
+```
 
 ## The language
 
 ### Examples
 
+More advanced examples can be found in [EXAMPLES.md](EXAMPLES.md), you can also
+look at the [standard library](lib/lasp/stdlib.lasp) which is implemented in
+Läsp itself.
+
 ```lisp
-(+ 1 2 3)
-; => 6
+(+ 1 2 3) ;; => 6
 
 (def x 5)
-x
-; => 6
+x ;; => 6
+
+(sum (list 5 10 15)) ;; => 30
 
 (def inc (fn (x) (+ x 1)))
-(inc 5)
-; => 6
+(inc 5) ;; => 6
 ```
 
 ### Data types
@@ -29,6 +56,7 @@ Supports these datatypes (implemented as their Ruby counterparts)
 - boolean
 - nil
 - string
+- list
 
 ### Comments
 
@@ -50,11 +78,17 @@ Implemented as Ruby lambdas.
 - `<`
 - `>`
 - `=`
+- `list`
 - `head`
 - `tail`
 - `cons`
+- `hash-map`
+- `get`
+- `assoc`
+- `dissoc`
 - `not`
 - `println`
+- `.`
 
 ### Special forms
 
@@ -94,4 +128,18 @@ Implemented in Läsp itself.
 
 ## Developing
 
-Run the tests with `rspec`.
+### Run the specs
+
+```bash
+rspec
+
+# or more verbose
+rspec --format=documentation
+```
+
+### Dev REPL
+
+```bash
+# This is basically just a shorthand for `rake install && lasp-repl`
+rake repl
+```

data/Rakefile

@@ -1 +1,6 @@
 require "bundler/gem_tasks"
+
+desc "Install and laund the Läsp REPL"
+task :repl => [:install] do
+  sh "lasp-repl"
+end

data/bin/lasp

@@ -3,4 +3,9 @@
 require "lasp"
 Lasp::load_stdlib!
 
+unless ARGV.first
+  puts "You have to supply a path"
+  exit!
+end
+
 Lasp::execute_file(ARGV.first)

data/bin/lasp-repl

@@ -5,13 +5,13 @@ Lasp::load_stdlib!
 
 trap("SIGINT") { puts "\n\nBye!"; exit! }
 
-puts "((( Läsp v#{Lasp::VERSION} REPL )))\n\n"
+puts "((( Läsp v#{Lasp::VERSION} REPL (ctrl+c to exit) )))\n\n"
 loop do
   begin
     print "lasp> "
     result = Lasp::execute(gets.chomp)
-    puts "  =>> #{result.inspect}"
+    puts "   => #{result.inspect}"
   rescue
-    puts "  **> #{$!}"
+    puts "   *> #{$!}"
   end
 end

data/lib/lasp.rb

@@ -2,6 +2,8 @@ require "lasp/version"
 require "lasp/eval"
 
 module Lasp
+  STDLIB_PATH = File.expand_path("../lasp/stdlib.lasp", __FILE__)
+
   module_function
 
   def execute_file(path)
@@ -13,6 +15,6 @@ module Lasp
   end
 
   def load_stdlib!
-    Lasp::execute_file(File.expand_path("../lasp/stdlib.lasp", __FILE__))
+    Lasp::execute_file(STDLIB_PATH)
   end
 end

data/lib/lasp/corelib.rb

@@ -1,18 +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             },
-    :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, meth)   { obj.send(meth)                  }
   }
 end

data/lib/lasp/stdlib.lasp

@@ -70,7 +70,7 @@
         acc
         (reduce f (f acc (head coll)) (tail coll)))))
 
-  ; Fil er a list of items based on a function
+  ; Filter a list of items based on a function
   (def filter
     (fn (f coll)
       (reduce

data/lib/lasp/version.rb

@@ -1,3 +1,3 @@
 module Lasp
-  VERSION = "0.1.1"
+  VERSION = "0.2.0"
 end

metadata

@@ -1,14 +1,14 @@
 --- !ruby/object:Gem::Specification
 name: lasp
 version: !ruby/object:Gem::Version
-  version: 0.1.1
+  version: 0.2.0
 platform: ruby
 authors:
 - Jimmy Börjesson
 autorequire: 
 bindir: bin
 cert_chain: []
-date: 2015-08-02 00:00:00.000000000 Z
+date: 2015-08-09 00:00:00.000000000 Z
 dependencies:
 - !ruby/object:Gem::Dependency
   name: bundler
@@ -49,6 +49,7 @@ extra_rdoc_files: []
 files:
 - ".gitignore"
 - CHANGELOG.md
+- EXAMPLES.md
 - Gemfile
 - LICENSE.txt
 - README.md