nydp 0.4.0 → 0.4.1

checksums.yaml

@@ -1,7 +1,7 @@
 ---
 SHA1:
-  metadata.gz: 8d9a87eb0c014a51f391ddd1ba6686165a01ab48
-  data.tar.gz: 8c3f3146c0ae8dc18ac6e86324274423d75be651
+  metadata.gz: 858b22d67ba13ec86efe8a00fd10b5fa813aee8c
+  data.tar.gz: 24876cc3c6e1389f656640d3548574d7241b3725
 SHA512:
-  metadata.gz: f946a10304dd7422fb73243b9cd3ef40fab33aa9ff4f0b53568278761b64905d00714ed0cf7401db29b8c3613d8a683460ed48feef3f174ab0c724dd3e5f922e
-  data.tar.gz: 1925438dd0eca5a718e6f41ff39ef9f35e1a9ed18279e58f2ebfa88c284cb46526f4864932db706dc346662a59cb153fbec70fca1047aeddc742740de971dab5
+  metadata.gz: 2c0094a86976f2272a70b9c5ea8b76e36face05f089ad9c7a0d51c3de251081230ce85d37e11f9ccaf23cd3d0433a655464d9193dfba37f1e1526fd929e03a13
+  data.tar.gz: 9eb38db6a571768e8da0bdddbd6420e7627f492748aa64aac0e8e48e08c9af416da84c5be0b8e3828559d1988de250f9f72eaa3d25166f5001c7a1896a9d8203

data/lib/lisp/core-015-documentation.nydp

@@ -1,5 +1,24 @@
 (def privately () nil)
 
+(assign comments nil)
+
+(def fetch-and-clear-comments ()
+  ((fn (c) (assign comments nil) c) (rev comments)))
+
+(def filter-comments (form acc)
+  (if (no form)
+      (rev acc)
+      (pair? form)
+      (filter-comments (cdr form)
+                       (if (if (pair? (car form))
+                               (eq? (caar form)
+                                    'comment))
+                           acc
+                           (cons (filter-comments (car form)
+                                                  nil)
+                                 acc)))
+      form))
+
 ((fn (this-chapter-name chapters chapter-new chapter-build chapter-add-to-chapter)
      (assign chapters (hash))
 
@@ -171,10 +190,10 @@
 
 (def define-def-expr (name args body-forms)
   ; used internally by 'def
-  `(do (def-assign ,name (fun ,args ,@(hash-get body-forms nil)))
+  `(do (def-assign ,name (fun ,args ,@(filter-comments (hash-get body-forms nil))))
        (dox-add-doc ',name
                     'def
-                    ',(map car (hash-get body-forms 'comment))
+                    ',(+ (fetch-and-clear-comments) (map car (hash-get body-forms 'comment)))
                     ',args
                     '(def ,name ,args ,@(hash-get body-forms nil))
                     ',(map car (hash-get body-forms 'chapter)))))
@@ -183,3 +202,7 @@
   ; define a new function in the global namespace
   (chapter nydp-core)
   (define-def-expr name args (filter-forms (build-def-hash (hash)) body)))
+
+(mac comment (txt)
+  (assign comments (cons txt comments))
+  nil)

data/lib/lisp/core-017-builtin-dox.nydp

