nydp 0.2.2 → 0.2.3

checksums.yaml

@@ -1,7 +1,7 @@
 ---
 SHA1:
-  metadata.gz: 0efb226f96102a49ecfc52dcd363de20d26a7f3f
-  data.tar.gz: f8423c03ffc9f016396d9daf7934f6a3e5df133d
+  metadata.gz: 546120f25e3fa424942cb1d4f6296da7007fa3a1
+  data.tar.gz: afc6a8ac316812422abd8b4d8aa0e7c870ab73fd
 SHA512:
-  metadata.gz: b5c3030351ffef2de2d5e922f1f75c4639ca0ef7a616301335b7c015c172461865421502c0615bd594186702f6fe29244a14ae25a1c9959913a5d457d6eabd9f
-  data.tar.gz: 87d733099303526473ef61fb7b3e75738b7f2b3f86698fa5bc1f26d811c5fd54c7f359b0fe675ddd521fde85185e3c577bd0c0fae94b57955ae6a5399b5e1bc4
+  metadata.gz: a8d144329085f686df6e0b3b12be6fb207e08fe0edca7633088d3a59095cdf1c0953636b8faf352037bdd22fc13dbc822604a76b6f6709b1e3d74787362ad34c
+  data.tar.gz: 6c0875dfd8712fc2fb22dd987cc4cf323d7e4c39b6444e4da0b6e8790706e3f7714f0e1fdac563edad9ce1104cb1e38600becb3fdcadd668b498d0c2b5c9384c

data/LICENSE.txt

@@ -1,4 +1,4 @@
-Copyright (c) 2013 conanite
+Copyright (c) 2013-2016 Conan Dalton conan@conandalton.net
 
 MIT License
 

data/bin/nydp

@@ -2,4 +2,4 @@
 
 require 'nydp'
 
-Nydp.repl
+Nydp.repl verbose: ($*.include? "-v")

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

