nydp 0.1.4 → 0.1.5

checksums.yaml

@@ -1,7 +1,7 @@
 ---
 SHA1:
-  metadata.gz: a7f1dacf6f22c7cd5db09de064fe3cdd11a76654
-  data.tar.gz: 530d35d6fc54b082edb788eec8ccb15078c09582
+  metadata.gz: 37191dabf60a754266ff7898dad970be1f0cedcd
+  data.tar.gz: fa74bdef9dff4ec5be87e23630064e6a9603ea13
 SHA512:
-  metadata.gz: 84db7216bd92545097e6b0dc3f827620c45b80261d3bbdfb18e7f0dfb70dca2b5d3078dfd07be3a0ef5fa107ad2363f9cc66e94a21b1a4b8b09a40c0cb87451a
-  data.tar.gz: 07c739e5165a3c857a43d8c2e04088562897dcede3283a9ae572620a09f24b6cf8836efcb84f8fcd0985a424c24db675c77acff178ed03a43692bd857877d82b
+  metadata.gz: d32cdb68d796ca1434fed7e1e5603e718f00dcadca3779e738e870308e9a4b66a64a5e0d6c5dedb2c09cb0e929fc7560f23b40e8aa32ed42ffbcb702164c3197
+  data.tar.gz: 762f0e8f0b52151b8e85d8b0e4221979207609587f96f061b58fb02c18d55e8a759a10642ffc67cfeb35a7fbea53b4fdd16d42c915606240059b22b4d1f4b01f

data/README.md

