nydp 0.1.10 → 0.1.11

checksums.yaml

@@ -1,7 +1,7 @@
 ---
 SHA1:
-  metadata.gz: 6eec33bbcb86a9efa22b6e3fe9be0ab2f792e54c
-  data.tar.gz: 61bf6dde8f734b52a82779be3b8127714cd4775c
+  metadata.gz: e297c2db504d03a1ae69c9b084c42d2967c409f6
+  data.tar.gz: 14ef550b291308d9fe1b5804a17e82733df7d46e
 SHA512:
-  metadata.gz: 47dd8b9bdd75f050da422385256417a2ed334c1b988dbb718c53f2be91905174af5390a37817b9938eddc09b67b056e718310932fa00375f622240607a33f06c
-  data.tar.gz: d947fab3747a487f5d99db30ae90186ee8b2424fb3370b8463567430afc94ff533c1ec51b7770ecf93aeed1ed919dcdbc5b28886e92487aa1547168187454252
+  metadata.gz: 9b0ee4357faaf3d0d4f2a7be37df48eac75877c3e717c32ac05ab1e57372d36764f2f1d185ba4acbba90e34bb5f73ea8c1165fc8db4d640762ee42bdaedf6985
+  data.tar.gz: 36bd8b57e1b6dfb3634129806931b5d0b4e69caaa7bff59f0540c68a34ad9fc18d96b11d360069a1f38aa474e279b5e75db54fd198bd10fb66553fc73519d760

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

@@ -1,3 +1,12 @@
+(mac and args
+  ; returns last arg if all 'args evaluate to non-nil
+  ; nil otherwise
+  (if args
+      (if (cdr args)
+          `(if ,(car args) (and ,@(cdr args)))
+          (car args))
+      't))
+
 (def orf args
   ; evaluates each arg in 'args, returns the
   ; first non-nil value, or nil if they are
@@ -8,6 +17,12 @@
               (apply orf
                      (cdr args)))))
 
+(def caris (obj things)
+  ; returns true if 'things is a list and the first item of the
+  ; list is the given object
+  (and (isa 'pair things)
+       (eq? (car things)  obj)))
+
 (mac unless (arg . body)
   ; evaluate 'body if 'arg is nil
   `(if (no ,arg) (do ,@body)))
@@ -56,13 +71,6 @@
           `(colon-syntax no ,@(cdar rest))
           `(colon-syntax no ,(car rest)))))
 
-(mac and args
-  (if args
-      (if (cdr args)
-          `(if ,(car args) (and ,@(cdr args)))
-          (car args))
-      't))
-
 (mac when (condition . body)
   `(cond ,condition (do ,@body)))
 
@@ -209,3 +217,8 @@
       (no (cdr args))
       `(brace-list-mono ,(car args))
       (brace-list-build-hash args)))
+
+(mac returning (val . body)
+  ; stores ,val, executes ,@body, and returns ,val.
+  (w/uniq retval
+          `(let ,retval ,val ,@body ,retval)))

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

@@ -53,6 +53,10 @@
                (f items)
                items)))
 
