nydp 0.0.12 → 0.1.0

checksums.yaml

@@ -1,7 +1,7 @@
 ---
 SHA1:
-  metadata.gz: 6e7ea4e19c5b46b3a1c56299814f4412262c19ee
-  data.tar.gz: e812a2a39dab9ac0eb1a27b8cce1d6f0fd0b8f21
+  metadata.gz: ebd833948c836f583d77adc0028df3838bd30ed3
+  data.tar.gz: 85458c42aa0466e0802771a3a62b3593cc26d25d
 SHA512:
-  metadata.gz: 6b65eac655935ae485b2c66e4e90f50dce3b5fcab5afb7f4c2394ae7f5a72b1451a65f24dadcb72460ad2e6f5b51a4e4c6ccbf7353ebc2d31aa8bc9294292d47
-  data.tar.gz: 95d9519c024596480c2a604db56055bfe6d5ec929c0b57a3c5356ff0b1150b92c698199f35116036c85ad0431d6d083918279abeab3640dbfa736af4b937f444
+  metadata.gz: 6b0981f75b8ecf590694377973f0bc9b013250cd54ad0278d0b79cfba43cc6c8f870f4842238e1df43448fdcfad15a2cb7634c2b30c141b60dbb1bca87a610ee
+  data.tar.gz: cd44bec0ad3c3fe9b1bfc8c38937ac5850de8529b0f74004378bbbae3dbe376d9e39c02ea5db3c1383888b26bcf8f6fea34fc50adf634a1e8a3ef134587d598a

data/lib/lisp/core-01-precompile.nydp

@@ -21,7 +21,7 @@
 
 (assign pre-compile-msg
         (fn (src compiled)
-            (pre-compile-msg "pre-compile" src "\n  -> " compiled)
+            (p "pre-compile" src "\n  -> " compiled)
             compiled))
 
 (assign pre-compile-raw

data/lib/lisp/core-02-utils.nydp

@@ -1,8 +1,6 @@
-; -*- lisp -*-
-
 (def map (f things)
   (if (no things)
       nil
-    (pair? things)
-    (cons (f (car things)) (map f (cdr things)))
-    (map f (list things))))
+      (pair? things)
+      (cons (f (car things)) (map f (cdr things)))
+      (map f (list things))))

data/lib/lisp/core-03-syntax.nydp

@@ -1,5 +1,3 @@
-; -*- lisp -*-
-
 (mac unless (arg . body)
   `(if (no ,arg) (do ,@body)))
 

data/lib/lisp/core-04-utils.nydp

@@ -1,10 +1,3 @@
-; -*- lisp -*-
-
-(def each (f acc things)
-  (if things
-      (each f (f acc (car things)) (cdr things))
-      acc))
-
 (def eachr (f things)
      (when things
        (eachr f (cdr things))
@@ -46,6 +39,15 @@
 (def string-pieces pieces
   (joinstr "" pieces))
 
+(def detect (f things)
+  (if (pair? things)
+      (let it (car things)
+        (or
+         (and (f it) it)
+         (detect f (cdr things))))
+      (f things)
+      things))
+
 (def nth (n things)
      (if (eq? n 0)
          (car things)
@@ -122,3 +124,20 @@
   `(map (fn (,x) ,expr) ,things))
 
 (def empty? (things) (eq? (len things) 0))