@@ -41,6 +41,9 @@
 (dox-add-doc 'inspect   'def '("return a string representing 'arg, potentially (but not always) in a way that can be parsed back in to get the original object") '(arg)                nil '(nydp-core))
 (dox-add-doc 'comment   'def '("does nothing at all." "Intercepted inside 'def and 'mac and used for documentation")                                             '(arg)                nil '(nydp-core))
 (dox-add-doc 'parse-in-string 'def '("parse the given string assuming a string-open delimiter has already been encountered")                                     '(str)                nil '(nydp-core))
+(dox-add-doc 'rand            'def '("return a random number ; with no args, between 0 and 1"
+                                     "with 1 arg, an integer less than arg"
+                                     "with two args, an integer >= arg 0 and < arg 1")                                                                           'args                 nil '(math))
 (dox-add-doc 'random-string   'def '("return a random string of length 'len (default 10)")                                                                       '(len)                nil '(string-manipulation))
 (dox-add-doc 'to-string       'def '("return a human-readable string representation of 'arg")                                                                    '(arg)                nil '(string-manipulation))
 (dox-add-doc 'string-length   'def '("return the length of 'arg")                                                                                                '(arg)                nil '(string-manipulation))
@@ -78,6 +81,8 @@
 (dox-add-doc 'chapter-current 'def '("Get the name of the chapter in progress right now - this is normally the last value sent to 'chapter-start")               nil                   nil '(nydp/documentation))
 (dox-add-doc 'chapter-delete  'def '("Remove the named chapter")                                                                                                 '(name)               nil '(nydp/documentation))
 (dox-add-doc 'chapter-find    'def '("Get the named chapter")                                                                                                    '(name)               nil '(nydp/documentation))
+(dox-add-doc 'set-intersection 'def '("return the intersection of the given lists")                                                                              'args                 nil '(list-manipulation))
+(dox-add-doc 'set-union       'def '("return the union of the given lists")                                                                                      'args                 nil '(list-manipulation))
 (dox-add-doc 'dox-add-doc     'def '("Store the provided documentation item."
                                      "'name is the name of the item"
                                      "'what is the type of the item ('def or 'mac or 'thingy ... this is user-definable, not related to 'type-of)"

data/lib/lisp/core-060-benchmarking.nydp

@@ -164,6 +164,19 @@
   (bm-or-lex-lex-lex 1 2 3)
   (bm-or-lex-lex-lex nil 2 3))
 
+(def build-mapsum-data (count data)
+  (if (> count 0)
+      (build-mapsum-data (- count 1)
+                         (cons { mappit (rand 10) }
+                               data))
+      data))
+
+(let mapsum-data (build-mapsum-data 1000)
+  (def bm-mapsum    () (mapsum &mappit mapsum-data))
+  (def bm-mapreduce () (mapreduce &mappit + mapsum-data 0)))
+
+
+
 (def bm-repeat (f n)
   ; used in benchmarking
   (for b 1 n (f)))
@@ -184,7 +197,9 @@
 
 (def rbs (name)
   (let summary nil
-    (push (bm "cond with OR       "   bm-faster-or             10  40000) summary)
+    (push (bm "mapsum    "   bm-mapsum             10  100) summary)
+    (push (bm "mapreduce "   bm-mapreduce          10  100) summary)
+    ;; (push (bm "cond with OR       "   bm-faster-or             10  40000) summary)
     ;; (push (bm "cond with OR       "   bm-cond-9             10  40000) summary)
     ;; (push (bm "cond with OR       "   bm-cond-9             10  100000) summary)
     ;; (push (bm "cond with OR       "   bm-cond-lex-lit-lit             10  100000) summary)

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

@@ -15,13 +15,21 @@
            (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 mapreduce (fmap freduce things)
+  ; same as (reduce freduce (map fmap things))
+  ; returns the resulting list
+  (if (pair? things)
+      (freduce (fmap (car things))
+               (mapreduce fmap freduce (cdr things)))
+      things
+      (freduce (map fmap things))
+      (freduce)))
+
+; map 'f over 'things and sum the resulting list
+(def mapsum (f things) (mapreduce f + things))
+
+; return values for each key in hash 'h
+(def hash-values (h) (map (fn (k) h.,k) (hash-keys h)))
 
 (def seen? ()
   ; returns a new function f which takes a parameter x
@@ -33,9 +41,8 @@
   (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))
+; return a list containing all the elements of 'things, but with no duplicates
+(def uniqify (things) (reject (seen?) things))
 
 (def group-by (f things)
   ; return a hash of 'things keyed by (f thing) for
@@ -54,9 +61,8 @@
         (let mi (m2i anchor)
           (map λm(i2m (+ mi m)) mm))))
 
-(mac auto-hash names
-  ; (auto-hash a b c) same as { a a b b c c }
-  `(brace-list ,@(flatten:map λn(list n n) names)))
+; (auto-hash a b c) same as { a a b b c c }
+(mac auto-hash names `(brace-list ,@(flatten:map λn(list n n) names)))
 
 (mac accum (accfn-name . body)
   (w/uniq acc
@@ -65,18 +71,19 @@
          ,@body
          (rev ,acc)))))
 
-(mac ++ (place inc)
-  `(= ,place (+ ,place ,(or inc 1))))
+; increment the value at 'place by 'inc (default 1)
+(mac ++ (place inc) `(= ,place (+ ,place ,(or inc 1))))
 
+; return a function that returns 'start on first invocation,
+; and 'start + n * 'incr for each nth invocation
 (def seqf (start incr)
   (let i (or incr 1)
     (fn () (returning start (++ start i)))))
 
-(def mapply (f args)
-  ; like 'map, but assumes each item in 'args is a list
-  ; of parameters for 'f. Effectively, calls (apply f item)
-  ; for each item in 'args
-  (map λa(apply f a) args))
+; like 'map, but assumes each item in 'args is a list
+; of parameters for 'f. Effectively, calls (apply f item)
+; for each item in 'args
+(def mapply (f args) (map λa(apply f a) args))
 
 (mac def/cycler (name things)
   ; create a function called 'name ; each invocation of the function will

data/lib/lisp/tests/filter-forms-examples.nydp

@@ -44,3 +44,33 @@
                                  (this)
                                  (that))))
    ((("hello") ("more details") ("very rigourous")) ((this) (that)))))
+
+(examples-for filter-comments
+  ("returns nil for nil"
+   (filter-comments nil nil)
+   nil)
+
+  ("returns atom for atom"
+   (filter-comments 12 nil)
+   12)
+
+  ("returns list for list"
+   (filter-comments '(a b c d) nil)
+   (a b c d))
+
+  ("returns list without comment for list with comment"
+   (filter-comments '(a b (comment "hahaha") c d) nil)
+   (a b c d))
+
+  ("returns nothing for comment"
+   (filter-comments '((comment "hahaha")) nil)
+   nil)
+
+  ("weeds out nested comments"
+   (filter-comments '(1 2 (3 4
+                             (comment "yoyo") 5
+                             (6 7 (comment "eight") 8 9)
+                             { 10 (comment "eleven") 11 12 13 }
+                             (comment "fourteen") 14) (comment "fifteen") 15
+                             (if 16 (comment "seventeen") 17 (comment "eighteen") 18 19)))
+   (1 2 (3 4 5 (6 7 8 9) (brace-list 10 11 12 13) 14) 15 (if 16 17 18 19))))

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

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

data/lib/lisp/tests/set-intersection-examples.nydp

@@ -0,0 +1,16 @@
+(examples-for ⋂
+  ("returns a single arg"
+   (⋂ '(a b c))
+   (a b c))
+
+  ("returns intersection of two args"
+   (⋂ '(a b c) '(a b d))
+   (a b))
+
+  ("returns intersection of three args"
+   (⋂ '(a b c d e) '(a b c d f) '(z b c d g))
+   (b c d))
+
+  ("returns intersection of four args"
+   (⋂ '(a b c d e) '(a b c d f) '(z b d c g) '(z y g c d))
+   (c d)))

data/lib/lisp/tests/set-union-examples.nydp

@@ -0,0 +1,16 @@
+(examples-for ⋃
+  ("returns a single arg"
+   (⋃ '(a b c))
+   (a b c))
+
+  ("returns union of two args"
+   (⋃ '(a b c) '(a b d))
+   (a b c d))
+
+  ("returns union of three args"
+   (⋃ '(a b c d e) '(a b c d f) '(z b c d g))
+   (a b c d e f z g))
+
+  ("returns union of four args"
+   (⋃ '(a b c d e) '(a b c d f) '(z b d c g) '(z y g c d))
+   (a b c d e f z g y)))

data/lib/nydp/builtin/rand.rb

@@ -0,0 +1,18 @@
+class Nydp::Builtin::Rand
+  include Nydp::Builtin::Base, Singleton
+
+  def builtin_invoke_1 vm             ; vm.push_arg rand                ; end
+  def builtin_invoke_2 vm, a          ; vm.push_arg rand(a)             ; end
+  def builtin_invoke_3 vm, a0, a1     ; vm.push_arg(a0 + rand(a1 - a0)) ; end
+  def builtin_invoke   vm, args       ;
+    if Nydp::NIL.is? args
+      builtin_invoke_1 vm
+    else
+      case args.size
+      when 1 ; builtin_invoke_2 vm, args.car
+      when 2 ; builtin_invoke_3 vm, args.car, args.cadr
+      else   ; raise "rand: 0, 1 or 2 args expected, got #{args.length}"
+      end
+    end
+  end
+end

data/lib/nydp/builtin/set_intersection.rb

@@ -0,0 +1,8 @@
+class Nydp::Builtin::SetIntersection
+  include Nydp::Builtin::Base, Singleton
+
+  def builtin_invoke_2       vm, a ; vm.push_arg a               ; end
+  def builtin_invoke_3    vm, a, b ; vm.push_arg(a & b)          ; end
+  def builtin_invoke_4 vm, a, b, c ; vm.push_arg(a & b & c)      ; end
+  def builtin_invoke      vm, args ; vm.push_arg args.reduce &:& ; end
+end

data/lib/nydp/builtin/set_union.rb

@@ -0,0 +1,8 @@
+class Nydp::Builtin::SetUnion
+  include Nydp::Builtin::Base, Singleton
+
+  def builtin_invoke_2       vm, a ; vm.push_arg a               ; end
+  def builtin_invoke_3    vm, a, b ; vm.push_arg(a | b)          ; end
+  def builtin_invoke_4 vm, a, b, c ; vm.push_arg(a | b | c)      ; end
+  def builtin_invoke      vm, args ; vm.push_arg args.reduce &:| ; end
+end

data/lib/nydp/core.rb

@@ -45,6 +45,7 @@ module Nydp
       Symbol.mk(:p,     ns).assign(Nydp::Builtin::Puts.instance)
       Symbol.mk(:PI,    ns).assign 3.1415
       Symbol.mk(:nil,   ns).assign Nydp::NIL
+      Symbol.mk(:rand,  ns).assign Nydp::Builtin::Rand.instance
       Symbol.mk(:sort,  ns).assign Nydp::Builtin::Sort.instance
       Symbol.mk(:sqrt,  ns).assign Nydp::Builtin::Sqrt.instance
       Symbol.mk(:t,     ns).assign Nydp::T
@@ -74,11 +75,15 @@ module Nydp
       Symbol.mk(:"pre-compile" , ns).assign Nydp::Builtin::PreCompile.instance
       Symbol.mk(:"script-run"  , ns).assign Nydp::Builtin::ScriptRun.instance
       Symbol.mk(:"**"          , ns).assign Nydp::Builtin::MathPower.instance
-      Symbol.mk(:"⌊"           , ns).assign Nydp::Builtin::MathFloor.instance
-      Symbol.mk(:"math-floor"  , ns).assign Nydp::Builtin::MathFloor.instance
-      Symbol.mk(:"⌈"           , ns).assign Nydp::Builtin::MathCeiling.instance
-      Symbol.mk(:"math-ceiling", ns).assign Nydp::Builtin::MathCeiling.instance
-      Symbol.mk(:"math-round"  , ns).assign Nydp::Builtin::MathRound.instance
+      Symbol.mk(:"⌊"               , ns).assign Nydp::Builtin::MathFloor.instance
+      Symbol.mk(:"math-floor"      , ns).assign Nydp::Builtin::MathFloor.instance
+      Symbol.mk(:"⌈"               , ns).assign Nydp::Builtin::MathCeiling.instance
+      Symbol.mk(:"math-ceiling"    , ns).assign Nydp::Builtin::MathCeiling.instance
+      Symbol.mk(:"math-round"      , ns).assign Nydp::Builtin::MathRound.instance
+      Symbol.mk(:"⋂"               , ns).assign Nydp::Builtin::SetIntersection.instance
+      Symbol.mk(:"set-intersection", ns).assign Nydp::Builtin::SetIntersection.instance
+      Symbol.mk(:"⋃"               , ns).assign Nydp::Builtin::SetUnion.instance
+      Symbol.mk(:"set-union"       , ns).assign Nydp::Builtin::SetUnion.instance
     end
   end
 end

data/lib/nydp/pair.rb

@@ -22,6 +22,9 @@ class Nydp::Pair
   def +    other ; copy.append other                          ; end
   def size       ; 1 + (cdr.is_a?(Nydp::Pair) ? cdr.size : 0) ; end
   def inspect    ; "(#{inspect_rest})"                        ; end
+  def &    other ; self.class.from_list((Set.new(self) & other).to_a)           ; end
+  def |    other ; self.class.from_list((Set.new(self) | other).to_a)           ; end
+  def proper?    ; Nydp::NIL.is?(cdr) || (cdr.is_a?(Nydp::Pair) && cdr.proper?) ; end
 
   # returns Array of elements after calling #n2r on each element
   def to_ruby list=[]
@@ -55,10 +58,6 @@ class Nydp::Pair
     (NIL != other) && (other.respond_to? :car) && (self.car == other.car) && (self.cdr == other.cdr)
   end
 
-  def proper?
-    Nydp::NIL.is?(cdr) || (cdr.is_a?(Nydp::Pair) && cdr.proper?)
-  end
-
   def each &block
     yield car
     cdr.each(&block) unless Nydp::NIL.is?(cdr)

data/lib/nydp/version.rb

@@ -1,3 +1,3 @@
 module Nydp
-  VERSION = "0.4.0"
+  VERSION = "0.4.1"
 end

data/spec/rand_spec.rb

@@ -0,0 +1,45 @@
+require "spec_helper"
+
+describe Nydp::Builtin::Rand do
+  let(:vm) { Nydp::VM.new(ns) }
+
+  let(:randf) { Nydp::Builtin::Rand.instance }
+
+  def get_rand *args
+    randf.invoke vm, pair_list(args)
+    vm.pop_args(1).first
+  end
+
+  describe "zero args" do
+    it "returns values between 0 and 1" do
+      numbers = (0..100).map { |i| get_rand }
+      expect(numbers.all? { |n| n >= 0 && n < 1 })
+      avg = numbers.reduce &:+
+      expect(avg).to be_between 40, 60
+      distinct = Set.new numbers
+      expect(distinct.count).to be > 90
+    end
+  end
+
+  describe "one arg" do
+    it "returns values between 0 and arg" do
+      numbers = (0..200).map { |i| get_rand 10 }
+      expect(numbers.all? { |n| n >= 0 && n < 10 })
+      avg = numbers.reduce &:+
+      expect(avg).to be_between 800, 1200
+      distinct = Set.new numbers
+      expect(distinct.count).to eq 10
+    end
+  end
+
+  describe "two arg" do
+    it "returns values between arg 0 and arg 1" do
+      numbers = (0..200).map { |i| get_rand 10, 20 }
+      expect(numbers.all? { |n| n >= 10 && n < 20 })
+      avg = numbers.reduce &:+
+      expect(avg).to be_between 2800, 3200
+      distinct = Set.new numbers
+      expect(distinct.count).to eq 10
+    end
+  end
+end

metadata

@@ -1,14 +1,14 @@
 --- !ruby/object:Gem::Specification
 name: nydp
 version: !ruby/object:Gem::Version
-  version: 0.4.0
+  version: 0.4.1
 platform: ruby
 authors:
 - Conan Dalton
 autorequire: 
 bindir: bin
 cert_chain: []
-date: 2017-10-20 00:00:00.000000000 Z
+date: 2017-12-14 00:00:00.000000000 Z
 dependencies:
 - !ruby/object:Gem::Dependency
   name: bundler
@@ -147,6 +147,7 @@ files:
 - lib/lisp/tests/list-gsub-examples.nydp
 - lib/lisp/tests/list-match-examples.nydp
 - lib/lisp/tests/list-tests.nydp
+- lib/lisp/tests/mapreduce-examples.nydp
 - lib/lisp/tests/mapsum-examples.nydp
 - lib/lisp/tests/none-examples.nydp
 - lib/lisp/tests/orequal-examples.nydp
@@ -162,6 +163,8 @@ files:
 - lib/lisp/tests/returning-examples.nydp
 - lib/lisp/tests/rfnwith-tests.nydp
 - lib/lisp/tests/seqf-examples.nydp
+- lib/lisp/tests/set-intersection-examples.nydp
+- lib/lisp/tests/set-union-examples.nydp
 - lib/lisp/tests/sort-examples.nydp
 - lib/lisp/tests/string-tests.nydp
 - lib/lisp/tests/syntax-tests.nydp
@@ -202,8 +205,11 @@ files:
 - lib/nydp/builtin/pre_compile.rb
 - lib/nydp/builtin/puts.rb
 - lib/nydp/builtin/quit.rb
+- lib/nydp/builtin/rand.rb
 - lib/nydp/builtin/random_string.rb
 - lib/nydp/builtin/script_run.rb
+- lib/nydp/builtin/set_intersection.rb
+- lib/nydp/builtin/set_union.rb
 - lib/nydp/builtin/sort.rb
 - lib/nydp/builtin/sqrt.rb
 - lib/nydp/builtin/string_match.rb
@@ -256,6 +262,7 @@ files:
 - spec/nydp_spec.rb
 - spec/pair_spec.rb
 - spec/parser_spec.rb
+- spec/rand_spec.rb
 - spec/spec_helper.rb
 - spec/string_atom_spec.rb
 - spec/string_token_spec.rb
@@ -298,6 +305,7 @@ test_files:
 - spec/nydp_spec.rb
 - spec/pair_spec.rb
 - spec/parser_spec.rb
+- spec/rand_spec.rb
 - spec/spec_helper.rb
 - spec/string_atom_spec.rb
 - spec/string_token_spec.rb