@@ -1,4 +1,3 @@
-
 (assign mac-expand (fn (names macfn expr)
   (cond macfn
         (pre-compile-with names

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

@@ -1,20 +1,21 @@
 (def privately () nil)
 
-((fn (this-chapter-name chapters chapter-new chapter-build chapter-find-by-name chapter-add-to-chapter)
+((fn (this-chapter-name chapters chapter-new chapter-build chapter-add-to-chapter)
      (assign chapters (hash))
 
      (def chapter-end ()
        (assign this-chapter-name nil))
 
-     (def chapter-start (name description)
-       (assign this-chapter-name name)
-       (chapter-describe description))
+     (def chapter-start (chapter-name description)
+       (assign this-chapter-name chapter-name)
+       (chapter-describe description chapter-name))
 
      (def chapter-new (hsh name)
        (hash-set hsh 'name name)
        hsh)
 
      (def chapter-names () (hash-keys chapters))
+     (def chapter-current () this-chapter-name)
 
      (def chapter-build (name chapter)
        (cond chapter
@@ -24,11 +25,8 @@
                              name
                              (chapter-new (hash) name)))))
 
-     (def chapter-find-by-name (name)
-       (chapter-build name (hash-get chapters name)))
-
      (def chapter-find (name)
-       (chapter-find-by-name (cond name name this-chapter-name)))
+       (chapter-build name (hash-get chapters name)))
 
      (def chapter-add-to-chapter (chapter attribute thing)
        (cond chapter
@@ -55,7 +53,7 @@
        (hash-set hsh 'texts    texts       )
        (hash-set hsh 'args     args        )
        (hash-set hsh 'src      src         )
-       (hash-set hsh 'chapters chapters    )
+       (hash-set hsh 'chapters (cons (chapter-current) chapters))
        (hash-set hsh 'file     this-script )
        (hash-set hsh 'plugin   this-plugin )
        hsh)
@@ -69,7 +67,6 @@
              (dox-new (dox-build (hash) name what texts args src chapters))))
 
      (def dox-add-to-chapters (item chapters)
-       (chapter-add-item item)
        (cond chapters
              (do (chapter-add-item    item (car chapters))
                  (dox-add-to-chapters item (cdr chapters)))

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

@@ -12,8 +12,8 @@
              '(cond (no args) nil
                     (cond (cdr args)
                           (cond (cddr args)
-                                `(cond ,(car twargs) ,(cadr twargs) (if ,@(cddr twargs)))
-                                `(cond ,(car twargs) ,(cadr twargs)))
+                                `(cond ,(car args) ,(cadr args) (if ,@(cddr args)))
+                                `(cond ,(car args) ,(cadr args)))
                           (car args)))
              '(flow-control))
 

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

@@ -1,3 +1,7 @@
+(chapter-start 'nydp/syntax "Provides core nydp keywords and syntax, including lazy
+boolean expressions, special syntax for symbols and lists, special macros for
+scoping, assignment, anonymous functions and more...")
+
 (mac and args
   ; returns last arg if all 'args evaluate to non-nil
   ; nil otherwise
@@ -20,7 +24,7 @@
 (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)
+  (and (pair? things)
        (eq? (car things)  obj)))
 
 (mac unless (arg . body)
@@ -167,8 +171,13 @@
 (mac hash-lookup (names)
   (build-hash-getters names nil))
 
-(mac dot-syntax names `(hash-lookup ,names))
-(mac dollar-syntax (_ name) `(,name))
+(mac dot-syntax names
+  ; parser expands a.b to (dot-syntax a b)
+  `(hash-lookup ,names))
+
+(mac dollar-syntax (_ name)
+  ; parser expands a$b to (dollar-syntax a b)
+  `(,name))
 
 (def dot-syntax-assignment (names value-expr)
   (let rnames (rev names)
@@ -180,6 +189,8 @@
   `(hash-set ,@lookup ,value))
 
 (mac = (name value)
+  ; generic assignment which unlike builtin 'assign, knows how to assign
+  ; to hash keys
   (if (isa 'symbol name)
       `(assign ,name ,value)
       (caris 'dot-syntax name)
@@ -187,7 +198,13 @@
       (caris 'hash-get name)
       (hash-get-assignment (cdr name) value)))
 
-(mac def-assign args `(= ,@args))
+(mac def-assign args
+  ; override previous definition to allow expressions like (def hsh.foo (arg arg2) ...)
+  `(= ,@args))
+
+(mac or= (place val)
+  ; evaluate ,val and assign result to ,place only if ,place is already nil
+  `(or ,place (= ,place ,val)))
 
 (def brace-list-hash-key (k)
   (if (isa 'symbol k)      `(quote ,k)
@@ -207,16 +224,23 @@
       `(fn (obj) ,(build-hash-lookup-from 'obj (list arg)))))
 
 (mac ampersand-syntax (pfx . rest)
+  ; parser expands a&b to (ampersand-syntax a b)
   (if (no (eq? pfx '||))
       (error "Irregular '& syntax: got prefix ~(inspect pfx) in ~(joinstr "&" (cons pfx rest))"))
   (if (cdr rest)
       (error "Irregular '& syntax: got suffix ~(inspect (cdr rest)) in ~(joinstr "&" (cons pfx rest))")
       (build-ampersand-syntax (car rest))))
 
-(mac brace-list-mono (arg) arg)
-(mac brace-list-empty () '(hash))
+(mac brace-list-mono (arg)
+  ; override 'brace-list-mono in order to provide a useful interpretation for "{ x }" syntax
+  arg)
+
+(mac brace-list-empty ()
+  ; interprets "{ }" as new hash
+  '(hash))
 
 (mac brace-list args
+  ; parser expands { foo bar } to (brace-list foo bar)
   (if (no args)
       `(brace-list-empty)
       (no (cdr args))
@@ -224,9 +248,12 @@
       (brace-list-build-hash args)))
 
 (mac returnlet (var val . body)
-  ; stores ,val in ,var, executes ,@body, returns ,var
+  ; stores ,val in ,var, executes ,@body, returns ,var. Saves a line of code at the end of
+  ; 'let. Assumes 'body is going to do something destructive with 'val, but you want 'val before
+  ; it gets changed. See also 'returning
   `(let ,var ,val ,@body ,var))
 
 (mac returning (val . body)
-  ; stores ,val, executes ,@body, and returns ,val.
+  ; stores ,val, executes ,@body, and returns ,val. Assumes 'body is going to do something
+  ; destructive with 'val, but you want 'val before it gets changed. See also 'returnlet
   (w/uniq retval `(returnlet ,retval ,val ,@body)))

data/lib/lisp/core-035-flow-control.nydp

@@ -0,0 +1,50 @@
+(chapter-start 'flow-control "constructs for looping and error management")
+
+(mac on-err (handler . body)
+  ; executes 'body. If an error is raised, executes 'handler. Inside
+  ; 'handler, the parameter 'err refers to the error that was raised.
+  `(handle-error (fn (err) ,handler)
+                 (fn ()    ,@body)))
+
+(mac ensure (protection . body)
+  ; executes 'body. Afterwards, executes 'protection.
+  ; 'protection is always executed even if there is an error.
+  `(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)
+            (if ,gparm
+                (do ,@body ,update (,gfn ,test))))
+          ,test))))
+
+(mac for (v init max . body)
+  ; assign 'init to 'v, then execute 'body 'max times,
+  ; incrementing 'v at each iteration
+  (w/uniq (gi gm)
+    `(with (,v nil ,gi ,init ,gm (+ ,max 1))
+       (loop (assign ,v ,gi) (< ,v ,gm) (assign ,v (+ ,v 1))
+         ,@body))))
+
+(def curry (func . args1)
+  ; return a new function which is the original function with
+  ; the given args1 already applied
+  ; arguments to the new function are whatever arguments remain
+  ; for the old function
+  (fn args
+      (apply func
+             (joinlists args1
+                        args))))

data/lib/lisp/core-037-list-utils.nydp

@@ -0,0 +1,38 @@
+(chapter-start 'list-manipulation "utilities for manipulating and iterating over lists, including filters and transforms")
+
+(def zip (a b)
+  ; takes two lists, (p q r) and (1 2 3), returns ((p 1) (q 2) (r 3))
+  (if a
+      (cons (list (car a) (car b))
+            (zip (cdr a) (cdr b)))))
+
+(def eachr (f things)
+     (when things
+       (eachr f (cdr things))
+       (f (car things))))
+
+(mac push (x things)
+  `(= ,things (cons ,x ,things)))
+
+(def flatten (things)
+     (let acc nil
+          (rfnwith flattenize (x things)
+                   (if (pair? x)
+                       (eachr flattenize x)
+                       (push x acc)))
+          acc))
+
+(def assoc (key al)
+  ; given a list 'al of form '( (k0 v0) (k1 v1) (k2 v2) ... (kn vn) ) and
+  ; a 'key, returns the list (kx vx) from 'al where kx is equal to 'key
+  ; #attribution: inspiration from arc.arc
+  (if (pair? al)
+      (if (caris key (car al))
+          (car al)
+          (assoc key (cdr al)))))
+
+(def alref (key al)
+  ; given a list 'al of form '( (k0 v0) (k1 v1) (k2 v2) ... (kn vn) ) and
+  ; a 'key, returns vx from 'al where kx is equal to 'key
+  ; #attribution: lifted almost directly from arc.arc
+  (cadr (assoc key al)))

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

@@ -1,55 +1,4 @@
-(def today ()
-  ; return a date for the current day
-  (date))
-
-(def eachr (f things)
-     (when things
-       (eachr f (cdr things))
-       (f (car things))))
-
-(def zip (a b)
-  ; takes two lists, (p q r) and (1 2 3), returns ((p 1) (q 2) (r 3))
-  (if a
-      (cons (list (car a) (car b))
-            (zip (cdr a) (cdr b)))))
-
-(mac push (x things)
-  `(= ,things (cons ,x ,things)))
-
-(def flatten (things)
-     (let acc nil
-          (rfnwith flattenize (x things)
-                   (if (pair? x)
-                       (eachr flattenize x)
-                       (push x acc)))
-          acc))
-
-(def list-slices (things slice-size)
-     ; slice 'things into a list of lists each with maximum 'slice-size items
-     (chapter pagination)
-     (chapter list-manipulation)
-     (if (< (len things) slice-size)
-         (cons things nil)
-         (cons (firstn slice-size things)
-               (list-slices (nthcdr slice-size things)
-                            slice-size))))
-
-(def intersperse (inbetween things)
-  ; return a new list with 'inbetween in between every element of 'things
-  (if (and (pair? things) (cdr things))
-      (apply list (car things) inbetween
-             (intersperse inbetween (cdr things)))
-      things))
-
-(def intersperse-splicing (inbetween things)
-  ; expects 'things a list of lists, joins the lists
-  ; placing 'inbetween in between each list.
-  ; For example (intersperse-splicing 'X '((a b) (c d) (e f)))
-  ; returns (a b X c d X e f)
-  (apply joinlists (intersperse (list inbetween) things)))
-
-(def string-strip (txt)
-  (string-replace "(^\\s+|\\s+$)" "" txt))
+(chapter-start 'nydp-core "essential functions for getting anything done")
 
 (def joinstr (txt . things)
   ; flatten 'things into a single list (ie unnest lists)
@@ -63,43 +12,6 @@
            (flatten (zip (map (fn (_) txt) (cdr joinables))
                          (map to-string (cdr joinables)))))))
 
-(def j items
-  ; delegate to 'joinstr with an empty join string
-  ; shortcut for (joinstr ""  items)
-  (joinstr "" items))
-
-(def string-pieces pieces
-  ; string-interpolation syntax emits this form. Default implementation
-  ; is to delegate to 'j , but containing forms may use macros that
-  ; override this in order to provide specific interpolation behaviour
-  ; (for example, formatting numbers or stripping HTML tags)
-  (j pieces))
-
-(def collect (f things)
-  ; if 'things is a list, return all the items in the list for which 'f returns non-nil
-  ; otherwise, return 'things if (f things) is non-nil
-  ; otherwise, nil
-  (rfnwith collector (items things)
-           (if (no items)
-               nil
-               (pair? items)
-               (if (f (car items))
-                   (cons (car items)
-                         (collector (cdr items)))
-                   (collector (cdr items)))
-               (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)
-      (car things)
-      (nth (- n 1) (cdr things))))
-
 (def iso (x y)
      (or (eq? x y)
          (and (pair? x)
@@ -107,22 +19,23 @@
               (iso (car x) (car y))
               (iso (cdr x) (cdr y)))))
 
-(def x1      (thing)    thing)
-(def sym?    (arg)      (isa 'symbol arg))
-(def string? (arg)      (isa 'string arg))
-(mac just    (arg)      arg)
-(def quotify (arg)      `(quote ,arg))
-
-(def list-length (things)
-  (if (no things)    0
-      (atom? things) 1
-      (+ 1 (list-length:cdr things))))
-
-(def len (xs)
-  (if (no xs)      0
-      (pair? xs)   (list-length xs)
-      (string? xs) (string-length xs)
-      (hash? xs)   (list-length:hash-keys xs)
+(def x1      (thing) thing)
+(def sym?    (arg)   (isa 'symbol arg))
+(def string? (arg)   (isa 'string arg))
+(mac just    (arg)   arg)
+(def quotify (arg)   `(quote ,arg))
+
+(def len (things)
+  ; return the length of 'things where 'things may be nil, a string, list or hash
+  ; length of nil is zero, length of hash is number of keys, length of string
+  ; is number of characters, length of list is number of direct items - no recursive counting
+  (chapter list-manipulation)
+  (chapter string-manipulation)
+  (chapter hash-manipulation)
+  (if (no things)      0
+      (pair? things)   (list-length things)
+      (string? things) (string-length things)
+      (hash? things)   (list-length:hash-keys things)
       nil))
 
 (assign dynamics (hash))
@@ -142,53 +55,16 @@
                              ,result))))
            (def ,name () (hash-get (thread-locals) ',name))))))
 
-(mac on-err (handler . body)
-  ; executes 'body. If an error is raised, executes 'handler. Inside
-  ; 'handler, the parameter 'err refers to the error that was raised.
-  `(handle-error (fn (err) ,handler)
-                 (fn ()    ,@body)))
-
-(mac ensure (protection . body)
-  ; executes 'body. Afterwards, executes 'protection.
-  ; 'protection is always executed even if there is an error.
-  `(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)
-            (if ,gparm
-                (do ,@body ,update (,gfn ,test))))
-          ,test))))
-
-(mac for (v init max . body)
-  ; assign 'init to 'v, then execute 'body 'max times,
-  ; incrementing 'v at each iteration
-  (w/uniq (gi gm)
-    `(with (,v nil ,gi ,init ,gm (+ ,max 1))
-       (loop (assign ,v ,gi) (< ,v ,gm) (assign ,v (+ ,v 1))
-         ,@body))))
-
 (mac mapx (things x expr)
   ; a macro wrapper for 'map
   ; 'things is a list, 'x is the name of a variable, and 'expr
   ; is evaluated and collected for each 'x in 'things
+  (chapter list-manipulation)
   `(map (fn (,x) ,expr) ,things))
 
 (def atom? (thing)
   ; 't if 'thing is not a list or a hash
+  (chapter nydp-core)
   (and thing
        (!pair? thing)
        (!hash? thing)))
@@ -196,123 +72,16 @@
 (def empty? (things)
   ; t if it's nil or an empty list, string, or hash
   ; nil otherwise
+  (chapter list-manipulation)
+  (chapter string-manipulation)
+  (chapter hash-manipulation)
   (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
+  (chapter list-manipulation)
+  (chapter string-manipulation)
+  (chapter hash-manipulation)
   (!empty? thing))
-
-(mac each (var things code)
-  ; repeatedly assigns an element of 'things to 'var,
-  ; and executes 'code each time
-  (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)))
-
-(def proper? (list)
-  ; t if this is a proper list (last cdr is nil)
-  ; nil otherwise (last cdr is neither cons nor nil)
-  (or (no list)
-      (and (pair? list)
-           (proper? (cdr list)))))
-
-(def firstn (n things)
-  ; returns the first 'n items in the list 'things
-  (if (eq? n 0) nil
-      (cons (car things)
-            (firstn (- n 1)
-                    (cdr things)))))
-
-(def nthcdr (n things)
-  ; returns the nth cdr of the list 'things
-  (if (> n 0)
-      (nthcdr (- n 1) (cdr things))
-      things))
-
-(def joinlists (things . more-thingses)
-  ; return a new list which is the concatenation of all the given lists
-  ; 'things is a list
-  ; 'more-thingses is a list of lists
-  ; call like this: (joinlists '(a b c) '(x y z) '(1 2 3))
-  (if things
-      (cons (car things)
-            (apply joinlists
-                   (cdr things)
-                   more-thingses))
-      more-thingses
-      (apply joinlists more-thingses)))
-
-(def curry (func . args1)
-  ; return a new function which is the original function with
-  ; the given args1 already applied
-  ; arguments to the new function are whatever arguments remain
-  ; for the old function
-  (fn args
-      (apply func
-             (joinlists args1
-                        args))))
-
-(def detect (f things)
-  ; if 'f is a function,
-  ;   if 'things is a list, return the first item in the list for which 'f returns non-nil
-  ;   otherwise, return 'things if (f things) is non-nil
-  ;   otherwise, nil
-  ; if 'f is not a function, self-invoke with a function checking for equality with f
-  ;
-  ; WARNING: if the detected thing is nil, returns t instead. A return value of nil
-  ; means the thing was not found ; non-nil means the thing was found, including when
-  ; the found thing is itself nil.
-  (if (isa 'fn f)
-      (rfnwith d (items things)
-                 (if (pair? items)
-                     (let it (car items)
-                       (or
-                        (and (f it)
-                             (or it t))
-                        (d:cdr items)))
-                     (f items)
-                     items))
-      (detect (curry eq? f)
-              things)))
-
-(def tuples (n things)
-  ;; split things into a list of lists each n long
-  (rfnwith _ (list things)
-           (if (no list)
-               nil
-               (cons (firstn n list) (_ (nthcdr n list))))))
-
-(def range (start stop)
-  ; return a list containing the range
-  ; of elements starting with 'start, up
-  ; to but not including 'stop
-  (if (< start stop)
-      (cons start
-            (range (+ start 1)
-                   stop))))
-
-(def best (f things)
-  (if (no things)
-      nil
-      (let winner (car things)
-        (each thing (cdr things)
-              (if (f thing winner)
-                  (= winner thing)))
-        winner)))
-
-(def min things (best < things))
-(def max things (best > things))