nydp 0.1.8 → 0.1.9

checksums.yaml

@@ -1,7 +1,7 @@
 ---
 SHA1:
-  metadata.gz: 464c1f232ccc2d83cad5b5141745c64b46f44456
-  data.tar.gz: 6197cc9ee681187c2bd2ace20395f1c2a414df1f
+  metadata.gz: 2a04241f46cc86cfb401435e98feac3315b758bb
+  data.tar.gz: a2885ed15e20a545b3c73ada1cfe815f74fa163e
 SHA512:
-  metadata.gz: 9b1e87a79e8531565cedd6f9eaebd3bf1af59782ea383e3426ee054ae9c2c819881dde4123620f683690cbbbef164b1477df93a323de8dac817d39355aaeccf7
-  data.tar.gz: 9d9a93990ebcd01d4305ef2458b02acfbf338263f3ee5ba4ab0f223f1115db845cc91220e410cf1bbb535a84c59f3eea66e8f8856e04d0919d9afb4ada53893a
+  metadata.gz: 0cb48a423ba6e63f894eb6731cde8c1006e142288f0c25b14be25a3b7877d5736fa4d94142d5fd9f53002c2ca76ab4e19a72b89b06b411afd06d565b5315a016
+  data.tar.gz: 3c0e631c2c920c73f00feaf98237e4548907c441097cabd037db3849cf4570b6d2969c15ead3c5408d3cdd0be6759d8bb4b656319196fa0ac841b1d0636b4e51

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

@@ -0,0 +1,9 @@
+(dox-add-doc 'cons  'def '("with args a and b, returns a new cons cell, (a . b)") '(a b) nil)
+(dox-add-doc 'car   'def '("with args a, where a is a cons cell (x . y), return x." "Commonly used to get the first element of a list") '(a) nil)
+(dox-add-doc 'cdr   'def '("with args a, where a is a cons cell (x . y), return y." "Commonly used to get contents of a list, excluding the first element") '(a) nil)
+(dox-add-doc '+     'def '("with rest-args things, return the sum of the elements of things." "Will also increment dates and concatenate strings and lists") 'things nil)
+(dox-add-doc '-     'def '("return the result of subtracting all other args from the first arg." "(- a b c d) is equivalent to (- a (+ b c d))") 'things nil)
+(dox-add-doc '*     'def '("with rest-args things, return the product of the elements of things.")    'things nil)
+(dox-add-doc '/     'def '("return the result of dividing all other args into the first arg." "(/ a b c d) is equivalent to (/ a (* b c d))") 'things nil)
+(dox-add-doc '>     'def '("true if each arg is greater than the next arg")                           'things nil)
+(dox-add-doc '<     'def '("true if each arg is less than the next arg")                              'things nil)

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

@@ -276,4 +276,6 @@
 (def min things (best < things))
 (def max things (best > things))
 
-(def hash-cons (h k v)  (= h.,k (cons v h.,k)))
+(def hash-cons (h k v)
+  ; push 'v onto the value for 'k in 'h
+  (= h.,k (cons v h.,k)))

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

@@ -17,11 +17,19 @@
 
 (def pp/string-pieces (things) "\"~(joinstr "" (map pp/string-piece things))\"")
 
