nydp 0.0.5 → 0.0.6

checksums.yaml

@@ -1,7 +1,7 @@
 ---
 SHA1:
-  metadata.gz: 8c1432b7602bbe14e2c346f16068b7f8aea35317
-  data.tar.gz: 664df28016183708d50c31a000088176ba6fe38a
+  metadata.gz: 56ae5257ab6792eeaef112c3e81991dae7c43ce1
+  data.tar.gz: 327b5770bc8f1c442202d340f5392288e58efdbe
 SHA512:
-  metadata.gz: 08fa70dd03b03b37e7427524502c216a3f7b82cdd12d9800282d91020d4d59e8faa2fdf860038299d66559f12367125913b9e699d24fe476f656599a1d49b9da
-  data.tar.gz: 40746bd05d453ab458c4e389c215546e9ffadb27e53455387a112539adc5ef189d762072f4e8988086d8813892cb9a29e53af2794fb1591e51df52bfb294f4ae
+  metadata.gz: 65b2df58e4d78c39e8ea8aacb1e3e0298269b5f2b03f6d9fb11e3ce44bf45012cd35b7b397a74de46d6e10f36a1b64be179c9efae28d5ca709959c50c9574e2b
+  data.tar.gz: 9e787875c9011054dbaa9b416b84ef162f798bea1f5c33fde9a834322fc54e8435d537a37ce7a7e62e1972db95103aca67a3336b2e727bf7da07b94953af34f8

data/lib/lisp/boot.nydp

@@ -30,6 +30,8 @@
         (fn (arg)
             (assign *debug-pre-compile* arg)))
 
+(assign *debug-pre-compile* nil)
+
 (assign pre-compile-expr
         (fn (name body)
             (mac-expand (hash-get macs name) name body)))
@@ -192,6 +194,14 @@
       (cons (list (car a) (car b))
             (zip (cdr a) (cdr b)))))
 
+(def reversify (things acc)
+  (if (no things)
+      acc
+      (reversify (cdr things)
+                 (cons (car things) acc))))
+
+(def rev (things) (reversify things nil))
+
 (mac push (x things)
   `(assign ,things (cons ,x ,things)))
 
@@ -252,10 +262,14 @@
               (iso (car x) (car y))
               (iso (cdr x) (cdr y)))))
 
-(def isa (type obj) (eq? (type-of obj) type))
+(def isa   (type   obj) (eq? (type-of obj) type))
 (mac just (arg) arg)
 (def quotify (arg) `(quote ,arg))
 
