nydp 0.0.8 → 0.0.9

checksums.yaml

@@ -1,7 +1,7 @@
 ---
 SHA1:
-  metadata.gz: c5371b4420aa7a746eccbe2b573c4272d7dfba14
-  data.tar.gz: a3984911b5b429111b2d05edfb0dbe8e7255f09b
+  metadata.gz: 815a0a959a0678c7fc8a7e4ad5cd50fa0a5aa0fb
+  data.tar.gz: 23c872b0c3126bfc18c9859e617ba645751e38ad
 SHA512:
-  metadata.gz: 2f34a901a9f99c8225bbe8b4301d7399e6cde7b54f10d8d46d22763309271ab8baaea9829de021ab0d35eaaf949a45ff805795b29ad6ea5d44595f4f4fea4ff5
-  data.tar.gz: 00f4189ec6bbeeb721b3431a59bb6bc819f239eaecd499f49ba38b49f42d29ffc8609b3cd370eb976a6897cccc4442c97b94457eed6cede53cf72db09fe85f54
+  metadata.gz: 2980ea82cc715d36febeaa27a008fef8e2eb507caad76a030ba46b52ddcb690b311c6313018c589790d9d49db3497fd0c044b2fe3ca284024dadd237fe5e5594
+  data.tar.gz: 3ba9d1749f05d877749af1ec35ee0a2cbdb8fa0ba818c194a8d0f3d773c674d1ea85b185a7eeea24e923781328ed4a61bcb03f38540088393d8dd9b9f9129b9c

data/lib/lisp/boot.nydp

@@ -19,6 +19,7 @@
 (assign last  (fn (arg) (car (last-cons arg))))
 (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   no  (fn (arg) (cond arg nil t)))
 (assign just  (fn (arg) arg))
@@ -150,13 +151,24 @@
                        `(cond ,(car args) ,(cadr args)))
                  (car args))))
 
+(def expand-colon-syntax (first rest)
+     (if (no rest)
+         `(apply ,first args)
+         `(,first ,(expand-colon-syntax (car rest) (cdr rest)))))
+
+(mac colon-syntax args
+  (if (eq? (car args) '||)
+      (error "Irregular ': syntax: got ~(inspect args) : not prefix-syntax : in ~(joinstr ":" (cons pfx rest))")
+      `(fn args ,(expand-colon-syntax (car args) (cdr args)))))
+
 (mac bang-syntax (pfx . rest)
   (if (no (eq? pfx '||))
-      (error "Irregular ! syntax: got prefix ~(inspect pfx) in ~(joinstr "!" (cons pfx rest))"))
+      (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))"))
-  `(fn args
-     (no (apply ,(car rest) args))))
+      (error "Irregular '! syntax: got suffix ~(inspect (cdr rest)) in ~(joinstr "!" (cons pfx rest))")
+      (if (caris 'colon-syntax (car rest))
+          `(colon-syntax no ,@(cdar rest))
+          `(colon-syntax no ,(car rest)))))
 
 (mac and args
   (if args
@@ -311,13 +323,20 @@
                              ,result))))
            (def ,name () (hash-get (thread-locals) ',name))))))
 
+(def build-hash-get-key (name)
+  (if (pair? name)
+      (if (caris 'unquote name)
+          (cadr name)
+          name)
+      (list 'quote name)))
+
 ;; (build-hash-getters '(a b c))
 ;; => (hash-get (hash-get a 'b) 'c)
 (def build-hash-getters (names acc)
   (if (no acc)
       (build-hash-getters (cdr names) (car names))
       names
-      (build-hash-getters (cdr names) `(hash-get ,acc ',(car names)))
+      (build-hash-getters (cdr names) `(hash-get ,acc ,(build-hash-get-key (car names))))
       acc))
 
 (def build-hash-lookup-from (root names)
@@ -327,6 +346,7 @@
   (build-hash-getters names nil))
 
 (mac dot-syntax names `(hash-lookup ,names))
+(mac dollar-syntax (_ name) `(,name))
 
 (def dot-syntax-assignment (names value-expr)
   (let rnames (rev names)
@@ -352,6 +372,18 @@
             ,@(map (fn (m) `(hash-set ,hash ,(brace-list-hash-key (car m)) ,(cadr m))) mappings)
             ,hash))))
 