@@ -65,7 +65,6 @@ After parsing its input, `'nydp` passes the result as an argument to the `pre-co
 You can override `pre-compile` to transform the expression in any way you wish. By default, the `boot.nydp` implementation of `pre-compile` performs macro-expansion.
 
 
-
 ```lisp
 (def pre-compile (expr)
   (map pre-compile
@@ -80,7 +79,6 @@ nydp > (pre-compile '(yoyo 42))
 ==> (do-yoyo 42)
 ```
 
-
 #### 2. Special symbol syntax
 
 The parser detects syntax embedded in smybol names and emits a form whose first element names the syntax used. Here's an example:
@@ -230,7 +228,7 @@ However, this doesn't need to be built-in, it can be done with macros alone. On
 (def fun (a b . others) ...)
 ```
 
-In this example, `'others` is either nil, or a list containing the third and subsequent arguments to the call to `'fun`. For many examples of this kind of invocation, see [invocation-tests](lib/lisp/tests/invocation-tests.nydp) in the `tests` directory.
+In this example, `others` is either nil, or a list containing the third and subsequent arguments to the call to `fun`. For many examples of this kind of invocation, see [invocation-tests](lib/lisp/tests/invocation-tests.nydp) in the `tests` directory.
 
 
 
@@ -398,6 +396,37 @@ nydp > (p:pp:dox-src 'pp/find-breaks)
 The pretty-printer is still rather primitive in that it only indents according to some hard-coded rules, and according to argument-count
 for documented macros. It has no means of wrapping forms that get too long, or that extend beyond a certain predefined margin or column number.
 
+#### 11 DSLs
+
+The `pre-compile` system (described earlier in "Macro-expansion runs in lisp") is available for implementing local, mini-languages. To do this, use `pre-compile-with`
+in a macro. `pre-compile-with` expects a hash with expansion rules, and an expression to expand using these rules. For example, to build a "describe" dsl :
+
+```lisp
+  (= describe-dsl (hash))
+  (= describe-dsl.def (fn (a b c) `(a-special-kind-of-def ,a ,b ,c)))
+  (= describe-dsl.p   (fn (w)     `(alternative-p ,w)))
+
+  (mac describe (name expr outcome)
+    `(add-description ',name
+       (pre-compile-with describe-dsl ',expr)
+       ',outcome))
+```
+
+In this example, `describe-dsl` establishes rules for expanding `def` and for `p` which will shadow their usual meanings, but only in the context
+of a `describe` form.
+
+This technique is useful to avoid cluttering the global macro-namespace with rules that are used only in a specific context. A word of warning:
+if you shadow a popular name, for example `let`, `map` or `do`, you are likely to run into trouble when some non-shadowed macro inside your
+dsl context expands into something you have shadowed; in this case your shadowy definitions will be used to further expand the result.
+
+For example, if you shadow `with`, but not `let`, and then you use a `let` form within a sample of the dsl you are specifying ; the `let`
+form expands into a `with` form, thinking the `with` will expand in the usual way, but in fact no, your private dsl is going to expand
+this `with` in your private special way, possibly in a way that's incompatible with the form produced by `let`.
+
+If, notwithstanding the aforementioned, the outcome works the way you expected it to, then you have the wrong kind of genius and your
+license to program should be revoked.
+
+
 ## Installation
 
 Add this line to your application's Gemfile:

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

@@ -1,22 +1,27 @@
 
-
-(assign mac-expand (fn (macfn name body)
+(assign mac-expand (fn (names macfn name body)
   (cond macfn
-        (pre-compile (apply macfn body))
+        (pre-compile-with names
+                          (apply macfn body))
         (cons name body))))
 
 (assign macs (hash))
 
 (assign pre-compile-expr
-        (fn (name body)
-            (mac-expand (hash-get macs name) name body)))
+        (fn (names name body)
+            (mac-expand names
+                        (hash-get names name)
+                        name
+                        body)))
 
 (assign pre-compile-each
-        (fn (args)
+        (fn (names args)
             (cond args
                   (cond (pair? args)
-                        (cons (pre-compile (car args))
-                              (pre-compile-each (cdr args)))
+                        (cons (pre-compile-with names
+                                                (car args))
+                              (pre-compile-each names
+                                                (cdr args)))
                         args))))
 
 (assign pre-compile-msg
@@ -25,23 +30,36 @@
             compiled))
 
 (assign pre-compile-raw
-        (fn (arg)
+        (fn (names arg)
             (cond (pair? arg)
                   (cond (eq? (car arg) 'quote)
                         arg
-                        (pre-compile-each (pre-compile-expr (car arg) (cdr arg))))
+                        (pre-compile-each names
+                                          (pre-compile-expr names
+                                                            (car arg)
+                                                            (cdr arg))))
                   arg)))
 
 (assign pre-compile-debug
-        (fn (arg)
-            (pre-compile-msg arg (pre-compile-raw arg))))
+        (fn (names arg)
+            (pre-compile-msg arg
+                             (pre-compile-raw names
+                                              arg))))
 
 (assign debug-pre-compile
         (fn (arg)
-            (assign pre-compile (cond arg pre-compile-debug pre-compile-raw))))
+            (assign pre-compile-with
+                    (cond arg
+                          pre-compile-debug
+                          pre-compile-raw))))
 
 (debug-pre-compile nil)
 
+; builtin pre-compile does nothing; override here to provide macro-expansion
+(assign pre-compile
+        (fn (arg)
+            (pre-compile-with macs arg)))
+
 ; we override this later to provide automatic documentation
 (hash-set macs 'def
           (fn (name args . body)

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

@@ -28,6 +28,8 @@
      (def dox-examples (name)
        (hash-get examples name))
 
+     (def dox-example-names () (hash-keys examples))
+
      (def dox-arg-names (name)
        (cond (dox? name)
              (cadddr (car (dox-lookup name))))))
@@ -81,9 +83,11 @@
              'args
              '`((fn nil ,@args)))
 
+(mac def-assign args `(assign ,@args))
+
 (def define-def-expr (name args documentation body)
   ; used internally by 'def
-  `(do (assign ,name (fn ,args ,@body))
+  `(do (def-assign ,name (fn ,args ,@body))
        (dox-add-doc ',name
                     'def
                     ',documentation

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

@@ -168,12 +168,16 @@
                ,(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)
       (caris 'dot-syntax name)
       (dot-syntax-assignment (cdr name) value)))
 
+(mac def-assign args `(= ,@args))
+
 (def brace-list-hash-key (k)
   (if (isa 'symbol k)      `(quote ,k)
       (caris 'unquote k)   (cadr k)
@@ -199,8 +203,11 @@
       (build-ampersand-syntax (car rest))))
 
 (mac brace-list-mono (arg) arg)
+(mac brace-list-empty () '(hash))
 
 (mac brace-list args
-  (if (no (cdr args))
+  (if (no args)
+      `(brace-list-empty)
+      (no (cdr args))
       `(brace-list-mono ,(car args))
       (brace-list-build-hash args)))

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

@@ -1,3 +1,4 @@
+
 (def eachr (f things)
      (when things
        (eachr f (cdr things))
@@ -78,7 +79,6 @@
               (iso (cdr x) (cdr y)))))
 
 (def x1      (thing)    thing)
-(def isa     (type obj) (eq? (type-of obj) type))
 (def sym?    (arg)      (isa 'symbol arg))
 (def string? (arg)      (isa 'string arg))
 (mac just    (arg)      arg)

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

@@ -51,8 +51,6 @@
 
 (mac examples-for (name . examples)
   (let suite-name "examples for ~(pp name)"
-    `(do
-         (register-test '(suite ,suite-name ,@examples))
-         (dox-add-examples ',name
-                           ',(collect (curry !caris 'comment)
-                                      examples)))))
+    (let plain-examples (collect (fn (x) (isa 'string (car x))) examples)
+      `(do (register-test '(suite ,suite-name ,@plain-examples))
+           (dox-add-examples ',name ',plain-examples)))))

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

@@ -54,6 +54,7 @@
 (pp/def brace-list       (form indent) "{~(pp/inline (cdr form) indent)}")
 
 (pp/syntax
+ percent-syntax "%"
  colon-syntax ":"
  dot-syntax   "."
  bang-syntax  "!"

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

@@ -0,0 +1,31 @@
+(examples-for date
+ ("creates a single date"          (to-string (date 1965 6 8))                                 "1965-06-08" )
+ ("navigates to next day"          (let d (date 2004  3 11) (to-string d.tomorrow))            "2004-03-12" )
+ ("navigates to previous day"      (let d (date 2006  6 22) (to-string d.yesterday))           "2006-06-21" )
+ ("navigates to previous year"     (let d (date 1971 12 18) (to-string d.last-year))           "1970-12-18" )
+ ("navigates to next year"         (let d (date 1974  1 11) (to-string d.next-year))           "1975-01-11" )
+ ("navigates to previous month"    (let d (date 1971 12 18) (to-string d.last-month))          "1971-11-18" )
+ ("navigates to next month"        (let d (date 1974  1 11) (to-string d.next-month))          "1974-02-11" )
+ ("jumps a year to previous month" (let d (date 1974  1 11) (to-string d.last-month))          "1973-12-11" )
+ ("navigates to previous week"     (let d (date 2008  2 16) (to-string d.last-week))           "2008-02-09" )
+ ("navigates to next week"         (let d (date 1972 11 13) (to-string d.next-week))           "1972-11-20" )
+ ("navigates to year start"        (let d (date 1972 11 13) (to-string d.beginning-of-year))   "1972-01-01" )
+ ("navigates to year end"          (let d (date 1972 11 13) (to-string d.end-of-year))         "1972-12-31" )
+ ("navigates to month start"       (let d (date 1971 11 18) (to-string d.beginning-of-month))  "1971-11-01" )
+ ("navigates to month end"         (let d (date 1971 11 18) (to-string d.end-of-month))        "1971-11-30" )
+ ("navigates to week start"        (let d (date 2015 11  6) (to-string d.beginning-of-week))   "2015-11-02" )
+ ("navigates to week end"          (let d (date 2015 11  6) (to-string d.end-of-week))         "2015-11-08" )
+
+ ("returns its year"      (let d (date 1999 12 31) d.year)     1999)
+ ("returns its month"     (let d (date 1999 12 31) d.month)    12  )
+ ("returns its day"       (let d (date 1999 12 31) d.day)      31  )
+ ("returns its week-day"  (let d (date 1999 12 31) d.week-day) 5   )
+ ("recognises not monday" (let d (date 2015 11  1) d.monday?   ) nil )
+ ("recognises monday"     (let d (date 2015 11  2) d.monday?   ) t   )
+ ("recognises tuesday"    (let d (date 2015 11  3) d.tuesday?  ) t   )
+ ("recognises wednesday"  (let d (date 2015 11  4) d.wednesday?) t   )
+ ("recognises thursday"   (let d (date 2015 11  5) d.thursday? ) t   )
+ ("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   ))

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

@@ -0,0 +1,16 @@
+(assign foo (hash))
+(def foo.bar (a b) (* a b))
+(def foo.zeb (a b) (* a (foo.bar a b)))
+
+(examples-for def
+  ("can assign a function to a hash key"
+   (foo.bar 3 4)
+   12)
+
+  ("sets hash keys"
+   (hash-keys foo)
+   (bar zeb))
+
+  ("hash defs are accessible wherever the hash is"
+   (foo.zeb 5 7)
+   175))

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

@@ -4,6 +4,14 @@
    2.5))
 
 (examples-for eq?
+  ("is nil for two different dates"
+   (eq? (today) (+ (today) 1))
+   nil)
+
+  ("is true for two identical dates"
+   (eq? (date 2015 3 12) (+ (date 2015 3 1) 11))
+   t)
+
   ("true for two empty symbols"
    (eq? '|| '||)
    t)

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

@@ -19,6 +19,11 @@
    nil))
 
 (examples-for brace-list
+  ("with no args builds an empty hash"
+   (let thing {}
+     (list (type-of thing) (hash-keys thing)))
+   (hash nil))
+
   ("build a hash table from brace-list syntax"
    (let hsh { foo 1 bar 2 }
      (list 'foo hsh.foo 'bar hsh.bar))

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

@@ -20,6 +20,10 @@
    (parse "%this-and-that")
    ((percent-syntax || this-and-that)) )
 
+  ("parses a percent-prefix-mixed-with-dot-syntax symbol"
+   (parse "%this.and.that")
+   ((percent-syntax || (dot-syntax this and that))) )
+
   ("parses a dot-syntax symbol"
    (parse "this.that.zozo")
    ((dot-syntax this that zozo)) )

data/lib/lisp/tests/pre-compile-examples.nydp

@@ -0,0 +1,19 @@
+(examples-for pre-compile-with
+  ("does nothing with an empty hash"
+   (pre-compile-with (hash) '(let a 1 (p a)))
+   (let a 1 (p a)))
+
+  ("uses the given macros to expand the given expression"
+   (let lang { p          (fn args `(print-stuff ,@args))
+               def        (fn (name . body) `(define-it ,(to-string name) ,(len body) ,@body))
+               brace-list (fn (first second third) `(brace-things ,first (p ,second))) }
+     (pre-compile-with lang
+                       '(let a 'b
+                          (p { a b c }
+                             (with (m n)
+                                   (def p q r s tt))))))
+   (let a 'b
+     (print-stuff (brace-things a
+                                (print-stuff b))
+                  (with (m n)
+                        (define-it "p" 4 q r s tt))))))

data/lib/lisp/tests/pretty-print-tests.nydp

@@ -25,6 +25,10 @@
    (pp '(string-pieces "hello " (bang-syntax || (dot-syntax x y (ampersand-syntax foo bar))) " and welcome to " (prefix-list "%%" (a b c d)) " and friends!"))
    "\"hello ~~!x.y.foo&bar and welcome to ~~%%(a b c d) and friends!\"")
 
+  ("perent-syntax"
+   (pp '(percent-syntax || (dot-syntax x y)))
+   "%x.y")
+
   ("brace list"
    (pp '(&x {a 1 b "two" c 'three d ,four e (sub invocation) f {sub brace list} }))
    "(&x {a 1 b \"two\" c 'three d ,four e (sub invocation) f {sub brace list}})"))

data/lib/nydp/date.rb

@@ -8,8 +8,12 @@ module Nydp
 
     MONTH_SIZES = [nil, 31, 28, 31, 30, 31, 30, 31, 31, 30, 31, 30, 31]
     def build y, m, d
-      s = MONTH_SIZES[m]
-      ::Date.new(y, m, (d > s ? s : d))
+      if m < 1
+        build( y - 1, m + 12, d )
+      else
+        s = MONTH_SIZES[m]
+        ::Date.new(y, m, (d > s ? s : d))
+      end
     end
 
     def initialize ruby_date
@@ -24,14 +28,16 @@ module Nydp
     def + int     ; r2n(ruby_date + int            , nil) ; end
     def > other   ; ruby_date > other.ruby_date           ; end
     def < other   ; ruby_date < other.ruby_date           ; end
+    def == other  ; ruby_date == other.ruby_date          ; end
 
+    @@pass_through = %i{ monday? tuesday? wednesday? thursday? friday? saturday? sunday? }
     @@keys = Set.new %i{
       year       month      week_day           day
       last_year  next_year  beginning_of_year  end_of_year
       last_month next_month beginning_of_month end_of_month
       last_week  next_week  beginning_of_week  end_of_week
       yesterday  tomorrow
-    }
+    } + @@pass_through
 
     def year               y, m, d, w ; y ; end
     def month              y, m, d, w ; m ; end
@@ -56,6 +62,12 @@ module Nydp
     def yesterday          y, m, d, w ; ruby_date - 1                ; end
     def tomorrow           y, m, d, w ; ruby_date + 1                ; end
 
+    @@pass_through.each do |n|
+      class_eval "def #{n} * ; ruby_date.#{n} ; end"
+    end
+
+    def dispatch key, y, m, d, w ; self.send(key, y, m, d, w) if @@keys.include?(key) ; end
+
     def [] key
       key = key.to_s.gsub(/-/, '_').to_sym
       y = ruby_date.year
@@ -63,8 +75,7 @@ module Nydp
       d = ruby_date.day
       w = ruby_date.wday
 
-      adjusted = self.send(key, y, m, d, w) if @@keys.include?(key)
-      r2n adjusted, nil
+      r2n(dispatch(key, y, m, d, w), nil)
     end
   end
 end

data/lib/nydp/version.rb

@@ -1,3 +1,3 @@
 module Nydp
-  VERSION = "0.1.4"
+  VERSION = "0.1.5"
 end

metadata

@@ -1,14 +1,14 @@
 --- !ruby/object:Gem::Specification
 name: nydp
 version: !ruby/object:Gem::Version
-  version: 0.1.4
+  version: 0.1.5
 platform: ruby
 authors:
 - Conan Dalton
 autorequire: 
 bindir: bin
 cert_chain: []
-date: 2015-11-05 00:00:00.000000000 Z
+date: 2015-11-08 00:00:00.000000000 Z
 dependencies:
 - !ruby/object:Gem::Dependency
   name: bundler
@@ -101,6 +101,8 @@ files:
 - lib/lisp/tests/collect-tests.nydp
 - lib/lisp/tests/cons-examples.nydp
 - lib/lisp/tests/curry-tests.nydp
+- lib/lisp/tests/date-examples.nydp
+- lib/lisp/tests/def-examples.nydp
 - lib/lisp/tests/detect-examples.nydp
 - lib/lisp/tests/dot-syntax-examples.nydp
 - lib/lisp/tests/dox-tests.nydp
@@ -115,6 +117,7 @@ files:
 - lib/lisp/tests/len-examples.nydp
 - lib/lisp/tests/list-tests.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