nydp 0.1.7.1 → 0.1.8

checksums.yaml

@@ -1,7 +1,7 @@
 ---
 SHA1:
-  metadata.gz: db35faecd269e526a42734f65107c5e01225e1d7
-  data.tar.gz: bf41a00b1da780edade899c64c60448af7e3bfed
+  metadata.gz: 464c1f232ccc2d83cad5b5141745c64b46f44456
+  data.tar.gz: 6197cc9ee681187c2bd2ace20395f1c2a414df1f
 SHA512:
-  metadata.gz: 8854d5d5072ddef9cc13b9990352ba1e14651304fc4e81042181504b0e9f352cc5aee08f91c655decea3c0019317325bb8c3b9ab1118f02712eeb7ff54b5dd74
-  data.tar.gz: 9e47f43feec791386e44b183dd16bdf254238bd507977b42e39771d3a0f55aea30dd42fc6db48544e65010d430c376e09e0607a680132756d572e842092d1de3
+  metadata.gz: 9b1e87a79e8531565cedd6f9eaebd3bf1af59782ea383e3426ee054ae9c2c819881dde4123620f683690cbbbef164b1477df93a323de8dac817d39355aaeccf7
+  data.tar.gz: 9d9a93990ebcd01d4305ef2458b02acfbf338263f3ee5ba4ab0f223f1115db845cc91220e410cf1bbb535a84c59f3eea66e8f8856e04d0919d9afb4ada53893a

data/lib/lisp/core-000.nydp

@@ -2,17 +2,20 @@
 ;;
 ;; Acknowledgements to Paul Graham, Robert Morris, and their ancestor programmers.
 ;; nydp's main inspiration is arc, and many nydp features (including, but not limited
-;; to, 'do, 'rfn, 'loop, 'for) were directly inspired by (aka stolen from) arc.arc
-;;
+;; to, 'do, 'rfn, 'loop, 'for) were directly inspired by (aka stolen from) arc.arc. See
+;; README.md however for some significant differences
 
 (assign   list (fn args args))
 (assign   caar (fn (arg) (car (car arg))))
 (assign   cadr (fn (arg) (car (cdr arg))))
 (assign   cdar (fn (arg) (cdr (car arg))))
 (assign   cddr (fn (arg) (cdr (cdr arg))))
-(assign  cadar (fn (arg) (car (cdr (car arg)))))
-(assign  caddr (fn (arg) (car (cdr (cdr arg)))))
-(assign  cdddr (fn (arg) (cdr (cdr (cdr arg)))))
-(assign cadddr (fn (arg) (car (cdr (cdr (cdr arg))))))
+(assign  cadar (fn (arg) (car (cdar arg))))
+(assign  caddr (fn (arg) (car (cddr arg))))
+(assign  cdddr (fn (arg) (cdr (cddr arg))))
+(assign cadddr (fn (arg) (car (cdddr arg))))
 (assign     no (fn (arg) (cond arg nil t)))
 (assign   just (fn (arg) arg))