+
+(mac each (var things code)
+  (w/uniq (xs c)
+          `((rfn ,c (,xs)
+                (if (pair? ,xs)
+                    (do
+                        (let ,var (car ,xs) ,code)
+                        (,c (cdr ,xs)))))
+           ,things)))
+
+(def reduce (f things)
+  ((rfn rd (acc list)
+        (if (pair? list)
+            (rd (f acc (car list))
+                (cdr list))
+            acc))
+   (car things) (cdr things)))

data/lib/lisp/core-05-test-runner.nydp

@@ -21,6 +21,7 @@
 (def execute-test (desc test passf failf verbose)
   (if (eq? 'suite (car test))
       (execute-tests (+ desc " - " (cadr test)) (cddr test) passf failf verbose)
+      (!eq? 'comment (car test))
       (execute-single-test desc test passf failf verbose)))
 
 (def execute-single-test (desc test passf failf verbose)

data/lib/lisp/core-07-prefix-list.nydp

@@ -0,0 +1,26 @@
+
+(assign prefix-list-prefixes ())
+
+(def prefix-match-fn (txt)
+  (fn (rule) (string-match txt (car rule))))
+
+(def find-prefix-rule (prefix)
+  (cdr:detect (prefix-match-fn prefix)
+        prefix-list-prefixes))
+
+(mac prefix-list (prefix list)
+  (let handler (find-prefix-rule prefix)
+    (and handler (handler prefix list))))
+
+(mac define-prefix-list-macro (regex prefix-var list-var . body)
+  `(push (cons ,regex (fn (,prefix-var ,list-var) ,@body))
+         prefix-list-prefixes))
+
+;;
+;; so you can write (map λa(upcase a.name) people)
+;;
+;; instead of (map (fn (a) (upcase a.name)) people)
+;;
+(define-prefix-list-macro "^λ.+" vars expr
+  (let var-list (map sym (cdr:string-split vars))
+    `(fn ,var-list ,expr)))

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

@@ -138,6 +138,35 @@
                     (mapx '(1 2 3 4) n (* n 2))
                     (2 4 6 8))))
 
+         (suite "reduce"
+                ("it applies a function cumulatively over a list"
+                 (reduce + '(1 2 3))
+                 6))
+
+         (suite "detect"
+                ("returns first matching item in a list"
+                 (detect (fn (x) (eq? (len x) 2))
+                         (list "foo" "bar" "xx" "pp"))
+                 "xx")
+
+                ("returns nil when nothing matches"
+                 (detect (fn (x) (eq? (len x) 20))
+                         (list "foo" "bar" "xx" "pp"))
+                 nil)
+
+                ;; kind of pointless
+                ("returns nil if nil is the matching item"
+                 (detect no (list "foo" "bar" nil "pp"))
+                 nil)
+
+                ("returns item if it's an atom and matches"
+                 (detect (fn (x) (eq? (len x) 2)) "zz")
+                 "zz")
+
+                ("returns nil if it's an atom and doesn't match"
+                 (detect (fn (x) (eq? (len x) 20))
+                         "zz")
+                 nil))
 
          (suite "pre-compile"
                 (suite "bang-syntax"

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

@@ -0,0 +1,5 @@
+(register-test
+ '(suite "'each Tests"
+         ("iterates over each item in list"
+          (let acc 0 (each x '(1 2 3 4) (assign acc (+ x acc))) acc)
+          10)))

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

@@ -25,6 +25,11 @@
          (list m.match m.captures))
        ("and" nil))
 
+      ("no match with regexp"
+       (let m (string-match "a and b and c and d" "not-in-string")
+         (list m.match m.captures))
+       (nil nil))
+
       ("match with regexp and capturing groups"
        (let m (string-match "  foo\b    bar" "(^\\s+)")
          (list m.match m.captures))
@@ -92,6 +97,11 @@
       (pre-compile '(= this 'that))
       (assign this 'that)))
 
+  (suite "argument default value"
+    ("is nil"
+     ( (fn (x y z) (list x y (car z))) 'a 'b )
+     (a b nil)))
+
   (suite "hash"
     ("hash-lookup"
      (pre-compile 'a.b.c)

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

@@ -12,6 +12,27 @@
      (parse "{foo bar 1 2 3}")
      ((brace-list foo bar 1 2 3))))
 
+  (suite "prefix-list"
+    ("parse quasiquote"
+     (parse "`(1 2 3)")
+     ((quasiquote (1 2 3))))
+
+    ("parse unquote unquote-splicing"
+     (parse ",,@(1 2 3)")
+     ((unquote (unquote-splicing (1 2 3)))))
+
+    ("parse unquote"
+     (parse ",(1 2 3)")
+     ((unquote (1 2 3))))
+
+    ("parse custom prefix-lists"
+     (parse "x(1 2 3)")
+     ((prefix-list "x" (1 2 3))))
+
+    ("parse custom prefix-lists with a special-syntax prefix"
+     (parse "x.y(1 2 3)")
+     ((prefix-list "x.y" (1 2 3)))))
+
   (suite "parse"
     ("parses an empty symbol"
      (parse "||")
@@ -21,6 +42,14 @@
      (parse "this:that")
      ((colon-syntax this that)) )
 
+    ("parses a percent-syntax symbol"
+     (parse "this%that")
+     ((percent-syntax this that)) )
+
+    ("parses a percent-prefix-syntax symbol"
+     (parse "%this-and-that")
+     ((percent-syntax || this-and-that)) )
+
     ("parses a dot-syntax symbol"
      (parse "this.that.zozo")
      ((dot-syntax this that zozo)) )
@@ -74,4 +103,7 @@
       (len (parse-in-string (joinstr "" (list "hello " '~ " world"))))
       13)
 
+    ("reports parse errors gracefully"
+     (on-err "CAUGHT: ~err" (parse-in-string (joinstr "" "blah ~~(\"stri...")))
+     "CAUGHT: parse error: \"unterminated string\" in\n  blah ~~(\"stri..." )
 )))

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

@@ -0,0 +1,16 @@
+(register-test
+ '(suite "syntax tests"
+         (suite "lambda shortcut"
+                ("one argument"
+                 (map λa(len a.name)
+                      (list { name "bob" } { name "willy" } { name "pteradactyl" }))
+                 (3 5 11))
+
+                ("with two args"
+                 (reduce λxy(joinstr ":" x y)
+                         '(a b c d e f))
+                 "a:b:c:d:e:f")
+
+                ("with two args, to be sure"
+                 (λpq(+ p (* p q)) 3 5)
+                 18))))

data/lib/nydp/builtin/hash.rb

@@ -12,20 +12,27 @@ class Nydp::Builtin::HashGet
   attr_accessor :ns
   def initialize ns ; @ns = ns; end
   def builtin_invoke vm, args
-    hash = args.car
+    hsh = args.car
     key = args.cdr.car
-    case hash
+    case hsh
     when Nydp::Hash
-      vm.push_arg(hash[key] || Nydp.NIL)
+      vm.push_arg(hsh[key] || Nydp.NIL)
     when NilClass, Nydp.NIL
       vm.push_arg Nydp.NIL
     else
-      if hash.respond_to? :[]
-        key = n2r args.cdr.car
-        vm.push_arg(r2n hash[key], ns)
-      else
-        raise "hash-get: Not a hash: #{hash.class.name}"
-      end
+      v = hsh.respond_to?(:[]) ? hsh[n2r key] : ruby_call(hsh, key)
+      vm.push_arg(r2n v, ns)
+    end
+  end
+
+  def ruby_call obj, method_name
+    if obj.respond_to? :_nydp_safe_methods
+      m       = n2r(method_name).to_s.to_sym
+      allowed = obj._nydp_safe_methods
+
+      obj.send n2r(m) if allowed.include?(m)
+    else
+      raise "hash-get: Not a hash: #{obj.class.name}"
     end
   end
 end

data/lib/nydp/builtin/parse_in_string.rb

@@ -6,8 +6,12 @@ class Nydp::Builtin::ParseInString
   end
 
   def builtin_invoke vm, args
-    tokens = Nydp::Tokeniser.new Nydp::StringReader.new args.car.to_s
+    parsable = args.car.to_s
+    tokens = Nydp::Tokeniser.new Nydp::StringReader.new parsable
     expr = @parser.string(tokens, "", :eof)
     vm.push_arg expr
+  rescue Exception => e
+    new_msg = "parse error: #{e.message.inspect} in\n#{Nydp.indent_text parsable}"
+    raise Nydp::Error.new new_msg
   end
 end

data/lib/nydp/lexical_context.rb

@@ -19,12 +19,8 @@ class Nydp::LexicalContext
     end
   end
 
-  def at name
-    values[name]
-  end
-
   def at_index index
-    values[index]
+    values[index] || Nydp.NIL
   end
 
   def set name, value

data/lib/nydp/parser.rb

@@ -31,7 +31,8 @@ module Nydp
       when /^(.*),@$/
         prefix_list $1, Pair.from_list([sym(:"unquote-splicing"), list])
       else
-        list
+        pfx = Nydp::StringAtom.new prefix
+        Pair.from_list([sym(:"prefix-list"), pfx, list])
       end
     end
 
@@ -41,6 +42,7 @@ module Nydp
 
     SYMBOL_OPERATORS =
       [
+        [ /%/,      "percent-syntax"    ],
         [ /\!/,     "bang-syntax"       ],
         [ /&/,      "ampersand-syntax"  ],
         [ /\./,     "dot-syntax"        ],
@@ -119,6 +121,7 @@ module Nydp
     def string token_stream, open_delimiter, close_delimiter
       fragments = [sym(:"string-pieces")]
       string_token = token_stream.next_string_fragment(open_delimiter, close_delimiter, INTERPOLATION_SIGN, INTERPOLATION_ESCAPES)
+      raise "unterminated string" if string_token.nil?
       fragments << Nydp::StringAtom.new(string_token.string, string_token)
       while !(string_token.is_a? StringFragmentCloseToken)
         fragments << expression(token_stream)

data/lib/nydp/version.rb

@@ -1,3 +1,3 @@
 module Nydp
-  VERSION = "0.0.12"
+  VERSION = "0.1.0"
 end

data/spec/hash_spec.rb

@@ -2,6 +2,19 @@ require "spec_helper"
 
 describe Nydp::Hash do
 
+  class TestThing
+    attr_accessor :a, :b, :c
+    def initialize a, b, c
+      @a, @b, @c = a, b, c
+    end
+
+    def inspect
+      "(TestThing #{a.inspect} #{b.inspect})"
+    end
+
+    def _nydp_safe_methods ; %i{ a b } ; end
+  end
+
   let(:vm) { Nydp::VM.new }
 
   describe "#to_ruby" do
@@ -181,6 +194,44 @@ describe Nydp::Hash do
     end
   end
 
+  describe "friendly non-hashes" do
+    let(:ahash) { TestThing.new 123, "hello there", "private" }
+
+    describe "hash get" do
+      it "returns a plain number" do
+        k      = Nydp::Symbol.mk "a", ns
+        args   = [ ahash, k ]
+
+        Nydp::Builtin::HashGet.new(ns).invoke vm, pair_list(args)
+        expect(vm.pop_arg).to eq 123
+      end
+
+      it "converts ruby value to nydp value" do
+        k      = Nydp::Symbol.mk "b", ns
+        args   = [ ahash, k ]
+
+        Nydp::Builtin::HashGet.new(ns).invoke vm, pair_list(args)
+        expect(vm.pop_arg).to eq Nydp::StringAtom.new("hello there")
+      end
+
+      it "converts string keys to method names" do
+        k      = Nydp::StringAtom.new "b"
+        args   = [ ahash, k ]
+
+        Nydp::Builtin::HashGet.new(ns).invoke vm, pair_list(args)
+        expect(vm.pop_arg).to eq Nydp::StringAtom.new("hello there")
+      end
+
+      it "returns nil for unavailable methods" do
+        k      = Nydp::Symbol.mk "c", ns
+        args   = [ ahash, k ]
+
+        Nydp::Builtin::HashGet.new(ns).invoke vm, pair_list(args)
+        expect(vm.pop_arg).to eq Nydp.NIL
+      end
+    end
+  end
+
   describe "non-hash" do
     let(:ahash) { Nydp::StringAtom.new "this here ain't no hash, hombre" }
 
@@ -206,8 +257,8 @@ raised
 
     describe "hash get" do
       it "converts ruby value to nydp value" do
-        k    = Nydp::Symbol.mk "keysym", ns
-        args           = [ ahash, k ]
+        k      = Nydp::Symbol.mk "keysym", ns
+        args   = [ ahash, k ]
 
         begin
           Nydp::Builtin::HashGet.new(ns).invoke vm, pair_list(args)
@@ -215,7 +266,7 @@ raised
           error = e
         end
 
-        expect(error.message.gsub(/at \/.*:in `builtin_invoke'/, '<error info>')).to eq "Called builtin/hash-get
+        expect(error.message.gsub(/at \/.*:in `ruby_call'/, '<error info>')).to eq "Called builtin/hash-get
 with args (\"this here ain't no hash, hombre\" keysym)
 raised
   hash-get: Not a hash: Nydp::StringAtom

data/spec/parser_spec.rb

@@ -13,6 +13,7 @@ describe Nydp::Parser do
   let(:quote)            { Nydp::Symbol.mk :quote,                ns }
   let(:quasiquote)       { Nydp::Symbol.mk :quasiquote,           ns }
   let(:unquote)          { Nydp::Symbol.mk :unquote,              ns }
+  let(:prefix_list)      { Nydp::Symbol.mk :"prefix-list",        ns }
   let(:unquote_splicing) { Nydp::Symbol.mk :"unquote-splicing",   ns }
   let(:comment)          { Nydp::Symbol.mk :comment,              ns }
   let(:dotsyn)           { Nydp::Symbol.mk :"dot-syntax",         ns }
@@ -214,6 +215,10 @@ describe Nydp::Parser do
     expect(parse ",(bar)").to eq pair_list([unquote, pair_list([bar])])
   end
 
+  it "retains otherwise unidentified list prefixes" do
+    expect(parse "%wong(bar)").to eq pair_list([prefix_list, "%wong", pair_list([bar])])
+  end
+
   it "should do some complicated unquote stuff with lists" do
     expect(parse("`(a b `(c d ,(+ 1 2) ,,(+ 3 4)))").inspect).to eq "(quasiquote (a b (quasiquote (c d (unquote (+ 1 2)) (unquote (unquote (+ 3 4)))))))"
   end

metadata

@@ -1,14 +1,14 @@
 --- !ruby/object:Gem::Specification
 name: nydp
 version: !ruby/object:Gem::Version
-  version: 0.0.12
+  version: 0.1.0
 platform: ruby
 authors:
 - Conan Dalton
 autorequire: 
 bindir: bin
 cert_chain: []
-date: 2015-09-23 00:00:00.000000000 Z
+date: 2015-10-09 00:00:00.000000000 Z
 dependencies:
 - !ruby/object:Gem::Dependency
   name: bundler
@@ -91,13 +91,16 @@ files:
 - lib/lisp/core-04-utils.nydp
 - lib/lisp/core-05-test-runner.nydp
 - lib/lisp/core-06-benchmarking.nydp
+- lib/lisp/core-07-prefix-list.nydp
 - lib/lisp/tests/boot-tests.nydp
 - lib/lisp/tests/builtin-tests.nydp
 - lib/lisp/tests/dynamic-scope-test.nydp
+- lib/lisp/tests/each-tests.nydp
 - lib/lisp/tests/error-tests.nydp
 - lib/lisp/tests/foundation-test.nydp
 - lib/lisp/tests/invocation-tests.nydp
 - lib/lisp/tests/parser-tests.nydp
+- lib/lisp/tests/syntax-tests.nydp
 - lib/nydp.rb
 - lib/nydp/assignment.rb
 - lib/nydp/builtin.rb