+(def build-ampersand-syntax (arg)
+  (if (caris 'dot-syntax arg)
+      `(fn (obj) ,(build-hash-lookup-from 'obj (cdr arg)))
+      `(fn (obj) ,(build-hash-lookup-from 'obj (list arg)))))
+
+(mac ampersand-syntax (pfx . rest)
+  (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 args
@@ -387,3 +419,6 @@
     `(with (,v nil ,gi ,init ,gm (+ ,max 1))
        (loop (assign ,v ,gi) (< ,v ,gm) (assign ,v (+ ,v 1))
          ,@body))))
+
+(mac mapx (things x expr)
+  `(map (fn (,x) ,expr) ,things))

data/lib/lisp/test-runner.nydp

@@ -30,7 +30,7 @@
             (passf)
             (do (p desc " - " (car test) " - FAILED:
    expected " (inspect expected) ",
-   got " (inspect result) "
+   got      " (inspect result) "
 ")
                 (failf)))))
 

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

@@ -108,6 +108,11 @@
                  (test-foo "x" "y")
                  ("a0 w0 x w0 y" "a0 w1 x w1 y" "a0 w2 x w2 y" "a0 w3 x w3 y"))
 
+                (suite "mapx"
+                  ("provides a convenient simplification for 'map"
+                    (mapx '(1 2 3 4) n (* n 2))
+                    (2 4 6 8)))
+
          (suite "pre-compile"
                 (suite "bang-syntax"
                        ("expansion"
@@ -126,6 +131,29 @@
                         (!caris 'foo '(zozo foo bar))
                         t))
 
+                (suite "ampersand-syntax"
+                       ("defines a hash-lookup function"
+                        (pre-compile '&first)
+                        (fn (obj) (hash-get obj (quote first))))
+
+                       ("defines a hash-lookup function with a dot-syntax arg"
+                        (pre-compile '&teacher.address.city)
+                        (fn (obj) (hash-get (hash-get (hash-get obj (quote teacher)) (quote address)) (quote city))) ))
+
+                (suite "colon-syntax"
+                       ("used for composition"
+                        (pre-compile '(no:eq? a b))
+                        ((fn args (no (apply eq? args))) a b))
+
+                       ("used for composition"
+                        (pre-compile '(x:y a b))
+                        ((fn args (x (apply y args))) a b)))
+
+                (suite "bang-colon syntax"
+                       ("special combination with bang"
+                        (pre-compile '(!x:y a b))
+                        ((fn args (no (x (apply y args)))) a b)))
+
                 ("expands 'let"
                  (do
                      (def x+3*z (x y)
@@ -184,7 +212,7 @@
                         `((a ,(+ 1 2) b)))
                        ("returns nested quasiquotes"
                         `(a b `(c d ,(+ 1 2) ,,(+ 3 4)))
-                        (a b `(c d ,(+ 1 2) ,7)))))
+                        (a b `(c d ,(+ 1 2) ,7))))
 
          (suite "build-keyword-args"
                 ("takes a list of lists and returns the list with the first item of each sublist quoted"

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

@@ -20,12 +20,20 @@
         (type-of "foobar")
         string)
 
+      ("returns 'number for an integer"
+        (type-of 42)
+        number)
+
+      ("returns 'number for a float"
+        (type-of 4.2)
+        number)
+
       ("interpolates a string"
         "foobar ~(+ 1 2) you know"
         "foobar 3 you know")
 
       ("returns 'string for an interpolated string"
-        (type-of "foobar %%(+ 1 2)")
+        (type-of "foobar ~(+ 1 2)")
         string)))
 
   (suite "eq?"
@@ -64,13 +72,37 @@
      (pre-compile 'a.b.c)
      (hash-get (hash-get a 'b) 'c))
 
+    ("hash-lookup with dollar-syntax for function call"
+     (pre-compile '$a.b.c)
+     (hash-get (hash-get (a) 'b) 'c))
+
+    ("hash-lookup with embedded dollar-syntax for function call"
+     (pre-compile 'a.$b.c)
+     (hash-get (hash-get a (b)) 'c))
+
+    ("hash-lookup with embedded unquote"
+     (pre-compile 'a.,b.c)
+     (hash-get (hash-get a b) 'c))
+
     ("hash assignment"
      (pre-compile '(= a.b 42))
      (hash-set a 'b 42))
 
     ("recursive hash assignment"
      (pre-compile '(= a.b.c.d 42))
-     (hash-set (hash-get (hash-get a 'b) 'c) 'd 42)))
+     (hash-set (hash-get (hash-get a 'b) 'c) 'd 42))
+
+    ("recursive hash assignment with embedded unquote"
+     (pre-compile '(= a.b.,c.d 42))
+     (hash-set (hash-get (hash-get a 'b) c) 'd 42))
+
+    ("recursive hash assignment with prefix dollar-syntax"
+     (pre-compile '(= $a.b.,c.d 42))
+     (hash-set (hash-get (hash-get (a) 'b) c) 'd 42))
+
+    ("recursive hash assignment with embedded dollar-syntax"
+     (pre-compile '(= a.$b.,c.d 42))
+     (hash-set (hash-get (hash-get a (b)) c) 'd 42)))
 
   (suite "isa"
     ("t for 'pair for list"

data/lib/nydp.rb

@@ -49,6 +49,7 @@ module Nydp
 end
 
 require "nydp/core"
+require "nydp/date"
 require "nydp/runner"
 require "nydp/error"
 require "nydp/truth"

data/lib/nydp/builtin/car.rb

@@ -2,4 +2,7 @@ class Nydp::Builtin::Car
   def invoke vm, args
     vm.push_arg args.car.car
   end
+
+  def to_s; "car"; end
+  def inspect; "builtin:car"; end
 end

data/lib/nydp/builtin/cdr.rb

@@ -2,4 +2,7 @@ class Nydp::Builtin::Cdr
   def invoke vm, args
     vm.push_arg args.car.cdr
   end
+
+  def to_s; "cdr"; end
+  def inspect; "builtin:cdr"; end
 end

data/lib/nydp/builtin/today.rb

@@ -0,0 +1,7 @@
+class Nydp::Builtin::Today
+  include Nydp::Helper
+
+  def invoke vm, args
+    vm.push_arg(Nydp::Date.new Date.today)
+  end
+end

data/lib/nydp/builtin/type_of.rb

@@ -5,7 +5,16 @@ class Nydp::Builtin::TypeOf
 
   def invoke vm, args
     arg = args.car
-    type = Nydp::Symbol.mk(arg.nydp_type.to_sym, @ns) if arg.respond_to?(:nydp_type)
+    typename = if arg.respond_to?(:nydp_type)
+                 arg.nydp_type.to_sym
+               elsif arg.is_a? Numeric
+                 :number
+               else
+                 "ruby/#{arg.class.name}".to_sym
+               end
+
+    type = Nydp::Symbol.mk(typename, @ns)
+
     vm.push_arg(type || Nydp.NIL)
   end
 end

data/lib/nydp/date.rb

@@ -0,0 +1,65 @@
+require 'nydp/helper'
+
+module Nydp
+  class Date
+    include Nydp::Helper
+
+    attr_accessor :ruby_date
+
+    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))
+    end
+
+    def initialize ruby_date
+      @ruby_date = ruby_date
+    end
+
+    def to_s      ; ruby_date.to_s    ; end
+    def inspect   ; ruby_date.inspect ; end
+    def nydp_type ; :date             ; end
+
+    @@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
+    }
+
+    def year               y, m, d, w ; y ; end
+    def month              y, m, d, w ; m ; end
+    def day                y, m, d, w ; d ; end
+    def week_day           y, m, d, w ; w ; end
+
+    def last_year          y, m, d, w ; build(y - 1, m, d)           ; end
+    def next_year          y, m, d, w ; ruby_date.next_year          ; end
+    def beginning_of_year  y, m, d, w ; build(y, 1, 1)               ; end
+    def end_of_year        y, m, d, w ; build(y, 12, 31)             ; end
+
+    def last_month         y, m, d, w ; build(y, m - 1, d)           ; end
+    def next_month         y, m, d, w ; ruby_date.next_month         ; end
+    def beginning_of_month y, m, d, w ; build(y, m, 1)               ; end
+    def end_of_month       y, m, d, w ; build(y, m, 31)              ; end
+
+    def last_week          y, m, d, w ; ruby_date - 7                ; end
+    def next_week          y, m, d, w ; ruby_date + 7                ; end
+    def beginning_of_week  y, m, d, w ; ruby_date + 1 - w            ; end
+    def end_of_week        y, m, d, w ; ruby_date + 7 - w            ; end
+
+    def yesterday          y, m, d, w ; ruby_date - 1                ; end
+    def tomorrow           y, m, d, w ; ruby_date + 1                ; end
+
+    def [] key
+      key = key.to_s.gsub(/-/, '_').to_sym
+      y = ruby_date.year
+      m = ruby_date.month
+      d = ruby_date.day
+      w = ruby_date.wday
+
+      adjusted = self.send(key, y, m, d, w) if @@keys.include?(key)
+      r2n adjusted, nil
+    end
+  end
+end

data/lib/nydp/hash.rb

@@ -1,2 +1,16 @@
 class Nydp::Hash < ::Hash
+  include Nydp::Helper
+
+  def to_ruby
+    @_ruby_hash ||= Hash.new { |h, k|
+      self[case k
+           when String
+             Nydp::StringAtom.new(k)
+           when Symbol
+             Nydp::Symbol.new(k)
+           else
+             k
+           end]
+    }
+  end
 end

data/lib/nydp/helper.rb

@@ -3,9 +3,10 @@ module Nydp
     ::Symbol   => ->(obj, ns) { Nydp::Symbol.mk(obj, ns)                            },
     Array      => ->(obj, ns) { Nydp::Pair.from_list obj.map { |o| Nydp.r2n o, ns } },
     String     => ->(obj, ns) { Nydp::StringAtom.new obj.to_s                       },
-    NilClass   => ->(obj, ns) { Nydp::Nil                                           },
-    FalseClass => ->(obj, ns) { Nydp::Nil                                           },
-    TrueClass  => ->(obj, ns) { Nydp::T                                             },
+    NilClass   => ->(obj, ns) { Nydp.NIL                                            },
+    FalseClass => ->(obj, ns) { Nydp.NIL                                            },
+    TrueClass  => ->(obj, ns) { Nydp.T                                              },
+    ::Date     => ->(obj, ns) { Nydp::Date.new obj                                  },
   }
 
   def self.n2r nydp
@@ -13,7 +14,7 @@ module Nydp
   end
 
   def self.r2n ruby_obj, ns
-    return ruby_obj._nydp_wrapper if ruby_obj.respond_to? :_nydp_wrapper
+    return ruby_obj._nydp_wrapper(ns) if ruby_obj.respond_to? :_nydp_wrapper
 
     rklass = ruby_obj.class
     R2NHELPERS.each do |hklass, proc|

data/lib/nydp/parser.rb

@@ -42,6 +42,7 @@ module Nydp
     SYMBOL_OPERATORS =
       [
         [ /\!/,     "bang-syntax"       ],
+        [ /&/,      "ampersand-syntax"  ],
         [ /\./,     "dot-syntax"        ],
         [ /\$/,     "dollar-syntax"     ],
         [ /::/,     "colon-colon-syntax"],

data/lib/nydp/string_atom.rb

@@ -8,6 +8,7 @@ module Nydp
     def nydp_type  ; :string        ; end
     def to_s       ;  string        ; end
     def to_ruby    ;  string        ; end
+    def to_sym     ;  string.to_sym ; end
     def eql? other ; self == other  ; end
     def inspect    ; string.inspect ; end
     def hash       ; string.hash    ; end

data/lib/nydp/symbol.rb

@@ -38,10 +38,13 @@ class Nydp::Symbol
     ns[name.to_sym]
   end
 
-  def nydp_type ; :symbol     ; end
-  def inspect   ; @inspection ; end
-  def to_s      ; name.to_s   ; end
-  def to_ruby   ; name        ; end
+  def nydp_type  ; :symbol        ; end
+  def inspect    ; @inspection    ; end
+  def to_s       ; name.to_s      ; end
+  def to_sym     ; name           ; end
+  def to_ruby    ; to_sym         ; end
+  def hash       ; name.hash      ; end
+  def eql? other ; self == other  ; end
 
   def == other
     other.is_a?(Nydp::Symbol) && (self.name == other.name)

data/lib/nydp/truth.rb

@@ -4,6 +4,7 @@ module Nydp
     def inspect   ; 't[nydp::Truth]' ; end
     def assign *_ ; self             ; end
     def nydp_type ; :truth           ; end
+    def to_ruby   ; true             ; end
   end
 
   class Nil
@@ -18,6 +19,7 @@ module Nydp
     def assign *_   ; self          ; end
     def inspect     ; "nil"         ; end
     def nydp_type   ; :nil          ; end
+    def to_ruby     ; nil           ; end
 
     def execute vm
       vm.push_arg self
@@ -34,6 +36,7 @@ module Nydp
   class Nil
     def self.new ; raise "no" ; end
   end
+
   def self.NIL; @@nil; end
   def self.T;   @@t;   end
 end

data/lib/nydp/version.rb

@@ -1,3 +1,3 @@
 module Nydp
-  VERSION = "0.0.8"
+  VERSION = "0.0.9"
 end

data/spec/date_spec.rb

@@ -0,0 +1,54 @@
+require 'spec_helper'
+
+describe Nydp::Date do
+
+  let(:ns) { { } }
+
+  it "converts ruby Date to Nydp::Date" do
+    rd = Date.parse "2015-06-08"
+    nd = Nydp.r2n rd, ns
+
+    expect(nd).        to be_a Nydp::Date
+    expect(nd.to_s).   to eq "2015-06-08"
+    expect(nd.inspect).to eq "#<Date: 2015-06-08 ((2457182j,0s,0n),+0s,2299161j)>"
+  end
+
+  it "returns date components" do
+    rd = Date.parse "2015-06-08"
+    nd = Nydp.r2n rd, ns
+
+    expect(nd[:year]). to eq 2015
+    expect(nd[:month]).to eq 6
+    expect(nd[:day]).  to eq 8
+  end
+
+  it "returns relative dates by year" do
+    rd = Date.parse "2015-06-08"
+    nd = Nydp.r2n rd, ns
+
+    expect(nd[:"last-year"].to_s).          to eq "2014-06-08"
+    expect(nd[:"next-year"].to_s).          to eq "2016-06-08"
+    expect(nd[:"beginning-of-year"].to_s).  to eq "2015-01-01"
+    expect(nd[:"end-of-year"].to_s).        to eq "2015-12-31"
+  end
+
+  it "returns relative dates by month" do
+    rd = Date.parse "2015-06-08"
+    nd = Nydp.r2n rd, ns
+
+    expect(nd[:"last-month"].to_s).          to eq "2015-05-08"
+    expect(nd[:"next-month"].to_s).          to eq "2015-07-08"
+    expect(nd[:"beginning-of-month"].to_s).  to eq "2015-06-01"
+    expect(nd[:"end-of-month"].to_s).        to eq "2015-06-30"
+  end
+
+  it "returns relative dates by week" do
+    rd = Date.parse "2015-03-12"
+    nd = Nydp.r2n rd, ns
+
+    expect(nd[:"last-week"].to_s).          to eq "2015-03-05"
+    expect(nd[:"next-week"].to_s).          to eq "2015-03-19"
+    expect(nd[:"beginning-of-week"].to_s).  to eq "2015-03-09"
+    expect(nd[:"end-of-week"].to_s).        to eq "2015-03-15"
+  end
+end

data/spec/hash_spec.rb

@@ -4,6 +4,32 @@ describe Nydp::Hash do
 
   let(:vm) { Nydp::VM.new }
 
+  describe "#to_ruby" do
+    it "converts ruby symbol key to nydp symbol key" do
+      hash = Nydp::Hash.new
+      hash[sym "boo"] = 42
+
+      rhash = hash.to_ruby
+      expect(rhash[:boo]).to eq 42
+    end
+
+    it "converts ruby string key to nydp string key" do
+      hash = Nydp::Hash.new
+      hash[Nydp::StringAtom.new "boo"] = 42
+
+      rhash = hash.to_ruby
+      expect(rhash["boo"]).to eq 42
+    end
+
+    it "uses integer keys unconverted" do
+      hash = Nydp::Hash.new
+      hash[21] = 42
+
+      rhash = hash.to_ruby
+      expect(rhash[21]).to eq 42
+    end
+  end
+
   describe "nydp hashes" do
     describe "new hash" do
       it "returns a new Nydp hash" do
@@ -81,6 +107,25 @@ describe Nydp::Hash do
 
         expect(vm.pop_arg).to eq Nydp::StringAtom.new("avalue")
       end
+
+      it "converts ruby nil to nydp value" do
+        k              = sym("keysym")
+        args           = [ ahash, k ]
+
+        Nydp::Builtin::HashGet.new(ns).invoke vm, pair_list(args)
+
+        expect(vm.pop_arg).to eq Nydp.NIL
+      end
+
+      it "converts ruby true to nydp value" do
+        ahash[:keysym] = true
+        k              = sym("keysym")
+        args           = [ ahash, k ]
+
+        Nydp::Builtin::HashGet.new(ns).invoke vm, pair_list(args)
+
+        expect(vm.pop_arg).to eq Nydp.T
+      end
     end
 
     describe "hash keys" do

data/spec/literal_spec.rb

@@ -6,4 +6,16 @@ describe Nydp::Literal do
     lit = Nydp::Literal.new sym
     expect(lit.to_ruby).to eq :foo
   end
+
+  describe "t" do
+    it "is #true in ruby" do
+      expect(Nydp.T.to_ruby).to eq true
+    end
+  end
+
+  describe "nil" do
+    it "is #nil in ruby" do
+      expect(Nydp.NIL.to_ruby).to eq nil
+    end
+  end
 end

data/spec/symbol_spec.rb

@@ -31,7 +31,10 @@ describe Nydp::Symbol do
     sym1 = Nydp::Symbol.mk :baz, ns1
     sym2 = Nydp::Symbol.mk :baz, ns2
 
-    expect(sym1).to eq sym2
-    expect(sym1).not_to equal sym2
+    expect(sym1.hash).to eq sym2.hash
+
+    expect(sym1 ==     sym2).to eq true
+    expect(sym1.eql?   sym2).to eq true
+    expect(sym1.equal? sym2).to eq false
   end
 end

metadata

@@ -1,14 +1,14 @@
 --- !ruby/object:Gem::Specification
 name: nydp
 version: !ruby/object:Gem::Version
-  version: 0.0.8
+  version: 0.0.9
 platform: ruby
 authors:
 - Conan Dalton
 autorequire: 
 bindir: bin
 cert_chain: []
-date: 2015-07-08 00:00:00.000000000 Z
+date: 2015-07-23 00:00:00.000000000 Z
 dependencies:
 - !ruby/object:Gem::Dependency
   name: bundler
@@ -128,6 +128,7 @@ files:
 - lib/nydp/builtin/times.rb
 - lib/nydp/builtin/to_string.rb
 - lib/nydp/builtin/to_sym.rb
+- lib/nydp/builtin/today.rb
 - lib/nydp/builtin/type_of.rb
 - lib/nydp/builtin/vm_info.rb
 - lib/nydp/closure.rb
@@ -135,6 +136,7 @@ files:
 - lib/nydp/cond.rb
 - lib/nydp/context_symbol.rb
 - lib/nydp/core.rb
+- lib/nydp/date.rb
 - lib/nydp/error.rb
 - lib/nydp/function_invocation.rb
 - lib/nydp/hash.rb
@@ -156,6 +158,7 @@ files:
 - lib/nydp/vm.rb
 - lib/tasks/tests.rake
 - nydp.gemspec
+- spec/date_spec.rb
 - spec/embedded_spec.rb
 - spec/hash_spec.rb
 - spec/literal_spec.rb
@@ -192,6 +195,7 @@ signing_key:
 specification_version: 4
 summary: A civilised yet somewhat dangerous kind of Lisp for a new generation
 test_files:
+- spec/date_spec.rb
 - spec/embedded_spec.rb
 - spec/hash_spec.rb
 - spec/literal_spec.rb