+(assign    isa (fn (type obj) (eq? (type-of obj) type)))
+(assign  pair? (fn (arg) (isa 'pair arg)))
+(assign  hash? (fn (arg) (isa 'hash arg)))

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

@@ -168,8 +168,6 @@
                ,(build-hash-get-key:car rnames)
                ,value-expr)))
 
-(def isa     (type obj) (eq? (type-of obj) type))
-
 (mac = (name value)
   (if (isa 'symbol name)
       `(assign ,name ,value)

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

@@ -78,10 +78,17 @@
   (and (isa 'pair things)
        (eq? (car things)  obj)))
 
+(def list-length (things)
+  (if (no things)    0
+      (atom? things) 1
+      (+ 1 (list-length:cdr things))))
+
 (def len (xs)
-  (if (pair? xs)   (+ 1 (len (cdr xs)))
+  (if (no xs)      0
+      (pair? xs)   (list-length xs)
       (string? xs) (string-length xs)
-      0))
+      (hash? xs)   (list-length:hash-keys xs)
+      nil))
 
 (assign dynamics (hash))
 
@@ -112,7 +119,18 @@
   `(ensuring (fn () ,protection)
              (fn ()    ,@body)))
 
+(mac while (test . body)
+  ; tests 'test, as long as 'test is non-nil,
+  ; repeatedly executes 'body
+  (w/uniq (rfname pred)
+    `(rfnwith ,rfname (,pred ,test)
+        (when ,pred
+          ,@body
+          (,rfname ,test)))))
+
 (mac loop (start test update . body)
+  ; execute 'start. then for as long as 'test returns non-nil,
+  ; execute 'body and 'update
   (w/uniq (gfn gparm)
     `(do ,start
          ((rfn ,gfn (,gparm)
@@ -129,7 +147,21 @@
 (mac mapx (things x expr)
   `(map (fn (,x) ,expr) ,things))
 
-(def empty? (things) (eq? (len things) 0))
+(def atom? (thing)
+  (and thing
+       (!pair? thing)
+       (!hash? thing)))
+
+(def empty? (things)
+  ; t if it's nil or an empty list, string, or hash
+  ; nil otherwise
+  (let l (len things)
+    (and l (eq? l 0))))
+
+(def present? (thing)
+  ; t if it's a symbol or number, or a non-empty string, list or hash
+  ; nil otherwise
+  (!empty? thing))
 
 (mac each (var things code)
   ; repeatedly assigns an element of 'things to 'var,

data/lib/lisp/core-080-pretty-print.nydp

@@ -75,7 +75,7 @@
 
 (def pp/find-breaks/mac (form)
   (if (eq? (dox-what-is? (car form)) 'mac)
-      (let arg-count (+ 1 (len (dox-arg-names (car form))))
+      (let arg-count (list-length:dox-arg-names:car form)
         (cons (firstn arg-count form)
               (map list (nthcdr arg-count form))))))
 

data/lib/lisp/tests/empty-examples.nydp

@@ -0,0 +1,31 @@
+(examples-for empty?
+  ("nonzero"       (empty? "foo-bar")  nil)
+  ("zero"          (empty? "")         t)
+  ("blank"         (empty? "  ")       nil)
+  ("nil is t"      (empty? nil)        t)
+  ("sym is nil"    (empty? 'abc)       nil)
+  ("number is nil" (empty? 234)        nil)
+
+  ("nil for proper list"     (empty? '(a b))            nil)
+  ("nil for improper list"   (empty? '(a b c . d))      nil)
+  ("t for empty hash"        (empty? { })               t)
+
+  ("nil for hash with keys"
+   (empty? { a 11 b 22 c 23 d nil e { nested t counted nil } })
+   nil))
+
+(examples-for present?
+  ("nonzero"       (present? "foo-bar")  t)
+  ("zero"          (present? "")         nil)
+  ("blank"         (present? "  ")       t)
+  ("nil is t"      (present? nil)        nil)
+  ("sym is t"      (present? 'abc)       t)
+  ("number is t"   (present? 234)        t)
+
+  ("t for proper list"       (present? '(a b))            t)
+  ("t for improper list"     (present? '(a b c . d))      t)
+  ("nil for empty hash"      (present? { })               nil)
+
+  ("t for hash with keys"
+   (present? { a 11 b 22 c 23 d nil e { nested t counted nil } })
+   t))

data/lib/lisp/tests/hash-examples.nydp

@@ -1,3 +1,10 @@
+(examples-for hash?
+  ("nil for a cons"    (hash? '(1 a 2 b 3 c))  nil)
+  ("nil for a number"  (hash? 1)               nil)
+  ("nil for a string"  (hash? "werwe")         nil)
+  ("  t for a hash"    (hash? {a 1 b 2})       t  )
+  ("nil for a symbol"  (hash? 'foo)            nil))
+
 (examples-for hash-merge
   ("merge with symbol keys"
    (let h (hash-merge { a 1 b 2 c 3 } { a 99 c 98 d 97 })

data/lib/lisp/tests/len-examples.nydp

@@ -1,11 +1,15 @@
 (examples-for len
-  ("nonzero"  (len "foo-bar")  7)
-  ("zero"     (len "")         0)
+  ("nonzero"       (len "foo-bar")  7)
+  ("zero"          (len "")         0)
+  ("nil is zero"   (len nil)        0)
+  ("sym is nil"    (len 'abc)       nil)
+  ("number is nil" (len 234)        nil)
 
-  ("ignores backslash-escaped interpolation symbol"
-   (len "hello \~world")
-   12)
+  ("ignores backslash-escaped interpolation symbol"  (len "hello \~world")  12)
+  ("returns length of proper list"                   (len '(a b))            2)
+  ("counts last item of  improper list"              (len '(a b c . d))      4)
+  ("counts keys of empty hash"                       (len { })               0)
 
-  ("len returns length of proper list"
-   (len (cons "a" (cons "b" nil)))
-   2))
+  ("counts keys of hash"
+   (len { a 11 b 22 c 23 d nil e { nested t counted nil } })
+   5))

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

@@ -1,3 +1,10 @@
+(examples-for pair?
+  ("  t for a cons"    (pair? '(1 a 2 b 3 c))  t)
+  ("nil for a number"  (pair? 1)               nil)
+  ("nil for a string"  (pair? "werwe")         nil)
+  ("nil for a hash"    (pair? {a 1 b 2})       nil)
+  ("nil for a symbol"  (pair? 'foo)            nil))
+
 (examples-for pairs
   ("'pair breaks a list into pairs"
    (pairs '(1 a 2 b 3 c))

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

@@ -1,7 +1,15 @@
 (examples-for string-split
   ("splits a string using given expression"
    (string-split "a and b and c and d" " and ")
-   ("a" "b" "c" "d")))
+   ("a" "b" "c" "d"))
+
+  ("returns empty leading, internal, and trailing segments"
+   (string-split "and" "and")
+   ("" ""))
+
+  ("returns empty leading, internal, and trailing segments"
+   (string-split "andandand" "and")
+   ("" "" "" "")))
 
 (examples-for string-replace
   ("replaces parts of a string with the given replacement"

data/lib/nydp/builtin/cons.rb

@@ -6,14 +6,4 @@ module Nydp::Builtin
       vm.push_arg Nydp::Pair.new(args.car, args.cdr.car)
     end
   end
-
-  class IsPair
-    include Nydp::Helper, Nydp::Builtin::Base
-
-    def builtin_invoke vm, args
-      arg = args.car
-      result = pair?(arg) ? Nydp.T : Nydp.NIL
-      vm.push_arg result
-    end
-  end
 end

data/lib/nydp/builtin/string_split.rb

@@ -4,7 +4,7 @@ class Nydp::Builtin::StringSplit
   def builtin_invoke vm, args
     target    = args.car.to_s
     separator = args.cdr.car.to_s
-    result    = target.split separator
+    result    = target.split separator, -1
     list      = result.map { |s| Nydp::StringAtom.new s }
 
     vm.push_arg Nydp::Pair.from_list list

data/lib/nydp/core.rb

@@ -60,7 +60,6 @@ module Nydp
       Symbol.mk("thread-locals"  , ns).assign(Nydp::Builtin::ThreadLocals.new)
       Symbol.mk("type-of",      ns).assign(Nydp::Builtin::TypeOf.new(ns))
       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 ns)
       Symbol.mk(:"hash-set",    ns).assign(Nydp::Builtin::HashSet.new)

data/lib/nydp/version.rb

@@ -1,3 +1,3 @@
 module Nydp
-  VERSION = "0.1.7.1"
+  VERSION = "0.1.8"
 end

metadata

@@ -1,14 +1,14 @@
 --- !ruby/object:Gem::Specification
 name: nydp
 version: !ruby/object:Gem::Version
-  version: 0.1.7.1
+  version: 0.1.8
 platform: ruby
 authors:
 - Conan Dalton
 autorequire: 
 bindir: bin
 cert_chain: []
-date: 2015-11-15 00:00:00.000000000 Z
+date: 2015-11-19 00:00:00.000000000 Z
 dependencies:
 - !ruby/object:Gem::Dependency
   name: bundler
@@ -112,6 +112,7 @@ files:
 - lib/lisp/tests/dox-tests.nydp
 - lib/lisp/tests/dynamic-scope-test.nydp
 - lib/lisp/tests/each-tests.nydp
+- lib/lisp/tests/empty-examples.nydp
 - lib/lisp/tests/error-tests.nydp
 - lib/lisp/tests/explain-mac-examples.nydp
 - lib/lisp/tests/foundation-test.nydp