+(def caris (obj things)
+     (and (isa 'pair things)
+          (eq? (car things)  obj)))
+
 (def len (xs)
   (if (pair? xs)
       (+ 1 (len (cdr xs)))
@@ -264,7 +278,10 @@
 (def build-keyword-args (pairs)
   (map (fn (ab) `(list (quote ,(car ab)) ,@(cdr ab))) pairs))
 
+(assign dynamics (hash))
+
 (mac dynamic (name)
+  (hash-set dynamics name t)
   (let with-mac-name (sym "w/~name")
     (w/uniq prev
       `(do
@@ -276,3 +293,29 @@
                              (hash-set (thread-locals) ',',name ,',prev)
                              ,result))))
            (def ,name () (hash-get (thread-locals) ',name))))))
+
+;; (build-hash-getters '(a b c))
+;; => (hash-get (hash-get a 'b) 'c)
+(def build-hash-getters (names acc)
+  (if (no acc)
+      (build-hash-getters (cdr names) (car names))
+      names
+      (build-hash-getters (cdr names) `(hash-get ,acc ',(car names)))
+      acc))
+
+(mac hash-lookup (names)
+  (build-hash-getters names nil))
+
+(mac dot-syntax names `(hash-lookup ,names))
+
+(def dot-syntax-assignment (names value-expr)
+  (let rnames (rev names)
+    `(hash-set ,(build-hash-getters (rev (cdr rnames)) nil)
+               ',(car rnames)
+               ,value-expr)))
+
+(mac = (name value)
+  (if (isa 'symbol name)
+      `(assign ,name ,value)
+    (caris 'dot-syntax name)
+      (dot-syntax-assignment (cdr name) value)))

data/lib/lisp/test-runner.nydp

@@ -16,8 +16,7 @@
       (/ passed (+ passed failed)))))
 
 (def run-tests (tests passf failf verbose)
-  (execute-test "" tests passf failf verbose)
-  results)
+  (execute-test "" tests passf failf verbose))
 
 (def execute-test (desc test passf failf verbose)
   (if (eq? 'suite (car test))

data/lib/lisp/tests/boot-tests.nydp

@@ -27,6 +27,26 @@
                  (pairs '(1 a 2 b 3 c))
                  ((1 a) (2 b) (3 c)))
 
+                ("'rev reverses a list"
+                 (rev '(a b c))
+                 (c b a))
+
+                ("'rev handles nil"
+                 (rev nil)
+                 nil)
+
+                ("'rev doesn't recurse"
+                 (rev '(a b (c d e) f g))
+                 (g f (c d e) b a))
+
+                ("joins elements into a string"
+                 (joinstr "" '("foo" "bar" "bax"))
+                 "foobarbax")
+
+                ("joins elements into a string"
+                 (joinstr " - " '(1 2 3))
+                 "1 - 2 - 3")
+
                 ("'flatten returns a flat list of things"
                  (flatten '((poo (x) (* x x)) (1 2 3)))
                  (poo x * x x 1 2 3)))
@@ -36,34 +56,66 @@
                  (map (fn (x) (* x x)) '(1 2 3))
                  (1 4 9)))
 
-         (suite "quasiquote"
-                ("same as quote for standalone item"
-                 `a
-                 a)
-                ("same as quote for standalone list"
-                 `(a b c)
-                 (a b c))
-                ("substitutes single variables"
-                 (let b 10 `(a ,b c))
-                 (a 10 c))
-                ("substitutes a list"
-                 (let b '(1 2 3) `(a ,@b c))
-                 (a 1 2 3 c))
-                ("substitutes a list at the end of a given list"
-                 (let b '(1 2 3) `(a ,b ,@b))
-                 (a (1 2 3) 1 2 3))
-                ("more complicated substitution example"
-                 (with (d '(1 2 3) g '(x y z)) `(a (b c ,d (e f ,@g))))
-                 (a (b c (1 2 3) (e f x y z))))
-                ("peeks inside nested quotes"
-                 `(a b '(c ,(+ 1 2)))
-                 (a b '(c 3)))
-                ("handles nested unquote-splicing"
-                 ``(a ,,@(list '+ 1 2) b)
-                 `((a ,(+ 1 2) b)))
-                ("returns nested quasiquotes"
-                 `(a b `(c d ,(+ 1 2) ,,(+ 3 4)))
-                 (a b `(c d ,(+ 1 2) ,7))))
+         (suite "pre-compile"
+                ("expands 'let"
+                 (do
+                     (def x+3*z (x y)
+                          (let y 3
+                               (fn (z) (* (+ x y) z))))
+                     ((x+3*z 2 99) 5))
+                 25)
+
+                ("expands 'and"
+                 (pre-compile '(and a b c))
+                 (cond a (cond b c)))
+
+                ("expands 'or"
+                 (do (reset-uniq-counter)
+                     (pre-compile '(or a b c)))
+                 ((fn (ora-1)
+                      (cond ora-1
+                            ora-1
+                            ((fn (ora-2)
+                                 (cond ora-2
+                                       ora-2
+                                       ((fn (ora-3)
+                                            (cond ora-3
+                                                  ora-3
+                                                  nil)) c))) b))) a))
+
+                ("w/uniq provides unique variables for macro expansion"
+                 (do (reset-uniq-counter)
+                     (pre-compile '(w/uniq a foo)))
+                 ((fn (a) foo) (uniq 'a)))
+
+                (suite "quasiquote"
+                       ("same as quote for standalone item"
+                        `a
+                        a)
+                       ("same as quote for standalone list"
+                        `(a b c)
+                        (a b c))
+                       ("substitutes single variables"
+                        (let b 10 `(a ,b c))
+                        (a 10 c))
+                       ("substitutes a list"
+                        (let b '(1 2 3) `(a ,@b c))
+                        (a 1 2 3 c))
+                       ("substitutes a list at the end of a given list"
+                        (let b '(1 2 3) `(a ,b ,@b))
+                        (a (1 2 3) 1 2 3))
+                       ("more complicated substitution example"
+                        (with (d '(1 2 3) g '(x y z)) `(a (b c ,d (e f ,@g))))
+                        (a (b c (1 2 3) (e f x y z))))
+                       ("peeks inside nested quotes"
+                        `(a b '(c ,(+ 1 2)))
+                        (a b '(c 3)))
+                       ("handles nested unquote-splicing"
+                        ``(a ,,@(list '+ 1 2) b)
+                        `((a ,(+ 1 2) b)))
+                       ("returns nested quasiquotes"
+                        `(a b `(c d ,(+ 1 2) ,,(+ 3 4)))
+                        (a b `(c d ,(+ 1 2) ,7)))))
 
          (suite "build-keyword-args"
                 ("takes a list of lists and returns the list with the first item of each sublist quoted"

data/lib/lisp/tests/foundation-test.nydp

@@ -28,7 +28,7 @@
           (if t "hello" "goodbye")
           "hello")
 
-         ("nil is boolean fale"
+         ("nil is boolean false"
           (if nil "hello" "goodbye")
           "goodbye")
 
@@ -48,6 +48,58 @@
         x)
       43))
 
+  (suite "assignment with '="
+    ("assigns a symbol"
+      (pre-compile '(= this 'that))
+      (assign this 'that)))
+
+  (suite "hash"
+    ("hash-lookup"
+     (pre-compile 'a.b.c)
+     (hash-get (hash-get a 'b) 'c))
+
+    ("hash assignment"
+     (pre-compile '(= a.b 42))
+     (hash-set a 'b 42))
+
+    ("recursive hash assignment"
+     (pre-compile '(= a.b.c.d 42))
+     (hash-set (hash-get (hash-get a 'b) 'c) 'd 42)))
+
+
+  (suite "parse"
+    ("parses a colon-syntax symbol"
+     (parse "this:that")
+     ((colon-syntax this that)) )
+
+    ("parses a dot-syntax symbol"
+     (parse "this.that.zozo")
+     ((dot-syntax this that zozo)) )
+
+    ("parses an expression"
+     (parse "(foo bar \"hello, String\") 1 2 (3 t nil) nil")
+     ((foo bar "hello, String") 1 2 (3 t nil))))
+
+  (suite "isa"
+    ("t for 'pair for list"
+      (isa 'pair '(a b c))
+      t)
+    ("nil for 'pair for non-list"
+      (isa 'pair 42)
+      nil)
+    ("t for 'symbol for symbol"
+      (isa 'symbol 'foo)
+      t)
+    ("nil for 'symbol for non-symbol"
+      (isa 'symbol "foo")
+      nil)
+    ("t for 'string for string"
+      (isa 'string "foo")
+      t)
+    ("nil for 'string for string"
+      (isa 'string '(a b c))
+      nil))
+
   (suite "Lists"
     (suite "cons"
       ("cons creates a list"

data/lib/nydp/builtin.rb

@@ -1,6 +1,21 @@
 require 'nydp'
 
 module Nydp::Builtin
+  module Base
+    def indent_text txt
+      txt.split(/\n/).map { |line| "  #{line}"}.join("\n")
+    end
+
+    def invoke vm, args
+      builtin_invoke vm, args
+    rescue Exception => e
+      new_msg = "Invoking #{self.class.name}\nwith args #{args}\nraised\n#{indent_text e.message}"
+      raise $!, new_msg, $!.backtrace
+    end
+  end
+
+  def inspect ; self.class.name ; end
+  def to_s    ; self.class.name ; end
 end
 
 Dir[File.join(File.dirname(__FILE__), "builtin", "**/*.rb")].each {|f|

data/lib/nydp/builtin/hash.rb

@@ -1,30 +1,56 @@
+require "nydp/hash"
+
 class Nydp::Builtin::Hash
-  def invoke vm, args
-    vm.push_arg({ })
+  include Nydp::Helper, Nydp::Builtin::Base
+  def builtin_invoke vm, args
+    vm.push_arg(Nydp::Hash.new)
   end
 end
 
 class Nydp::Builtin::HashGet
-  def invoke vm, args
+  include Nydp::Helper, Nydp::Builtin::Base
+  attr_accessor :ns
+  def initialize ns ; @ns = ns; end
+  def builtin_invoke vm, args
     hash = args.car
     key = args.cdr.car
-    vm.push_arg(hash[key] || Nydp.NIL)
+    case hash
+    when Nydp::Hash
+      vm.push_arg(hash[key] || Nydp.NIL)
+    else
+      key = n2r args.cdr.car
+      vm.push_arg(r2n hash[key], ns)
+    end
   end
 end
 
 class Nydp::Builtin::HashSet
-  def invoke vm, args
+  include Nydp::Helper, Nydp::Builtin::Base
+  def builtin_invoke vm, args
     hash = args.car
     key = args.cdr.car
     value = args.cdr.cdr.car
-    hash[key] = value
+    case hash
+    when Nydp::Hash
+      hash[key] = value
+    else
+      hash[n2r key] = n2r value
+    end
     vm.push_arg value
   end
 end
 
 class Nydp::Builtin::HashKeys
-  def invoke vm, args
+  include Nydp::Helper, Nydp::Builtin::Base
+  attr_accessor :ns
+  def initialize ns ; @ns = ns; end
+  def builtin_invoke vm, args
     hash = args.car
-    vm.push_arg Nydp::Pair.from_list hash.keys
+    case hash
+    when Nydp::Hash
+      vm.push_arg Nydp::Pair.from_list hash.keys
+    else
+      vm.push_arg r2n(hash.keys, ns)
+    end
   end
 end

data/lib/nydp/builtin/parse.rb

@@ -0,0 +1,15 @@
+class Nydp::Builtin::Parse
+  def initialize ns
+    @parser = Nydp::Parser.new(ns)
+  end
+
+  def invoke vm, args
+    tokens = Nydp::Tokeniser.new Nydp::StringReader.new args.car.to_s
+    exprs  = []
+    while !tokens.finished
+      expr = @parser.expression(tokens)
+      exprs << expr unless expr == nil
+    end
+    vm.push_arg Nydp::Pair.from_list exprs
+  end
+end

data/lib/nydp/compiler.rb

@@ -8,6 +8,12 @@ module Nydp
     extend Helper
 
     def self.compile expression, bindings
+      compile_expr expression, bindings
+    rescue Exception => e
+      raise "failed to compile expression #{expression.inspect},\nerror was #{e.message}"
+    end
+
+    def self.compile_expr expression, bindings
       if expression.is_a? Nydp::Symbol
         SymbolLookup.build expression, bindings
       elsif literal? expression

data/lib/nydp/core.rb

@@ -37,6 +37,7 @@ module Nydp
       Symbol.mk(:apply, ns).assign(Nydp::Builtin::Apply.new)
       Symbol.mk(:error, ns).assign(Nydp::Builtin::Error.new)
       Symbol.mk(:quit,  ns).assign(Nydp::Builtin::Quit.new)
+      Symbol.mk(:parse, ns).assign(Nydp::Builtin::Parse.new(ns))
       Symbol.mk(:p,     ns).assign(Nydp::Builtin::Puts.new)
       Symbol.mk(:PI,    ns).assign Literal.new(3.1415)
       Symbol.mk(:nil,   ns).assign Nydp.NIL
@@ -57,9 +58,9 @@ module Nydp
       Symbol.mk(:"eq?",         ns).assign(Nydp::Builtin::IsEqual.new)
       Symbol.mk(:"pair?",       ns).assign(Nydp::Builtin::IsPair.new)
       Symbol.mk(:"cdr-set",     ns).assign(Nydp::Builtin::CdrSet.new)
-      Symbol.mk(:"hash-get",    ns).assign(Nydp::Builtin::HashGet.new)
+      Symbol.mk(:"hash-get",    ns).assign(Nydp::Builtin::HashGet.new ns)
       Symbol.mk(:"hash-set",    ns).assign(Nydp::Builtin::HashSet.new)
-      Symbol.mk(:"hash-keys",   ns).assign(Nydp::Builtin::HashKeys.new)
+      Symbol.mk(:"hash-keys",   ns).assign(Nydp::Builtin::HashKeys.new(ns))
       Symbol.mk(:"vm-info",     ns).assign Nydp::Builtin::VmInfo.new
       Symbol.mk(:"pre-compile", ns).assign Nydp::Builtin::PreCompile.new
     end

data/lib/nydp/hash.rb

@@ -0,0 +1,2 @@
+class Nydp::Hash < ::Hash
+end

data/lib/nydp/helper.rb

@@ -1,5 +1,32 @@
 module Nydp
+  R2NHELPERS = {
+    ::Symbol   => ->(obj, ns) { Nydp::Symbol.mk(obj, ns)                            },
+    Array      => ->(obj, ns) { Nydp::Pair.from_list obj.map { |o| Nydp.r2n o, ns } },
+    String     => ->(obj, ns) { Nydp::StringAtom.new obj.to_s                       },
+    NilClass   => ->(obj, ns) { Nydp::Nil                                           },
+    FalseClass => ->(obj, ns) { Nydp::Nil                                           },
+    TrueClass  => ->(obj, ns) { Nydp::T                                             },
+  }
+
+  def self.n2r nydp
+    nydp.respond_to?(:to_ruby) ? nydp.to_ruby : nydp
+  end
+
+  def self.r2n ruby_obj, ns
+    rklass = ruby_obj.class
+    R2NHELPERS.each do |hklass, proc|
+      if rklass <= hklass
+        return proc.call ruby_obj, ns
+      end
+    end
+
+    ruby_obj
+  end
+
   module Helper
+    def n2r obj     ; Nydp.n2r obj     ; end
+    def r2n obj, ns ; Nydp.r2n obj, ns ; end
+
     def sym? expr, name
       expr.is_a?(Nydp::Symbol) && (expr.is? name)
     end

data/lib/nydp/literal.rb

@@ -1,5 +1,6 @@
 module Nydp
   class Literal
+    include Nydp::Helper
     attr_reader :expression
 
     def initialize expression
@@ -21,6 +22,7 @@ module Nydp
     def nydp_type ; :literal            ; end
     def inspect   ; @expression.inspect ; end
     def to_s      ; @expression.to_s    ; end
+    def to_ruby   ; n2r @expression ; end
 
     def coerce _
       [_, expression]

data/lib/nydp/pair.rb

@@ -18,6 +18,11 @@ class Nydp::Pair
   def cdar      ; car.cdr ; end
   def cddr      ; cdr.cdr ; end
 
+  def to_ruby list=[]
+    list << n2r(car)
+    cdr.is_a?(Nydp::Pair) ? cdr.to_ruby(list) : list
+  end
+
   def self.parse_list list
     if sym? list.slice(-2), "."
       from_list(list[0...-2], list.slice(-1))

data/lib/nydp/parser.rb

@@ -40,6 +40,7 @@ module Nydp
     end
 
     def parse_symbol txt
+      txt = txt.to_s
       case txt
       when /^[-+]?[0-9]*\.[0-9]+([eE][-+]?[0-9]+)?$/
         txt.to_f
@@ -53,20 +54,22 @@ module Nydp
         Pair.from_list [sym(:"unquote-splicing"), parse_symbol($1)]
       when /^,(.+)$/
         Pair.from_list [sym(:unquote), parse_symbol($1)]
+      when /^\.$/
+        sym txt
       else
-        syms = txt.to_s.split /\./
+        syms = txt.split /\./, -1
         return split_sym syms, sym("dot-syntax") if syms.length > 1
 
-        syms = txt.split /::/
+        syms = txt.split /::/, -1
         return split_sym syms, sym("colon-colon-syntax") if syms.length > 1
 
-        syms = txt.split /:/
+        syms = txt.split /:/, -1
         return split_sym syms, sym("colon-syntax") if syms.length > 1
 
-        syms = txt.split /->/
+        syms = txt.split /->/, -1
         return split_sym syms, sym("arrow-syntax") if syms.length > 1
 
-        syms = txt.split(/=>/)
+        syms = txt.split(/=>/, -1)
         return split_sym syms, sym("rocket-syntax") if syms.length > 1
 
         sym txt
@@ -89,6 +92,8 @@ module Nydp
       case token.first
       when :string_open_delim
         string token_stream, token.last, close_delimiter_for(token.last)
+      when :sym_open_delim
+        sym token_stream.next_string_fragment(token.last, /\|/, nil)
       when :left_paren
         prefix_list token[1], read_list(token_stream, :right_paren)
       when :left_brace
@@ -106,13 +111,15 @@ module Nydp
       next_form token_stream.next_token, token_stream
     end
 
+    INTERPOLATION_SIGN = /~/
+
     def string token_stream, open_delimiter, close_delimiter
       fragments = [sym(:"string-pieces")]
-      string_token = token_stream.next_string_fragment(open_delimiter, close_delimiter)
+      string_token = token_stream.next_string_fragment(open_delimiter, close_delimiter, INTERPOLATION_SIGN)
       fragments << Nydp::StringAtom.new(string_token.string, string_token)
       while !(string_token.is_a? StringFragmentCloseToken)
         fragments << expression(token_stream)
-        string_token = token_stream.next_string_fragment('', close_delimiter)
+        string_token = token_stream.next_string_fragment('', close_delimiter, INTERPOLATION_SIGN)
         fragments << Nydp::StringAtom.new(string_token.string, string_token)
       end
 

data/lib/nydp/runner.rb

@@ -48,6 +48,8 @@ module Nydp
 
     def compile_and_eval expr
       vm.thread Pair.new(Compiler.compile(expr, Nydp.NIL), Nydp.NIL)
+    rescue Exception => e
+      raise "failed to eval #{expr.inspect},\nerror was #{e.message}\nvm state is #{vm.error}"
     end
 
     def quote expr

data/lib/nydp/string_atom.rb

@@ -7,6 +7,7 @@ module Nydp
 
     def nydp_type ; :string ; end
     def to_s      ;  string ; end
+    def to_ruby   ;  string ; end
 
     def inspect
       string.inspect
@@ -19,6 +20,5 @@ module Nydp
     def + other
       StringAtom.new "#{@string}#{other}"
     end
-
   end
 end

data/lib/nydp/string_token.rb

@@ -5,9 +5,9 @@ module Nydp
       @string, @rep = string, rep
     end
 
-    def to_s
-      rep
-    end
+    def to_s    ; rep           ; end
+    def inspect ; rep           ; end
+    def to_sym  ; string.to_sym ; end
 
     def == other
       (self.class == other.class) && (self.string == other.string)

data/lib/nydp/symbol.rb

@@ -1,8 +1,15 @@
 class Nydp::Symbol
+  EMPTY = :""
   attr_accessor :name
 
   def initialize name
     @name = name.to_sym
+    @inspection = name.to_s
+    @inspection = "|#{name}|" if untidy(@inspection)
+  end
+
+  def untidy str
+    (str == "") || (str == nil) || (str =~ /\s/)
   end
 
   def is? nm
@@ -10,9 +17,11 @@ class Nydp::Symbol
   end
 
   def value context=nil
+    raise "unbound symbol: #{self.inspect}" if @value == nil
     @value || Nydp.NIL
   end
 
+
   def self.mk name, ns
     name = name.to_sym
     return Nydp.NIL if name == :nil
@@ -29,9 +38,10 @@ class Nydp::Symbol
     ns[name.to_sym]
   end
 
-  def nydp_type ; :symbol    ; end
-  def inspect   ; to_s       ; end
-  def to_s      ; name.to_s  ; end
+  def nydp_type ; :symbol     ; end
+  def inspect   ; @inspection ; end
+  def to_s      ; name.to_s   ; end
+  def to_ruby   ; name        ; end
 
   def == other
     other.is_a?(Nydp::Symbol) && (self.name == other.name)

data/lib/nydp/tokeniser.rb

@@ -25,7 +25,7 @@ module Nydp
       scanner.scan(delim)
     end
 
-    def next_string_fragment open_delimiter, close_delimiter
+    def next_string_fragment open_delimiter, close_delimiter, interpolation_sign
       s = @scanner
       rep = "#{open_delimiter}"
       string = ""
@@ -42,7 +42,7 @@ module Nydp
         elsif closer = close_delimiter?(s, close_delimiter)
           rep << closer
           return StringFragmentCloseToken.new(string, rep)
-        elsif start_interpolation = s.scan(/~/)
+        elsif interpolation_sign && (start_interpolation = s.scan(interpolation_sign))
           rep << start_interpolation
           return StringFragmentToken.new(string, rep)
         else
@@ -66,6 +66,8 @@ module Nydp
           tok = [:comment, comment[1..-1].strip]
         elsif open_str = s.scan(/"/)
           tok = [:string_open_delim, open_str]
+        elsif open_sym = s.scan(/\|/)
+          tok = [:sym_open_delim, open_sym]
         elsif list_prefix = s.scan(/[^\s()]*\(/)
           tok = [:left_paren, list_prefix[0...-1]]
         elsif list_prefix = s.scan(/[^\s()]*\{/)

data/lib/nydp/version.rb

@@ -1,3 +1,3 @@
 module Nydp
-  VERSION = "0.0.5"
+  VERSION = "0.0.6"
 end

data/spec/hash_spec.rb

@@ -0,0 +1,98 @@
+require "spec_helper"
+
+describe Nydp::Hash do
+
+  let(:vm) { Nydp::VM.new }
+
+  describe "nydp hashes" do
+    describe "new hash" do
+      it "returns a new Nydp hash" do
+        Nydp::Builtin::Hash.new.invoke vm, Nydp.NIL
+        h = vm.pop_arg
+        expect(h).to be_a Nydp::Hash
+      end
+    end
+
+    describe "hash set" do
+      it "sets a value on a hash" do
+        h    = Nydp::Hash.new
+        k    = sym "keysym"
+        v    = 42
+        args = Nydp::Pair.from_list([h, k, v])
+        Nydp::Builtin::HashSet.new.invoke vm, args
+
+        expect(h.keys).    to eq [k]
+        expect(h[k]).      to eq v
+        expect(vm.pop_arg).to eq v
+      end
+    end
+
+    describe "hash get" do
+      it "gets a value from a hash" do
+        h    = Nydp::Hash.new
+        k    = sym "keysym"
+        v    = 42
+        h[k] = v
+
+        args = Nydp::Pair.from_list([h, k])
+        Nydp::Builtin::HashGet.new(ns).invoke vm, args
+        expect(vm.pop_arg).to eq v
+      end
+    end
+
+    describe "hash keys" do
+      it "returns a list of keys" do
+        h    = Nydp::Hash.new
+        h[sym "k0"] = 42
+        h[sym "k1"] = 84
+
+        args = Nydp::Pair.from_list([h])
+        Nydp::Builtin::HashKeys.new(ns).invoke vm, args
+        expect(vm.pop_arg).to eq pair_list [sym("k0"), sym("k1")]
+      end
+    end
+  end
+
+  describe "foreign hashes" do
+    let(:ahash) { Hash.new }
+
+    describe "hash set" do
+      it "returns a new Nydp hash" do
+        k    = Nydp::Symbol.mk "keysym", ns
+        v    = Nydp::StringAtom.new "foobar"
+        args = pair_list [ahash, k, v]
+        Nydp::Builtin::HashSet.new.invoke vm, args
+
+        expect(ahash[:keysym]).      to eq "foobar"
+        expect(ahash[:keysym].class).to eq String
+        expect(ahash.keys).          to eq [:keysym]
+
+        expect(vm.pop_arg).to eq v
+      end
+    end
+
+    describe "hash get" do
+      it "converts ruby value to nydp value" do
+        ahash[:keysym] = "avalue"
+        k              = sym("keysym")
+        args           = [ ahash, k ]
+
+        Nydp::Builtin::HashGet.new(ns).invoke vm, pair_list(args)
+
+        expect(vm.pop_arg).to eq Nydp::StringAtom.new("avalue")
+      end
+    end
+
+    describe "hash keys" do
+      it "returns a list of keys" do
+        ahash[:k0] = 42
+        ahash[:k1] = 84
+        args       = [ahash]
+
+        Nydp::Builtin::HashKeys.new(ns).invoke vm, pair_list(args)
+
+        expect(vm.pop_arg).to eq pair_list [sym("k0"), sym("k1")]
+      end
+    end
+  end
+end

data/spec/literal_spec.rb

@@ -0,0 +1,9 @@
+require 'spec_helper'
+
+describe Nydp::Literal do
+  it "returns a ruby symbol in #to_ruby" do
+    sym = Nydp::Symbol.mk :foo, ns
+    lit = Nydp::Literal.new sym
+    expect(lit.to_ruby).to eq :foo
+  end
+end

data/spec/pair_spec.rb

@@ -52,7 +52,7 @@ describe Nydp::Pair do
     expect(p.cdr).to eq :b
   end
 
-  it "should convert a ruby list" do
+  it "should convert from a ruby list" do
     p = pair_list [:a, :b, :c, :d]
     expect(p.car).to eq :a
     p = p.cdr
@@ -69,6 +69,12 @@ describe Nydp::Pair do
     expect(p.cdr).to eq Nydp.NIL
   end
 
+  it "should convert to a ruby list" do
+    pair = pair_list [:a, :b, :c, :d]
+    ruby = pair.to_ruby
+    expect(ruby).to eq [:a, :b, :c, :d]
+  end
+
   it "should have size zero when empty" do
     expect(pair_list([]).size).to eq 0
   end

data/spec/parser_spec.rb

@@ -49,6 +49,13 @@ describe Nydp::Parser do
     expect(parse "(foo bar)").to eq pair_list([foo, bar])
   end
 
+  it "should parse untidy symbols" do
+    s0 = sym "foo bar"
+    s1 = sym ""
+    s2 = sym '" hello, there, silly billy!"'
+    expect(parse "(|foo bar| || |\" hello, there, silly billy!\"|)").to eq pair_list([s0, s1, s2])
+  end
+
   it "should parse numbers expression" do
     expect(parse "(1 2 3)").to eq pair_list([1, 2, 3])
   end
@@ -138,6 +145,11 @@ describe Nydp::Parser do
     expect([two, three, four].map &:class).to eq [Fixnum, Fixnum, Fixnum]
   end
 
+  it "should handle prefix and postfix syntax also" do
+    parsed = parse(".foo123:")
+    expect(parsed.inspect).to eq "(dot-syntax || (colon-syntax foo123 ||))"
+  end
+
   it "should parse a dotted symbol" do
     expect(parse "(list a b foo.bar c)").to eq  pair_list([sym(:list), a, b, pair_list([dotsyn, foo, bar]), c])
   end

data/spec/string_atom_spec.rb

@@ -0,0 +1,9 @@
+require "spec_helper"
+
+describe Nydp::StringAtom do
+  it "returns its string in #to_ruby" do
+    s = Nydp::StringAtom.new "harrypotter"
+    expect(s.to_ruby).to eq "harrypotter"
+    expect(s.to_ruby.class).to eq String
+  end
+end

data/spec/symbol_spec.rb

@@ -1,6 +1,11 @@
 require 'spec_helper'
 
 describe Nydp::Symbol do
+  it "returns a ruby symbol in #to_ruby" do
+    sym = Nydp::Symbol.mk :foo, ns
+    expect(sym.to_ruby).to eq :foo
+  end
+
   it "should not recognise an unknown symbol" do
     sym = Nydp::Symbol.find :foo, ns
     expect(sym).to eq nil
@@ -15,6 +20,7 @@ describe Nydp::Symbol do
     sym1 = Nydp::Symbol.mk :baz, ns
     sym2 = Nydp::Symbol.mk :baz, ns
 
+    expect(sym1).to eq sym2
     expect(sym1).to equal sym2
   end
 
@@ -26,5 +32,6 @@ describe Nydp::Symbol do
     sym2 = Nydp::Symbol.mk :baz, ns2
 
     expect(sym1).to eq sym2
+    expect(sym1).not_to equal sym2
   end
 end

metadata

@@ -1,14 +1,14 @@
 --- !ruby/object:Gem::Specification
 name: nydp
 version: !ruby/object:Gem::Version
-  version: 0.0.5
+  version: 0.0.6
 platform: ruby
 authors:
 - Conan Dalton
 autorequire: 
 bindir: bin
 cert_chain: []
-date: 2015-05-15 00:00:00.000000000 Z
+date: 2015-05-18 00:00:00.000000000 Z
 dependencies:
 - !ruby/object:Gem::Dependency
   name: bundler
@@ -109,6 +109,7 @@ files:
 - lib/nydp/builtin/load_tests.rb
 - lib/nydp/builtin/millisecs.rb
 - lib/nydp/builtin/minus.rb
+- lib/nydp/builtin/parse.rb
 - lib/nydp/builtin/plus.rb
 - lib/nydp/builtin/pre_compile.rb
 - lib/nydp/builtin/puts.rb
@@ -129,6 +130,7 @@ files:
 - lib/nydp/core.rb
 - lib/nydp/error.rb
 - lib/nydp/function_invocation.rb
+- lib/nydp/hash.rb
 - lib/nydp/helper.rb
 - lib/nydp/interpreted_function.rb
 - lib/nydp/lexical_context.rb
@@ -147,12 +149,14 @@ files:
 - lib/nydp/vm.rb
 - lib/tasks/tests.rake
 - nydp.gemspec
-- spec/boot_spec.rb
 - spec/embedded_spec.rb
-- spec/nypd_spec.rb
+- spec/hash_spec.rb
+- spec/literal_spec.rb
+- spec/nydp_spec.rb
 - spec/pair_spec.rb
 - spec/parser_spec.rb
 - spec/spec_helper.rb
+- spec/string_atom_spec.rb
 - spec/string_token_spec.rb
 - spec/symbol_spec.rb
 - spec/thread_local_spec.rb
@@ -181,12 +185,14 @@ signing_key:
 specification_version: 4
 summary: A new lisp for a new age
 test_files:
-- spec/boot_spec.rb
 - spec/embedded_spec.rb
-- spec/nypd_spec.rb
+- spec/hash_spec.rb
+- spec/literal_spec.rb
+- spec/nydp_spec.rb
 - spec/pair_spec.rb
 - spec/parser_spec.rb
 - spec/spec_helper.rb
+- spec/string_atom_spec.rb
 - spec/string_token_spec.rb
 - spec/symbol_spec.rb
 - spec/thread_local_spec.rb

data/spec/boot_spec.rb

@@ -1,69 +0,0 @@
-require 'spec_helper'
-
-describe Nydp do
-  let(:vm)                    { Nydp::VM.new }
-
-  before {
-    Nydp.setup ns
-    boot_path = File.expand_path File.join File.expand_path(File.dirname(__FILE__)), '../lib/lisp/boot.nydp'
-    reader = Nydp::StreamReader.new(File.new(boot_path))
-    Nydp::Runner.new(vm, ns, reader).run
-  }
-
-  def list *things
-    Nydp::Pair.from_list things.map { |thing|
-      case thing
-      when Symbol
-        sym(thing)
-      when Array
-        list(*thing)
-      else
-        thing
-      end
-    }
-  end
-
-  def run txt
-    Nydp::Runner.new(vm, ns, Nydp::StringReader.new(txt)).run
-  end
-
-  describe :let do
-    it "should create an inner scope with a single variable" do
-      lisp = "(def x+3*z (x) (let y 3 (fn (z) (* (+ x y) z)))) ((x+3*z 2) 5)"
-      result = run lisp
-      expect(result).to eq 25
-    end
-  end
-
-  describe :and do
-    it "should produce some nested conds" do
-      result = run "(pre-compile '(and a b c))"
-      expect(result).to eq list :cond, :a, [:cond, :b, :c]
-    end
-  end
-
-  describe :w_uniq do
-    it "should handle single-var case" do
-      result = run "(reset-uniq-counter) (pre-compile '(w/uniq a foo))"
-      expect(result).to eq list [:fn, [:a], :foo], [:uniq, [:quote, :a]]
-    end
-  end
-
-  describe :or do
-    it "should produce some nested conds" do
-      result = run "(reset-uniq-counter) (pre-compile '(or a b c))"
-      expect(result).to eq parse "((fn (ora-1) (cond ora-1 ora-1 ((fn (ora-2) (cond ora-2 ora-2 ((fn (ora-3) (cond ora-3 ora-3 nil)) c))) b))) a)"
-    end
-  end
-
-  describe :join do
-    it "should join a list of strings together" do
-      joining = %{(joinstr "" '("foo" "bar" "bax"))}
-      expect(run joining).to eq "foobarbax"
-    end
-
-    it "should join a list of things together as a string" do
-      expect(run %{(joinstr " - " '(1 2 3))}).to eq "1 - 2 - 3"
-    end
-  end
-end