+(def reject (f things)
+  ; return all the items in 'things for which 'f returns nil
+  (collect !f things))
+
 (def nth (n things)
   ; returns the n-th item in the list 'things
   (if (eq? n 0)
@@ -72,12 +76,6 @@
 (mac just    (arg)      arg)
 (def quotify (arg)      `(quote ,arg))
 
-(def caris (obj things)
-  ; returns true if 'things is a list and the first item of the
-  ; list is the given object
-  (and (isa 'pair things)
-       (eq? (car things)  obj)))
-
 (def list-length (things)
   (if (no things)    0
       (atom? things) 1

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

@@ -14,3 +14,25 @@
     (apply joinlists
            (map λx(hash-get tmp x)
                 (sort:hash-keys tmp)))))
+
+(def mapsum (f things)
+  ; map 'f over 'things and sum the resulting list
+  (apply + 0.0 (map f things)))
+
+(def hash-values (h)
+  ; return values for each key in hash 'h
+  (map (fn (k) h.,k) (hash-keys h)))
+
+(def seen? ()
+  ; returns a new function f which takes a parameter x
+  ; for each call to f with any value Z for x
+  ; f returns true if this f has previously seen Z
+  ; f returns nil otherwise.
+  ; Note that each call to 'seen? returns a new function with
+  ; its own history independent of previous calls to 'seen?
+  (let seen (hash)
+    λx(returning seen.,x (= seen.,x t))))
+
+(def uniqify (things)
+  ; return a list containing all the elements of 'things, but with no duplicates
+  (reject (seen?) things))

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

@@ -49,7 +49,10 @@
 
   ("adds 1 float"   (+ 4.2)         4.2)
   ("adds 2 floats"  (+ 4.2 4.5)     8.7)
-  ("adds 3 floats"  (+ 1.1 2.2 3.3) 6.6))
+  ("adds 3 floats"  (+ 1.1 2.2 3.3) 6.6)
+
+  ("adds days"             (let d (date 2015 11  8) (to-string (+ d  1))) "2015-11-09")
+  ("adds more days"        (let d (date 2015 11  8) (to-string (+ d 10))) "2015-11-18"))
 
 (examples-for -
   ("subtracts nothing"   (-)            0)
@@ -59,7 +62,13 @@
 
   ("subtracts 1 float"   (- 4.2)        -4.2)
   ("subtracts 2 floats"  (- 4.2 4.7)    -0.5)
-  ("subtracts 3 floats"  (- 6.6 1.1 3.3) 2.2))
+  ("subtracts 3 floats"  (- 6.6 1.1 3.3) 2.2)
+
+  ("subtracts a day"       (let d (date 2015 11 18) (to-string (- d  1))) "2015-11-17")
+  ("subtracts more days"   (let d (date 2015 11 18) (to-string (- d  5))) "2015-11-13")
+
+  ("subtracts two dates"   (- (date 2015 11 18) (date 2015 11  2))  16)
+  ("subtracts two dates"   (- (date 2015 11 18) (date 2015 12 25)) -37))
 
 (examples-for *
   ("multiplies nothing"   (*)            1)

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

@@ -26,3 +26,36 @@
    (collect (fn (x) (eq? (len x) 20))
             "zz")
    nil))
+
+(examples-for reject
+  ("returns all non-matching items in a list"
+   (reject (fn (x) (eq? (len x) 2))
+            (list "foo" "bar" "xx" "pp"))
+   ("foo" "bar"))
+
+  ("returns everything when nothing matches"
+   (reject (fn (x) (eq? (len x) 20))
+            (list "foo" "bar" "xx" "pp"))
+   ("foo" "bar" "xx" "pp"))
+
+  ;; kind of pointless
+  ("returns non-nils in list if nil is the matching item"
+   (reject no (list "foo" "bar" nil "pp" nil))
+   ("foo" "bar" "pp"))
+
+  ("returns item if it's an atom and doesn't match"
+   (reject (fn (x) (eq? (len x) 3)) "zz")
+   "zz")
+
+  ("preserves structure of improper list"
+   (reject (fn (x) (eq? (len x) 2)) '("aa" "bbb" "cc" "ddd" . "eee"))
+   ("bbb" "ddd" . "eee"))
+
+  ("ignores last-cons if matching"
+   (reject (fn (x) (eq? (len x) 2)) '("aa" "bbb" "cc" "ddd" . "ee"))
+   ("bbb" "ddd"))
+
+  ("returns thing if it's an atom and doesn't match"
+   (reject (fn (x) (eq? (len x) 20))
+            "zz")
+   "zz"))

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

@@ -36,4 +36,8 @@
  ("recognises friday"     (let d (date 2015 11  6) d.friday?   ) t   )
  ("recognises not friday" (let d (date 2015 11  7) d.friday?   ) nil )
  ("recognises saturday"   (let d (date 2015 11  7) d.saturday? ) t   )
- ("recognises sunday"     (let d (date 2015 11  8) d.sunday?   ) t   ))
+ ("recognises sunday"     (let d (date 2015 11  8) d.sunday?   ) t   )
+ ("adds days"             (let d (date 2015 11  8) (to-string (+ d  1))) "2015-11-09")
+ ("adds more days"        (let d (date 2015 11  8) (to-string (+ d 10))) "2015-11-18")
+ ("subtracts a day"       (let d (date 2015 11 18) (to-string (- d  1))) "2015-11-17")
+ ("subtracts more days"   (let d (date 2015 11 18) (to-string (- d  5))) "2015-11-13"))

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

@@ -1,3 +1,8 @@
+(examples-for hash-values
+  ("returns the list of values of the given hash"
+   (hash-values { a 1 b 2 c 'c d "hello" })
+   (1 2 c "hello")))
+
 (examples-for hash?
   ("nil for a cons"    (hash? '(1 a 2 b 3 c))  nil)
   ("nil for a number"  (hash? 1)               nil)

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

@@ -18,3 +18,26 @@
   ("nil for 42 in list not containing 42"
    (include? 42 '(1 2 nil 3 (a b c) 4))
    nil))
+
+(examples-for seen?
+  ("returns a function which returns t for every previously-seen argument, nil otherwise"
+   (map (seen?) '(a b c d a a e f b b g h c c i j d d k l a b c d))
+   (nil nil nil nil t t nil nil t t nil nil t t nil nil t t nil nil t t t t))
+
+  ("each 'seen? is independent"
+   (with (s1 (seen?) s2 (seen?) syms '(a b c a d b e c f))
+         (list (map s1 syms) (map s2 syms)))
+   ((nil nil nil t nil t nil t nil)
+    (nil nil nil t nil t nil t nil))))
+
+(examples-for uniqify
+  ("returns a list with duplicates removed"
+   (uniqify '(a b c d a a e f b b g h c c i j d d k l a b c d))
+   (a b c d e f g h i j k l))
+
+  ("removes duplicate dates"
+   (let d (date 2004 3 12)
+     (joinstr " "
+              (uniqify (map λx(+ d x)
+                            '(0 2 3 3 4 3 5 0 5) ))))
+   "2004-03-12 2004-03-14 2004-03-15 2004-03-16 2004-03-17"))

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

@@ -0,0 +1,10 @@
+(examples-for mapsum
+  ("maps a function over a list and sums the result"
+   (mapsum car '((2 3) (5 7) (11 13)))
+   18)
+
+  ("extracts an attribute and sums the result"
+   (mapsum &age (list { name "a" age 10 }
+                      { name "b" age  7 }
+                      { name "c" age 12 }))
+   29))

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

@@ -0,0 +1,6 @@
+(examples-for returning
+  ("it stores a value, executes body, returns the stored value"
+   (let x 2
+     (returning x
+       (= x 3)))
+   2))

data/lib/nydp/date.rb

@@ -24,7 +24,6 @@ module Nydp
     def to_ruby   ; ruby_date         ; end
     def inspect   ; ruby_date.inspect ; end
     def nydp_type ; :date             ; end
-    def - other   ; r2n(ruby_date - other.ruby_date, nil) ; end
     def + int     ; r2n(ruby_date + int            , nil) ; end
     def > other   ; ruby_date > other.ruby_date           ; end
     def < other   ; ruby_date < other.ruby_date           ; end
@@ -33,6 +32,14 @@ module Nydp
     def eql? d    ; self == d                             ; end
     def hash      ; ruby_date.hash                        ; end
 
+    def - other
+      if other.is_a? Nydp::Date
+        r2n(ruby_date - other.ruby_date, nil)
+      else
+        r2n(ruby_date - other, nil)
+      end
+    end
+
     @@pass_through = %i{ monday? tuesday? wednesday? thursday? friday? saturday? sunday? }
     @@keys = Set.new %i{
       year       month      week_day           day

data/lib/nydp/version.rb

@@ -1,3 +1,3 @@
 module Nydp
-  VERSION = "0.1.10"
+  VERSION = "0.1.11"
 end

metadata

@@ -1,14 +1,14 @@
 --- !ruby/object:Gem::Specification
 name: nydp
 version: !ruby/object:Gem::Version
-  version: 0.1.10
+  version: 0.1.11
 platform: ruby
 authors:
 - Conan Dalton
 autorequire: 
 bindir: bin
 cert_chain: []
-date: 2016-01-22 00:00:00.000000000 Z
+date: 2016-01-23 00:00:00.000000000 Z
 dependencies:
 - !ruby/object:Gem::Dependency
   name: bundler
@@ -123,11 +123,13 @@ files:
 - lib/lisp/tests/isa-examples.nydp
 - lib/lisp/tests/len-examples.nydp
 - lib/lisp/tests/list-tests.nydp
+- lib/lisp/tests/mapsum-examples.nydp
 - lib/lisp/tests/parser-tests.nydp
 - lib/lisp/tests/pre-compile-examples.nydp
 - lib/lisp/tests/pretty-print-tests.nydp
 - lib/lisp/tests/quasiquote-examples.nydp
 - lib/lisp/tests/range-examples.nydp
+- lib/lisp/tests/returning-examples.nydp
 - lib/lisp/tests/rfnwith-tests.nydp
 - lib/lisp/tests/sort-examples.nydp
 - lib/lisp/tests/string-tests.nydp