nydp 0.0.1

data/lib/nydp/string_atom.rb

@@ -0,0 +1,24 @@
+module Nydp
+  class StringAtom
+    attr_accessor :string, :token
+    def initialize string, token=nil
+      @string, @token = string, token
+    end
+
+    def to_s
+      string
+    end
+
+    def inspect
+      token ? token.rep : string.inspect
+    end
+
+    def == other
+      other.to_s == self.to_s
+    end
+
+    def + other
+      StringAtom.new "#{@string}#{other}"
+    end
+  end
+end

data/lib/nydp/string_token.rb

@@ -0,0 +1,21 @@
+module Nydp
+  class StringFragmentToken
+    attr_accessor :string, :rep
+    def initialize string, rep
+      @string, @rep = string, rep
+    end
+
+    def to_s
+      rep
+    end
+
+    def == other
+      %i{ string rep class }.inject(true) { |bool, attr|
+          bool && (self.send(attr) == other.send(attr))
+        }
+    end
+  end
+
+  class StringFragmentCloseToken < StringFragmentToken
+  end
+end

data/lib/nydp/symbol.rb

@@ -0,0 +1,47 @@
+class Nydp::Symbol
+  attr_accessor :name
+
+  def initialize name
+    @name = name.to_sym
+  end
+
+  def is? nm
+    self.name == nm.to_sym
+  end
+
+  def value context=nil
+    @value || Nydp.NIL
+  end
+
+  def self.mk name, ns
+    name = name.to_sym
+    return Nydp.NIL if name == :nil
+    return Nydp.T   if name == :t
+    sym = ns[name]
+    unless sym
+      sym = new(name)
+      ns[name] = sym
+    end
+    sym
+  end
+
+  def self.find name, ns
+    ns[name.to_sym]
+  end
+
+  def inspect
+    "(sym #{name.to_s})"
+  end
+
+  def to_s
+    name.to_s
+  end
+
+  def == other
+    other.is_a?(Nydp::Symbol) && (self.name == other.name)
+  end
+
+  def assign value, context=nil
+    @value = value
+  end
+end

data/lib/nydp/symbol_lookup.rb

@@ -0,0 +1,43 @@
+require 'nydp/context_symbol'
+
+module Nydp
+  class SymbolLookup
+    extend Helper
+
+    attr_reader :expression
+
+    def initialize expression
+      @expression = expression
+    end
+
+    def execute vm
+      vm.push_arg expression.value vm.peek_context
+    end
+
+    def assign value, context=nil
+      @expression.assign value, context
+    end
+
+    def self.build name, bindings
+      depth = 0
+      while Nydp.NIL.isnt? bindings
+        here = bindings.car
+        if here.key? name
+          return new ContextSymbol.new(depth, name)
+        else
+          depth += 1
+          bindings = bindings.cdr
+        end
+      end
+      new name
+    end
+
+    def to_s
+      "#lookup:#{expression}:"
+    end
+
+    def inspect
+      "#lookup_symbol:#{@expression.inspect}"
+    end
+  end
+end

data/lib/nydp/tokeniser.rb

