rbl 0.0.1

data/lib/rubylisp/reader.rb

@@ -0,0 +1,209 @@
+require 'rubylisp/types'
+
+module RubyLisp
+  class Reader
+    # from kanaka/mal
+    TOKEN_REGEX = %r{
+      # ignore whitespace and commas
+      [\s,]*
+
+      # match any of...
+      (
+        # the splice-unquote reader macro
+        ~@|
+
+        # special characters
+        [\[\]{}()'`~^@]|
+
+        # strings
+        "(?:\\.|[^\\"])*"|
+
+        # comments
+        ;.*|
+
+        # any sequence of non-special characters
+        # e.g. symbols, numbers, keywords, booleans, etc.
+        [^\s\[\]{}('"`,;)]*
+      )
+    }x
+
+    attr_accessor :tokens, :position
+
+    def peek
+      @tokens[@position]
+    end
+
+    def next_token
+      token = peek
+      @position += 1
+      token
+    end
+
+    def read_seq(type, end_token, seq=[])
+      case peek
+      when nil
+        raise RubyLisp::ParseError, "Unexpected EOF while parsing #{type}."
+      when end_token
+        next_token
+        type.new(seq)
+      else
+        seq << read_form
+        read_seq(type, end_token, seq)
+      end
+    end
+
+    def read_list
+      read_seq RubyLisp::List, ')'
+    end
+
+    def read_vector
+      read_seq RubyLisp::Vector, ']'
+    end
+
+    def read_hashmap
+      read_seq RubyLisp::HashMap, '}'
+    end
+
+    def read_atom
+      token = next_token
+      case token
+      when nil
+        nil
+      when /^\-?\d+$/
+        RubyLisp::Int.new(token.to_i)
+      when /^\-?\d+\.\d+$/
+        RubyLisp::Float.new(token.to_f)
+      when /^".*"$/
+        # it's safe to use eval here because the tokenizer ensures that
+        # the token is an escaped string representation
+        RubyLisp::String.new(eval(token))
+      # it's a little weird that an unfinished string (e.g. "abc) gets
+      # tokenized as "", but at least the behavior is consistent ¯\_(ツ)_/¯
+      when ""
+        raise RubyLisp::ParseError,
+              "Unexpected EOF while parsing RubyLisp::String."
+      when /^:/
+        RubyLisp::Keyword.new(token[1..-1].to_sym)
+      when 'nil'
+        RubyLisp::Nil.new
+      when 'true'
+        RubyLisp::Boolean.new(true)
+      when 'false'
+        RubyLisp::Boolean.new(false)
+      else
+        RubyLisp::Symbol.new(token)
+      end
+    end
+
+    def read_special_form(special)
+      form = read_form
+      unless form
+        raise RubyLisp::ParseError,
+              "Unexpected EOF while parsing #{special} form."
+      end
+      RubyLisp::List.new([RubyLisp::Symbol.new(special), form])
+    end
+
+    def read_quoted_form
+      read_special_form 'quote'
+    end
+
+    def read_quasiquoted_form
+      read_special_form 'quasiquote'
+    end
+
+    def read_unquoted_form
+      read_special_form 'unquote'
+    end
+
+    def read_splice_unquoted_form
+      read_special_form 'splice-unquote'
+    end
+
+    def read_deref_form
+      read_special_form 'deref'
+    end
+
+    def read_form_with_metadata
+      token = peek
+      case token
+      when nil
+        raise RubyLisp::ParseError, "Unexpected EOF while parsing metadata."
+      when '{'
+        next_token
+        metadata = read_hashmap
+      when /^:/
+        kw = read_form
+        metadata = RubyLisp::HashMap.new([kw, RubyLisp::Boolean.new(true)])
+      else
+        raise RubyLisp::ParseError, "Invalid metadata: '#{token}'"
+      end
+
+      form = read_form
+      unless form
+        raise RubyLisp::ParseError, "Unexpected EOF after metadata."
+      end
+
+      RubyLisp::List.new([RubyLisp::Symbol.new("with-meta"), form, metadata])
+    end
+
+    def read_form
+      case peek
+      when /^;/
+        # ignore comments
+        next_token
+        read_form
+      when '('
+        next_token
+        read_list
+      when '['
+        next_token
+        read_vector
+      when '{'
+        next_token
+        read_hashmap
+      when ')'
+        raise RubyLisp::ParseError, "Unexpected ')'."
+      when ']'
+        raise RubyLisp::ParseError, "Unexpected ']'."
+      when '}'
+        raise RubyLisp::ParseError, "Unexpected '}'."
+      when "'"
+        next_token
+        read_quoted_form
+      when '`'
+        next_token
+        read_quasiquoted_form
+      when '~'
+        next_token
+        read_unquoted_form
+      when '~@'
+        next_token
+        read_splice_unquoted_form
+      when '@'
+        next_token
+        read_deref_form
+      when '^'
+        next_token
+        read_form_with_metadata
+      else
+        read_atom
+      end
+    end
+
+    def tokenize str
+      @tokens = str.strip.scan(TOKEN_REGEX).flatten[0...-1]
+      @position = 0
+    end
+
+    def Reader.read_str str
+      reader = Reader.new
+      reader.tokenize(str)
+      forms = []
+      while reader.position < reader.tokens.count
+        forms << reader.read_form
+      end
+      forms
+    end
+  end
+end

data/lib/rubylisp/repl.rb

@@ -0,0 +1,26 @@
+require 'readline'
+require 'rubylisp/environment'
+require 'rubylisp/parser'
+
+module RubyLisp
+  module REPL
+    module_function
+
+    def start
+      env = RubyLisp::Environment.new(namespace: 'user').stdlib.repl
+
+      while buf = Readline.readline("#{env.namespace}> ", true)
+        begin
+          input = buf.nil? ? '' : buf.strip
+          puts input.empty? ? '' : RubyLisp::Parser.parse(input, env)
+        rescue => e
+          # If an error happens, print it like Ruby would and continue accepting
+          # REPL input.
+          puts e.backtrace
+                .join("\n\t")
+                .sub("\n\t", ": #{e}#{e.class ? " (#{e.class})" : ''}\n\t")
+        end
+      end
+    end
+  end
+end

data/lib/rubylisp/types.rb

@@ -0,0 +1,169 @@
+require 'hamster/core_ext'
+require 'hamster/hash'
+require 'hamster/list'
+require 'hamster/vector'
+
+# Monkey-patch Ruby symbols to act more like Clojure keywords
+class Symbol
+  def to_s
+    inspect
+  end
+
+  def call(target)
+    if [Hash, Hamster::Hash].member? target.class
+      target[self]
+    else
+      target.instance_variable_get "@#{self.to_s}".to_sym
+    end
+  end
+end
+
+# Monkey-patch Hamster types to have nicer (and more Clojure-like) string
+# representations
+module Hamster
+  class Cons
+    def to_s
+      "(#{join " "})"
+    end
+  end
+
+  module EmptyList
+    def EmptyList.to_s
+      "()"
+    end
+  end
+
+  class Vector
+    def to_s
+      "[#{join " "}]"
+    end
+  end
+end
+
+module RubyLisp
+  class Value
+    attr_accessor :value, :quoted
+
+    def initialize(value)
+      @value = value
+    end
+
+    def quote
+      @quoted = true
+      self
+    end
+
+    def unquote
+      @quoted = false
+      self
+    end
+
+    def to_s
+      @value.to_s
+    end
+  end
+
+  class Boolean < Value; end
+  class Float < Value; end
+  class Int < Value; end
+  class Keyword < Value; end
+  class String < Value; end
+
+  class ParseError < StandardError; end
+  class RuntimeError < StandardError; end
+
+  class HashMap < Value
+    def initialize(seq)
+      if seq.size.odd?
+        raise RubyLisp::ParseError,
+          "A RubyLisp::HashMap must contain an even number of forms."
+      else
+        @value = Hamster::Hash[seq.each_slice(2).to_a]
+      end
+    end
+  end
+
+  class List < Value
+    def initialize(values)
+      @value = values.to_list
+    end
+
+    def quote
+      @value.each(&:quote)
+      @quoted = true
+      self
+    end
+
+    def unquote
+      @value.each(&:unquote)
+      @quoted = false
+      self
+    end
+  end
+
+  class Nil < Value
+    def initialize
+      @value = nil
+    end
+  end
+
+  class Symbol < Value
+    def to_s
+      @value
+    end
+
+    def resolve(env)
+      # rbl: (.+ 1 2)
+      # ruby: 1.+(2)
+      instance_method = /^\.(.*)/.match(@value).to_a[1]
+      if instance_method
+        return lambda {|obj, *args| obj.send instance_method, *args}
+      end
+
+      # rbl: (File::open "/tmp/foo")
+      # ruby: File::open("/tmp/foo")  OR  File.open("/tmp/foo")
+      #
+      # rbl: Foo::Bar::BAZ
+      # ruby: Foo::Bar::BAZ
+      if /^\w+(::\w+)+$/ =~ @value
+        first_segment, *segments = @value.split('::')
+        first_segment = Object.const_get first_segment
+        return segments.reduce(first_segment) do |result, segment|
+          if result.class == Proc
+            # a method can only be in the final position
+            raise RubyLisp::RuntimeError, "Invalid value: #{@value}"
+          elsif /^[A-Z]/ =~ segment
+            # get module/class constant
+            result.const_get segment
+          else
+            # if module/class method doesn't exist, trigger a NoMethodError
+            result.send segment unless result.respond_to? segment
+            # call module/class method
+            lambda {|*args| result.send segment, *args }
+          end
+        end
+      end
+
+      env.get @value
+    end
+  end
+
+  class Vector < Value
+    def initialize(values)
+      @value = Hamster::Vector.new(values)
+    end
+
+    def quote
+      @value.each(&:quote)
+      @quoted = true
+      self
+    end
+
+    def unquote
+      @value.each(&:unquote)
+      @quoted = false
+      self
+    end
+  end
+end
+

data/lib/rubylisp/version.rb

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

data/lib/rubylisp.rb

@@ -0,0 +1 @@
+# ʕ •ᴥ• ʔ	nothing to see here

data/rubylisp/core.rbl

@@ -0,0 +1,245 @@
+; TODO:
+; and, or
+; implement macros
+; defn
+; str
+; comment
+; ->, ->>
+; private vars/fns
+; if-not, when, when-not, if-let, when-let
+; cond
+; case
+
+(ns rubylisp.core)
+
+;; MATH & LOGIC
+
+(def +
+  (fn + [x y & more]
+    (let [xy (.+ x y)]
+      (if more
+        (apply + xy more)
+        xy))))
+
+(def -
+  (fn - [x y & more]
+    (let [xy (.- x y)]
+      (if more
+        (apply - xy more)
+        xy))))
+
+(def inc
+  (fn inc [x]
+    (+ x 1)))
+
+(def dec
+  (fn dec [x]
+    (- x 1)))
+
+(def *
+  (fn * [x y & more]
+    (let [xy (.* x y)]
+      (if more
+        (apply * xy more)
+        xy))))
+
+(def /
+  (fn / [x y & more]
+    (let [xy (./ x y)]
+      (if more
+        (apply / xy more)
+        xy))))
+
+(def <
+  (fn < [x y & more]
+    (let [xy (.< x y)]
+      (if more
+        (apply < xy more)
+        xy))))
+
+(def <=
+  (fn <= [x y & more]
+    (let [xy (.<= x y)]
+      (if more
+        (apply <= xy more)
+        xy))))
+
+(def =
+  (fn = [x y & more]
+    (let [xy (.== x y)]
+      (if more
+        (apply = xy more)
+        xy))))
+
+(def not=
+  (fn not= [x y & more]
+    (let [xy (.!= x y)]
+      (if more
+        (apply not= xy more)
+        xy))))
+
+(def boolean
+  (fn boolean [x]
+    (if x true false)))
+
+(def not
+  (fn not [x]
+    (if x false true)))
+
+(def >
+  (fn > [x y & more]
+    (let [xy (.> x y)]
+      (if more
+        (apply > xy more)
+        xy))))
+
+(def >=
+  (fn >= [x y & more]
+    (let [xy (.>= x y)]
+      (if more
+        (apply >= xy more)
+        xy))))
+
+(def pos?
+  (fn pos? [x]
+    (> (count x) 0)))
+
+(def neg?
+  (fn neg? [x]
+    (< (count x) 0)))
+
+(def zero?
+  (fn zero? [x]
+    (= 0 x)))
+
+;; LISTS & COLLECTIONS
+
+(def nil?
+  (fn nil? [x]
+    (= nil x)))
+
+(def count
+  (fn count [x]
+    (if (nil? x)
+      0
+      (.count x))))
+
+(def empty?
+  (fn empty? [coll]
+    (if (nil? coll)
+      true
+      (.empty? coll))))
+
+(def list
+  (fn list [& args]
+    (.to_list (if (nil? args)
+                []
+                args))))
+
+(def list?
+  (fn list? [x]
+    (.is_a? x Hamster::List)))
+
+(def string?
+  (fn string? [x]
+    (.is_a? x Kernel::String)))
+
+(def seq
+  (fn seq [x]
+    (if (not (empty? x))
+      (if (string? x)
+        (.to_list (.chars x))
+        (.to_list x)))))
+
+(def cons
+  (fn cons [x y]
+    (let [lst (if (nil? y) (Hamster::List::empty) (.to_list y))]
+      (.cons lst x))))
+
+(def first
+  (fn first [coll]
+    (.first coll)))
+
+(def last
+  (fn last [coll]
+    (.last coll)))
+
+(def rest
+  (fn rest [coll]
+    (let [lst (if (nil? coll) (Hamster::List::empty) (.to_list coll))]
+      (.tail lst))))
+
+(def take
+  (fn take [n coll]
+    (.to_list (.take coll n))))
+
+;; TODO: support mapping over multiple collections
+(def map
+  (fn map [f coll]
+    (if (empty? coll)
+      ()
+      (cons (f (first coll)) (map f (rest coll))))))
+
+(def reverse
+  (fn reverse [coll]
+    (if (empty? coll)
+      coll
+      (+ [(last coll)]
+         (reverse (.slice coll 0 (dec (count coll))))))))
+
+;; TODO: implement as multiple arity fn
+;; TODO: zero-arity that produces a lazy list, i.e. Hamster::iterate(0,
+;; &:next).take(5)
+;; (requires some kind of block syntax)
+(def range
+  (fn range [& args]
+    (if (= 1 (count args))
+      (apply range 0 args)
+      (apply Hamster::interval args))))
+
+;; TODO: implement as multiple arity fn
+(def repeat
+  (fn repeat [& args]
+    (if (= 1 (count args))
+      (apply Hamster::repeat args)
+      (apply Hamster::replicate args))))
+
+;; STRINGS
+
+(def str
+  (fn str [& args]
+    (.join (map .to_s args))))
+
+;; I/O
+
+(def pr-str
+  (fn pr-str [& args]
+    (if (zero? (count args))
+      ""
+      (apply RubyLisp::Printer::pr_str args))))
+
+(def prn
+  (fn prn [& args]
+    (Kernel::puts (apply pr-str args))
+    nil))
+
+(def print
+  (fn print [& args]
+    (Kernel::print (.join (map str args) " "))
+    nil))
+
+(def println
+  (fn print [& args]
+    (Kernel::puts (.join (map str args) " "))
+    nil))
+
+;; RUBY INTEROP
+
+(def =@
+  (fn =@ [obj kw value]
+    (.instance_variable_set obj (.to_sym (+ "@" (.to_s kw))) value)))
+
+(def class
+  (fn class [x]
+    (.class x)))
+

data/rubylisp/repl.rbl

@@ -0,0 +1,2 @@
+; TODO
+(Kernel::puts "Loaded rubylisp.repl")

data/rubylisp.gemspec

@@ -0,0 +1,34 @@
+# coding: utf-8
+lib = File.expand_path('../lib', __FILE__)
+$LOAD_PATH.unshift(lib) unless $LOAD_PATH.include?(lib)
+require 'rubylisp/version'
+
+Gem::Specification.new do |spec|
+  spec.name          = "rbl"
+  spec.version       = RubyLisp::VERSION
+  spec.authors       = ["Dave Yarwood"]
+  spec.email         = ["dave.yarwood@gmail.com"]
+
+  spec.summary       = "A Lisp dialect of Ruby"
+  spec.description   = "A Lisp dialect of Ruby"
+  spec.homepage      = "https://github.com/daveyarwood/rubylisp"
+  spec.license       = "MIT"
+
+  if spec.respond_to?(:metadata)
+    spec.metadata['allowed_push_host'] = "https://rubygems.org"
+  else
+    raise "RubyGems 2.0 or newer is required to protect against " \
+      "public gem pushes."
+  end
+
+  spec.files         = `git ls-files -z`.split("\x0").reject do |f|
+    f.match(%r{^(test|spec|features)/})
+  end
+  spec.bindir        = "exe"
+  spec.executables   = spec.files.grep(%r{^exe/}) { |f| File.basename(f) }
+  spec.require_paths = ["lib"]
+
+  spec.add_development_dependency "rake", "~> 10.0"
+  spec.add_development_dependency "rspec", "~> 3.0"
+  spec.add_runtime_dependency 'hamster', '3.0.0'
+end