+(def pp/kv (hsh)
+  (map λk(joinstr " "
+                  (pp k)
+                  (pp hsh.,k))
+       (hash-keys hsh)))
+
 (def pp/literal (thing)
   (if (eq? thing '||)
       ""
       (isa 'string thing)
       "\"~(pp/escape-string-literal thing)\""
+      (isa 'hash thing)
+      "{ ~(joinstr " " (pp/kv thing)) }"
       (inspect thing)))
 
 (mac pp/def (name args . body)

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

@@ -2,3 +2,15 @@
   ; alias for 'detect
   ; true if thing is in things, nil otherwise
   (detect thing things))
+
+(def sort-by (f things)
+  ; sort 'things according to the value
+  ; returned by 'f for each thing in 'things
+  (let tmp (hash)
+    (each thing things
+          (hash-cons tmp
+                    (f thing)
+                    thing))
+    (apply joinlists
+           (map λx(hash-get tmp x)
+                (sort:hash-keys tmp)))))

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

@@ -3,7 +3,23 @@
    (best < '(3 5 4 7 8 2))
    2)
 
-  ("finds maximum of list"
+  ("finds minimum of list of syms"
+   (best < '(c g d o p b m e g z m))
+   b)
+
+  ("finds minimum of list of strings"
+   (best < '("c" "g" "d" "o" "p" "b" "z" "m"))
+   "b")
+
+  ("finds maximum of list of strings"
+   (best > '("c" "g" "d" "o" "p" "b" "y" "m"))
+   "y")
+
+  ("finds maximum of list of syms"
+   (best > '(c g d o a p b m e g a z m))
+   z)
+
+  ("finds maximum of list of numbers"
    (best > '(3 5 4 7 8 2))
    8))
 

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

@@ -0,0 +1,28 @@
+(examples-for sort
+  ("sorts a list of numbers"
+   (sort '(3 5 4 7 8 2))
+   (2 3 4 5 7 8))
+
+  ("sorts a list of syms"
+   (sort '(c g d o a p b m e g a z m))
+   (a a b c d e g g m m o p z))
+
+  ("sorts a list of strings"
+   (sort '("c" "g" "d" "o" "a" "p" "b" "m" "e" "g" "a" "z" "m"))
+   ("a" "a" "b" "c" "d" "e" "g" "g" "m" "m" "o" "p" "z")))
+
+(examples-for sort-by
+  ("sorts a list of hashes by a specified key"
+   (let hh (list { a 1 b 2 } { a 7 b 9 } { a 3 b 1 } { a 2 b 8 })
+     (pp (sort-by &a hh)))
+   "({ a 1 b 2 } { a 2 b 8 } { a 3 b 1 } { a 7 b 9 })")
+
+  ("sorts a list of strings according to their length"
+   (sort-by len
+            '("short" "very very very long" "somewhat long" "more medium" "min" "medium"))
+   ("min" "short" "medium" "more medium" "somewhat long" "very very very long"))
+
+  ("sort a list of strings according to their length even when some strings have the same length"
+   (sort-by len
+            '("short" "very long" "sport" "very song" "min" "max"))
+   ("max" "min" "sport" "short" "very song" "very long")))

data/lib/nydp/builtin/sort.rb

@@ -0,0 +1,15 @@
+module Nydp
+  class Builtin::Sort
+    include Builtin::Base
+
+    def builtin_invoke vm, args
+      vm.push_arg Pair.from_list to_array(args.car, []).sort
+    end
+
+    private
+
+    def to_array pair, list
+      pair.is_a?(Pair) ? to_array(pair.cdr, (list << pair.car)) : list
+    end
+  end
+end

data/lib/nydp/core.rb

@@ -40,6 +40,7 @@ module Nydp
       Symbol.mk(:p,     ns).assign(Nydp::Builtin::Puts.new)
       Symbol.mk(:PI,    ns).assign Literal.new(3.1415)
       Symbol.mk(:nil,   ns).assign Nydp.NIL
+      Symbol.mk(:sort,  ns).assign Nydp::Builtin::Sort.new
       Symbol.mk(:sqrt,  ns).assign Nydp::Builtin::Sqrt.new
       Symbol.mk(:t,     ns).assign Nydp.T
       Symbol.mk(:sym,   ns).assign Nydp::Builtin::Sym.new(ns)

data/lib/nydp/string_atom.rb

@@ -13,9 +13,15 @@ module Nydp
     def inspect    ; string.inspect ; end
     def hash       ; string.hash    ; end
     def length     ; string.length  ; end
+    def > other    ; self.string > other.string ; end
+    def < other    ; self.string < other.string ; end
+
+    def <=> other
+      self < other ? -1 : (self == other ? 0 : 1)
+    end
 
     def == other
-      other.to_s == self.to_s
+      other.is_a?(Nydp::StringAtom) && (other.to_s == self.to_s)
     end
 
     def + other

data/lib/nydp/symbol.rb

@@ -40,6 +40,8 @@ class Nydp::Symbol
   def hash       ; name.hash      ; end
   def eql? other ; self == other  ; end
   def is? nm     ; self.name == nm.to_sym   ; end
+  def > other    ; self.name > other.name   ; end
+  def < other    ; self.name < other.name   ; end
   def <=> other  ; self.name <=> other.name ; end
 
   def == other

data/lib/nydp/version.rb

@@ -1,3 +1,3 @@
 module Nydp
-  VERSION = "0.1.8"
+  VERSION = "0.1.9"
 end

data/spec/embedded_spec.rb

@@ -27,19 +27,19 @@ describe Nydp::Parser do
   it "should parse empty string" do
     expected = pair_list([sym('string-pieces'), Nydp::StringFragmentCloseToken.new('','$%')])
     actual   = parse_string "%", '$', /%/
-    expect(actual).to eq ''
+    expect(actual).to eq Nydp::StringAtom.new ''
   end
 
   it "should parse external text" do
     actual   = parse_string "a fluffy bunny!", 'EAT ', /!/
-    expect(actual)        .to eq "a fluffy bunny"
+    expect(actual)        .to eq Nydp::StringAtom.new "a fluffy bunny"
     expect(actual.inspect).to eq '"a fluffy bunny"'
   end
 
   it "should parse a string delimited by eof" do
     expected = pair_list([sym('string-pieces'), Nydp::StringFragmentCloseToken.new('a fluffy bunny!','a fluffy bunny!')])
     actual   = parse_string "a fluffy bunny!", '', :eof
-    expect(actual)        .to eq "a fluffy bunny!"
+    expect(actual)        .to eq Nydp::StringAtom.new "a fluffy bunny!"
     expect(actual.inspect).to eq '"a fluffy bunny!"'
   end
 
@@ -59,7 +59,7 @@ describe Nydp::Parser do
   it "should parse a string with embedded code containing a nested string, delimited by eof" do
     n1 = sym(:foo)
     n2 = sym(:bar)
-    n3 = 'an embedded bunny :)'
+    n3 = Nydp::StringAtom.new 'an embedded bunny :)'
     n4 = sym(:zop)
 
     x1 = sym('string-pieces')

data/spec/nydp_spec.rb

@@ -18,7 +18,7 @@ describe Nydp do
   end
 
   it "should add strings" do
-    expect(run '(+ "hello" " " "world")').to eq "hello world"
+    expect(run '(+ "hello" " " "world")').to eq Nydp::StringAtom.new("hello world")
   end
 
   it "should add Pairs" do
@@ -42,7 +42,7 @@ describe Nydp do
   end
 
   it "should convert items to strings" do
-    expect(run "(to-string 3.1415)").to eq "3.1415"
+    expect(run "(to-string 3.1415)").to eq Nydp::StringAtom.new("3.1415")
   end
 
   it "should compare integers" do

data/spec/parser_spec.rb

@@ -80,7 +80,7 @@ describe Nydp::Parser do
     s2 = Nydp::StringFragmentCloseToken.new "hello there", '"hello there"'
 
     x1 = 1
-    x2 = "hello there"
+    x2 = Nydp::StringAtom.new "hello there"
     x3 = 3
 
     expected = pair_list [x1, x2, x3]
@@ -90,7 +90,7 @@ describe Nydp::Parser do
 
   it "should parse a string" do
     x1 = sym 'join'
-    x2 = " - "
+    x2 = Nydp::StringAtom.new " - "
     x3 = 1
     x4 = 2
     x5 = 3
@@ -105,7 +105,7 @@ describe Nydp::Parser do
     s2 = Nydp::StringFragmentCloseToken.new "hello (1 2 3) there", '"hello (1 2 3) there"'
 
     x1 = 1
-    x2 = "hello (1 2 3) there"
+    x2 = Nydp::StringAtom.new "hello (1 2 3) there"
     x3 = 3
 
     expected = pair_list [x1, x2, x3]
@@ -118,7 +118,7 @@ describe Nydp::Parser do
     s2 = Nydp::StringFragmentCloseToken.new "hello there \"jimmy\"", '"hello there \"jimmy\""'
 
     x1 = 1
-    x2 = "hello there \"jimmy\""
+    x2 = Nydp::StringAtom.new "hello there \"jimmy\""
     x3 = 3
 
     expected = pair_list [x1, x2, x3]
@@ -216,7 +216,7 @@ describe Nydp::Parser do
   end
 
   it "retains otherwise unidentified list prefixes" do
-    expect(parse "%wong(bar)").to eq pair_list([prefix_list, "%wong", pair_list([bar])])
+    expect(parse "%wong(bar)").to eq pair_list([prefix_list, Nydp::StringAtom.new("%wong"), pair_list([bar])])
   end
 
   it "should do some complicated unquote stuff with lists" do
@@ -262,7 +262,7 @@ describe Nydp::Parser do
   ; here's a comment
   (zab))
 "
-    c1 = pair_list([comment, "here's a comment"])
+    c1 = pair_list([comment, Nydp::StringAtom.new("here's a comment")])
     fbar = pair_list([bar])
     fzab = pair_list([Nydp::Symbol.mk(:zab, ns)])
     fdef = Nydp::Symbol.mk(:def, ns)

data/spec/string_atom_spec.rb

@@ -1,9 +1,61 @@
 require "spec_helper"
 
 describe Nydp::StringAtom do
+  let(:bar) { Nydp::StringAtom.new "BAR" }
+  let(:foo) { Nydp::StringAtom.new "FOO" }
+  let(:vm)  { Nydp::VM.new               }
+
+  it "is not equal to a symbol with the same represenation" do
+    string = Nydp::StringAtom.new "harrypotter"
+    symbol = Nydp::Symbol.mk "harrypotter", ns
+    compare = Nydp::StringAtom.new symbol.to_s
+    expect(string == compare).to eq true
+    expect(string == symbol) .to eq false
+  end
+
+  it "is not equal to a list with the same represenation" do
+    string = Nydp::StringAtom.new "(FOO BAR)"
+    list   = Nydp::Pair.from_list [foo, bar]
+    compare = Nydp::StringAtom.new list.to_s
+    expect(string == compare).to eq true
+    expect(string == list)   .to eq false
+  end
+
   it "returns its string in #to_ruby" do
     s = Nydp::StringAtom.new "harrypotter"
     expect(s.to_ruby).to eq "harrypotter"
     expect(s.to_ruby.class).to eq String
   end
+
+  it "works with builtin greater-than when true" do
+    f = Nydp::Builtin::GreaterThan.new
+
+    f.invoke vm, pair_list([foo, bar])
+
+    expect(vm.pop_arg).to eq Nydp.T
+  end
+
+  it "works with builtin greater-than when false" do
+    f = Nydp::Builtin::GreaterThan.new
+
+    f.invoke vm, pair_list([bar, foo])
+
+    expect(vm.pop_arg).to eq Nydp.NIL
+  end
+
+  it "works with builtin less-than when true" do
+    f = Nydp::Builtin::LessThan.new
+
+    f.invoke vm, pair_list([bar, foo])
+
+    expect(vm.pop_arg).to eq Nydp.T
+  end
+
+  it "works with builtin less-than when false" do
+    f = Nydp::Builtin::LessThan.new
+
+    f.invoke vm, pair_list([foo, bar])
+
+    expect(vm.pop_arg).to eq Nydp.NIL
+  end
 end

data/spec/symbol_spec.rb

@@ -1,6 +1,10 @@
 require 'spec_helper'
 
 describe Nydp::Symbol do
+  let(:bar) { Nydp::Symbol.mk :BAR, ns }
+  let(:foo) { Nydp::Symbol.mk :FOO, ns }
+  let(:vm)  { Nydp::VM.new             }
+
   it "returns a ruby symbol in #to_ruby" do
     sym = Nydp::Symbol.mk :foo, ns
     expect(sym.to_ruby).to eq :foo
@@ -37,4 +41,37 @@ describe Nydp::Symbol do
     expect(sym1.eql?   sym2).to eq true
     expect(sym1.equal? sym2).to eq false
   end
+
+  it "works with builtin greater-than when true" do
+    f = Nydp::Builtin::GreaterThan.new
+
+    f.invoke vm, pair_list([foo, bar])
+
+    expect(vm.pop_arg).to eq Nydp.T
+  end
+
+  it "works with builtin greater-than when false" do
+    f = Nydp::Builtin::GreaterThan.new
+
+    f.invoke vm, pair_list([bar, foo])
+
+    expect(vm.pop_arg).to eq Nydp.NIL
+  end
+
+  it "works with builtin less-than when true" do
+    f = Nydp::Builtin::LessThan.new
+
+    f.invoke vm, pair_list([bar, foo])
+
+    expect(vm.pop_arg).to eq Nydp.T
+  end
+
+  it "works with builtin less-than when false" do
+    f = Nydp::Builtin::LessThan.new
+
+    f.invoke vm, pair_list([foo, bar])
+
+    expect(vm.pop_arg).to eq Nydp.NIL
+  end
+
 end

metadata

@@ -1,14 +1,14 @@
 --- !ruby/object:Gem::Specification
 name: nydp
 version: !ruby/object:Gem::Version
-  version: 0.1.8
+  version: 0.1.9
 platform: ruby
 authors:
 - Conan Dalton
 autorequire: 
 bindir: bin
 cert_chain: []
-date: 2015-11-19 00:00:00.000000000 Z
+date: 2016-01-11 00:00:00.000000000 Z
 dependencies:
 - !ruby/object:Gem::Dependency
   name: bundler
@@ -87,6 +87,7 @@ files:
 - lib/lisp/core-000.nydp
 - lib/lisp/core-010-precompile.nydp
 - lib/lisp/core-015-documentation.nydp
+- lib/lisp/core-017-builtin-dox.nydp
 - lib/lisp/core-020-utils.nydp
 - lib/lisp/core-030-syntax.nydp
 - lib/lisp/core-040-utils.nydp
@@ -128,6 +129,7 @@ files:
 - lib/lisp/tests/quasiquote-examples.nydp
 - lib/lisp/tests/range-examples.nydp
 - lib/lisp/tests/rfnwith-tests.nydp
+- lib/lisp/tests/sort-examples.nydp
 - lib/lisp/tests/string-tests.nydp
 - lib/lisp/tests/syntax-tests.nydp
 - lib/lisp/tests/tuples-examples.nydp
@@ -162,6 +164,7 @@ files:
 - lib/nydp/builtin/puts.rb
 - lib/nydp/builtin/quit.rb
 - lib/nydp/builtin/random_string.rb
+- lib/nydp/builtin/sort.rb
 - lib/nydp/builtin/sqrt.rb
 - lib/nydp/builtin/string_match.rb
 - lib/nydp/builtin/string_replace.rb