@@ -0,0 +1,80 @@
+require "strscan"
+
+module Nydp
+  class Tokeniser
+    attr_accessor :state, :finished
+
+    def initialize stream
+      @stream = stream.is_a?(String) ? nil : stream
+      @scanner = StringScanner.new(stream.is_a?(String) ? stream : "")
+      @state = :lisp
+    end
+
+    def no_more?
+      @scanner << @stream.readline if @scanner.eos? && @stream && !@stream.eof?
+      @scanner.eos?
+    end
+
+    def close_delimiter? scanner, delim
+      return (no_more? ? '' : nil) if (delim == :eof)
+      scanner.scan(delim)
+    end
+
+    def next_string_fragment open_delimiter, close_delimiter
+      s = @scanner
+      rep = "#{open_delimiter}"
+      string = ""
+      while (!no_more?)
+        if esc = s.scan(/\\/)
+          rep    << esc
+          ch = s.getch
+          string << ch
+          rep    << ch
+        elsif closer = close_delimiter?(s, close_delimiter)
+          rep << closer
+          return StringFragmentCloseToken.new(string, rep)
+        elsif embed_suffix = s.scan(/%%/)
+          rep << embed_suffix
+          return StringFragmentToken.new(string, rep)
+        else
+          ch = s.getch
+          string << ch
+          rep    << ch
+        end
+      end
+
+      return StringFragmentCloseToken.new(string, rep) if close_delimiter == :eof
+    end
+
+    def next_token
+      s = @scanner
+      tok = nil
+      while !tok
+        if no_more?
+          @finished = true
+          return nil
+        elsif comment = s.scan(/;.*$/)
+          tok = [:comment, comment[1..-1].strip]
+        elsif open_str = s.scan(/"/)
+          tok = [:string_open_delim, open_str]
+        elsif embed_suffix = s.scan(/\]#/)
+          self.state = :external_text
+          tok = [:embed_suffix, embed_suffix]
+        elsif list_prefix = s.scan(/[^\s()]*\(/)
+          tok = [:left_paren, list_prefix[0...-1]]
+        elsif s.scan(/\)/)
+          tok = [:right_paren]
+        elsif number = s.scan(/[-+]?[0-9]*\.[0-9]+([eE][-+]?[0-9]+)?/)
+          tok = [:number, number.to_f]
+        elsif integer = s.scan(/[-+]?[0-9]+/)
+          tok = [:number, integer.to_i]
+        elsif atom = s.scan(/[^\s()]+/)
+          tok = [:symbol, atom]
+        else
+          s.getch
+        end
+      end
+      tok
+    end
+  end
+end

data/lib/nydp/truth.rb

@@ -0,0 +1,37 @@
+module Nydp
+  class Truth
+    def to_s      ; 't'              ; end
+    def inspect   ; 't[nydp::Truth]' ; end
+    def assign *_ ; self             ; end
+  end
+
+  class Nil
+    def car         ; self          ; end
+    def cdr         ; self          ; end
+    def size        ; 0             ; end
+    def is?   other ; other == self ; end
+    def isnt? other ; other != self ; end
+    def to_s        ; "nil"         ; end
+    def + other     ; other         ; end
+    def copy        ; self          ; end
+    def assign *_   ; self          ; end
+
+    def inspect
+      "nil[Nydp::Nil]"
+    end
+
+    def execute vm
+      vm.push_arg self
+    end
+
+    def repush _, contexts
+      contexts.pop
+    end
+  end
+
+  @@nil = Nil.new
+  @@t   = Truth.new
+
+  def self.NIL; @@nil; end
+  def self.T;   @@t;   end
+end

data/lib/nydp/version.rb

@@ -0,0 +1,3 @@
+module Nydp
+  VERSION = "0.0.1"
+end

data/lib/nydp/vm.rb

@@ -0,0 +1,76 @@
+module Nydp
+  class VM
+    include Helper
+    attr_accessor :instructions, :args, :contexts, :current_context
+
+    def initialize
+      @instructions = []
+      @args = []
+      @contexts = []
+    end
+
+    def thread expr
+      instructions.push expr
+      while instructions.length > 0
+        self.current_context = contexts.last
+        ii = instructions.pop
+        i = ii.car
+        ii.cdr.repush instructions, contexts
+        i.execute(self)
+      end
+      pop_arg
+    end
+
+    def peek_context;  current_context;      end
+    def pop_context;   contexts.pop;         end
+    def push_arg a;    args.push a;          end
+    def peek_arg;      args.last;            end
+    def pop_arg;       args.pop;             end
+
+    def push_instructions ii, ctx
+      instructions.push ii
+      contexts.push ctx
+    end
+
+    def pop_args count, tail=Nydp.NIL
+      case count
+      when 0
+        tail
+      else
+        pop_args(count - 1, cons(pop_arg, tail))
+      end
+    end
+
+    def error e
+      puts "     error"
+      puts e
+      puts "================="
+      puts
+      puts "instruction stack"
+      puts "================="
+      instructions.each_with_index do |ii, ix|
+        puts "instructions##{ix} : #{ii} #{ii.source if ii.respond_to?(:source)}"
+      end
+      puts
+      puts
+      puts "context stack"
+      puts "================="
+      contexts.each_with_index do |ctx, ix|
+        puts "context##{ix} : #{ctx}"
+      end
+      puts
+      puts
+      puts "ruby backtrace"
+      puts "================="
+      (e.backtrace || []).each_with_index do |ctx, ix|
+        puts "#{ctx}"
+      end
+      puts
+      puts
+
+      instructions = []
+      contexts     = []
+      args = [Nydp.NIL]
+    end
+  end
+end

data/nydp.gemspec

@@ -0,0 +1,27 @@
+# coding: utf-8
+lib = File.expand_path('../lib', __FILE__)
+$LOAD_PATH.unshift(lib) unless $LOAD_PATH.include?(lib)
+require 'nydp/version'
+
+Gem::Specification.new do |spec|
+  spec.name          = "nydp"
+  spec.version       = Nydp::VERSION
+  spec.authors       = ["Conan Dalton"]
+  spec.email         = ["conan@conandalton.net"]
+  spec.description   = %q{Not Your Daddy's Parentheses}
+  spec.summary       = %q{A new lisp for a new age}
+  spec.homepage      = "http://github.com/conanite/nydp"
+  spec.license       = "MIT"
+
+  spec.files         = `git ls-files`.split($/)
+  spec.executables   = spec.files.grep(%r{^bin/}) { |f| File.basename(f) }
+  spec.test_files    = spec.files.grep(%r{^(test|spec|features)/})
+  spec.require_paths = ["lib"]
+
+  spec.add_development_dependency "bundler", "~> 1.3"
+  spec.add_development_dependency "rake"
+
+  spec.add_development_dependency 'rspec', '~> 2.9'
+  spec.add_development_dependency 'rspec_numbering_formatter'
+
+end

data/spec/boot_spec.rb

@@ -0,0 +1,119 @@
+require 'spec_helper'
+
+describe Nydp do
+  let(:ns)                    { { } }
+  let(:vm)                    { Nydp::VM.new }
+
+  before {
+    Nydp.setup ns
+    boot_path = File.expand_path File.join File.expand_path(File.dirname(__FILE__)), '../lib/lisp/boot.nydp'
+    Nydp::StreamRunner.new(vm, ns, File.new(boot_path)).run
+  }
+
+  def sym name
+    Nydp::Symbol.mk name.to_sym, ns
+  end
+
+  def list *things
+    Nydp::Pair.from_list things.map { |thing|
+      case thing
+      when Symbol
+        sym(thing)
+      when Array
+        list(*thing)
+      else
+        thing
+      end
+    }
+  end
+
+  def run txt
+    Nydp::StreamRunner.new(vm, ns, txt).run
+  end
+
+  it "should map a function over a list of numbers" do
+    expect(run "(map (fn (x) (* x x)) '(1 2 3))").to eq Nydp::Pair.from_list [1, 4, 9]
+  end
+
+  describe "quasiquote" do
+    it "should quasiquote a standalone item" do
+      expect(run "`a").to eq sym(:a)
+    end
+
+    it "should quasiquote a plain list" do
+      expect(run "`(a b c)").to eq list :a, :b, :c
+    end
+
+    it "should quasiquote a plain list with a variable substitution" do
+      expect(run "(assign b 10) `(a ,b c)").to eq list :a, 10, :c
+    end
+
+    it "should quasiquote a plain list with a list-variable substitution" do
+      expect(run "(assign b '(1 2 3)) `(a ,@b c)").to eq list :a, 1, 2, 3, :c
+    end
+
+    it "should quasiquote a plain list with a list-variable substitution at the end" do
+      expect(run "(assign b '(1 2 3)) `(a ,b ,@b)").to eq list :a, [1,2,3], 1, 2, 3
+    end
+
+    it "should quasiquote a plain list with a list-variable substitution at the end" do
+      expect(run "(assign d '(1 2 3)) (assign g '(x y z)) `(a (b c ,d (e f ,@g)))").to eq list :a, [:b, :c, [1, 2, 3], [:e, :f, :x, :y, :z]]
+    end
+  end
+
+  describe "pairs" do
+    it "should break a list into pairs" do
+      result   = run "(pairs '(1 a 2 b 3 c))"
+      expected = run "'((1 a) (2 b) (3 c))"
+      expect(result).to eq expected
+    end
+  end
+
+  describe :let do
+    it "should create an inner scope with a single variable" do
+      lisp = "(def x+3*z (x) (let y 3 (fn (z) (* (+ x y) z)))) ((x+3*z 2) 5)"
+      result = run lisp
+      expect(result).to eq 25
+    end
+  end
+
+  describe :flatten do
+    it "should return a flat list of things" do
+      lisp = "(flatten '((poo (x) (* x x)) (1 2 3)))"
+      result = run lisp
+      expect(result).to eq list :poo, :x, :"*", :x, :x, 1, 2, 3
+    end
+  end
+
+  describe :and do
+    it "should produce some nested conds" do
+      result = run "(pre-compile '(and a b c))"
+      expect(result).to eq list :cond, :a, [:cond, :b, :c]
+    end
+  end
+
+  describe :w_uniq do
+    it "should handle single-var case" do
+      result = run "(reset-uniq-counter) (pre-compile '(w/uniq a foo))"
+      expect(result).to eq list [:fn, [:a], :foo], [:uniq, [:quote, :a]]
+    end
+  end
+
+  describe :or do
+    it "should produce some nested conds" do
+      result = run "(reset-uniq-counter) (pre-compile '(or a b c))"
+      expect(result.to_s).to eq "((fn (ora-3) (cond ora-3 ora-3 ((fn (ora-4) (cond ora-4 ora-4 ((fn (ora-5) (cond ora-5 ora-5)) c))) b))) a)"
+    end
+  end
+
+  describe :join do
+    it "should join a list of strings together" do
+      joining = %{(joinstr "" '("foo" "bar" "bax"))}
+      expect(run joining).to eq "foobarbax"
+    end
+
+    it "should join a list of things together as a string" do
+      expect(run %{(joinstr " - " '(1 2 3))}).to eq "1 - 2 - 3"
+    end
+  end
+end