rbl 0.0.1

checksums.yaml

@@ -0,0 +1,7 @@
+---
+SHA1:
+  metadata.gz: 79590c140a9864fb5f46c288fe46603d8b63b3c9
+  data.tar.gz: 2109a3b23bf7b20e8e30e95d8e0451119ec72a5a
+SHA512:
+  metadata.gz: c66238bc2c4772dd3557edfd11a56309135e9f423361a8c9783b14193a75c7d1208da3005463d2fc5682e34714ac88ec748bcd3c61efb41611f24f6a12b9372c
+  data.tar.gz: 82e872d0e9e44745b075f5b2a26bf9fdebfcc6666fd7ac45c4cac2c13df81333e98952998a4b1e250b4e565e0ef8da3b60616364c292977fed10594fedf7b7d5

data/.gitignore

@@ -0,0 +1,13 @@
+*.gem
+/.bundle/
+/.yardoc
+/Gemfile.lock
+/_yardoc/
+/coverage/
+/doc/
+/pkg/
+/spec/reports/
+/tmp/
+
+# rspec failure tracking
+.rspec_status

data/.rspec

@@ -0,0 +1,2 @@
+--format documentation
+--color

data/.travis.yml

@@ -0,0 +1,5 @@
+sudo: false
+language: ruby
+rvm:
+  - 2.3.1
+before_install: gem install bundler -v 1.14.5

data/Gemfile

@@ -0,0 +1,4 @@
+source 'https://rubygems.org'
+
+# Specify your gem's dependencies in rubylisp.gemspec
+gemspec

data/LICENSE.txt

@@ -0,0 +1,21 @@
+The MIT License (MIT)
+
+Copyright (c) 2017 Dave Yarwood
+
+Permission is hereby granted, free of charge, to any person obtaining a copy
+of this software and associated documentation files (the "Software"), to deal
+in the Software without restriction, including without limitation the rights
+to use, copy, modify, merge, publish, distribute, sublicense, and/or sell
+copies of the Software, and to permit persons to whom the Software is
+furnished to do so, subject to the following conditions:
+
+The above copyright notice and this permission notice shall be included in
+all copies or substantial portions of the Software.
+
+THE SOFTWARE IS PROVIDED "AS IS", WITHOUT WARRANTY OF ANY KIND, EXPRESS OR
+IMPLIED, INCLUDING BUT NOT LIMITED TO THE WARRANTIES OF MERCHANTABILITY,
+FITNESS FOR A PARTICULAR PURPOSE AND NONINFRINGEMENT. IN NO EVENT SHALL THE
+AUTHORS OR COPYRIGHT HOLDERS BE LIABLE FOR ANY CLAIM, DAMAGES OR OTHER
+LIABILITY, WHETHER IN AN ACTION OF CONTRACT, TORT OR OTHERWISE, ARISING FROM,
+OUT OF OR IN CONNECTION WITH THE SOFTWARE OR THE USE OR OTHER DEALINGS IN
+THE SOFTWARE.

data/README.md

@@ -0,0 +1,103 @@
+# RubyLisp
+
+A Lisp dialect of Ruby.
+
+## Why?
+
+Lisps are great, but I haven't found one usable enough (by my own standards) for scripting. [Clojure][clojure] is my favorite language from a design perpective, and the fact that you can leverage existing JVM libraries is super convenient. But there's just one problem -- its startup time is _so slow_.
+
+[Common Lisp][commonlisp] is nice; it's a powerful Lisp, and it's fast. But it's not always
+easy to find X existing library to do Y thing, it's maybe a little too
+low-level for my liking, and the tooling situation is not so great.
+
+[Ruby][ruby] is great for scripting, cross-platform, and has hella good libraries, but there's just one problem -- it's not a Lisp.
+
+I've played around with the [make-a-lisp][mal] guide a few times in the past to
+build Lisps for fun in languages like Rust. I thought it would be interesting to
+try and build for myself the convenient scripting Lisp that I always wanted. It turns out that it's super easy to write a Lisp interpreter, but it's awful time-consuming to build a whole language from scratch. I had a shower thought that the Ruby standard library can already do about 80% of the things a faithful Lisp should do, so maybe the path of least resistance to building the Lisp of my dreams is to write the interpreter in Ruby and totally cheat on all of the function implementations by delegating to functions and types that have already been implemented in the Ruby stdlib.
+
+I think I was right. Check it out, everyone -- you can write your Ruby scripts in Lisp now!
+
+## Features
+
+> NOTE: RubyLisp is still in early development. If you find something is broken
+> or missing, please file an issue, or better yet, fork this repo, add/fix it
+> yourself, and make a Pull Request!
+
+* Syntax and stdlib functions heavily influenced by Clojure.
+* Easy, convenient Ruby inter-op.
+* Fire up a REPL or run it in a script.
+* Immutable linked lists, vectors, and hashes courtesy of the [Hamster][hamster]
+  library.
+* _(TODO)_ Macros, Clojure-style.
+* _(TODO)_ Namespaces, Clojure-style.
+* _(TODO)_ Dependency management / the ability to use some sort of build tool to
+  include Ruby libraries and use them via inter-op.
+
+## Examples
+
+_TODO_
+
+## Installation
+
+Run this:
+
+```bash
+$ gem install rubylisp
+```
+
+## Usage
+
+To start a REPL:
+
+```bash
+$ rbl
+```
+
+To interpret a file containing RubyLisp code:
+
+```bash
+$ rbl my_sweet_rubylisp_script.rbl
+```
+
+Or, if you'd like, you can include a shebang, make the script executable and run it directly:
+
+```
+$ cat << EOF > reticulate_splines.rbl
+#!/usr/bin/env rbl
+(print "Reticulating splines... ")
+(Kernel::sleep 2)
+(println "done.")
+EOF
+
+$ chmod +x reticulate_splines.rbl
+
+$ ./reticulate_splines.rbl
+Reticulating splines... done.
+```
+
+## Development
+
+After checking out the repo, run `bin/setup` to install dependencies. Then, run `rake spec` to run the tests. You can also run `bin/console` for an interactive prompt that will allow you to experiment.
+
+To install this gem onto your local machine, run `bundle exec rake install`. To release a new version, update the version number in `version.rb`, and then run `bundle exec rake release`, which will create a git tag for the version, push git commits and tags, and push the `.gem` file to [rubygems.org](https://rubygems.org).
+
+## Contributing
+
+Contributions welcome!
+
+As a general rule, I want RubyLisp to mirror the behavior of Clojure as closely
+as possible. If you have a favorite Clojure function/macro and it isn't included
+in RubyLisp yet, why not add it yourself and make a Pull Request? :)
+
+## License
+
+Copyright © 2017 Dave Yarwood
+
+The gem is available as open source under the terms of the [MIT License](http://opensource.org/licenses/MIT).
+
+[clojure]: https://clojure.org
+[commonlisp]: https://en.wikipedia.org/wiki/Common_Lisp
+[ruby]: http://ruby-lang.org
+[mal]: https://github.com/kanaka/mal
+[hamster]: https://github.com/hamstergem/hamster

data/Rakefile

@@ -0,0 +1,6 @@
+require "bundler/gem_tasks"
+require "rspec/core/rake_task"
+
+RSpec::Core::RakeTask.new(:spec)
+
+task :default => :spec

data/bin/console

@@ -0,0 +1,14 @@
+#!/usr/bin/env ruby
+
+require "bundler/setup"
+require "rubylisp"
+
+# You can add fixtures and/or initialization code here to make experimenting
+# with your gem easier. You can also use a different console, if you like.
+
+# (If you use this, don't forget to add pry to your Gemfile!)
+# require "pry"
+# Pry.start
+
+require "irb"
+IRB.start(__FILE__)

data/bin/rbl

@@ -0,0 +1,27 @@
+#!/usr/bin/env ruby
+
+require 'bundler/setup'
+require 'rubylisp/parser'
+require 'rubylisp/repl'
+
+USAGE = <<~HEREDOC
+  Usage:
+    To start a REPL session:
+    #{File.basename $0}
+
+    To run a file:
+    #{File.basename $0} <filename>
+HEREDOC
+
+if __FILE__ == $0
+  case ARGV.length
+  when 0
+    RubyLisp::REPL::start
+  when 1
+    file_contents = File.read ARGV[0]
+    input = file_contents.gsub(/\A#!.*\n/, '')
+    puts RubyLisp::Parser.parse(input)
+  else
+    puts USAGE
+  end
+end

data/bin/setup

@@ -0,0 +1,8 @@
+#!/usr/bin/env bash
+set -euo pipefail
+IFS=$'\n\t'
+set -vx
+
+bundle install
+
+# Do any other automated setup that you need to do here

data/lib/rubylisp/environment.rb

@@ -0,0 +1,75 @@
+require 'rubylisp/parser'
+
+module RubyLisp
+  class Environment
+    attr_accessor :namespace, :vars, :outer
+
+    def initialize(outer: nil, namespace: nil)
+      @vars = {'*ns*' => (outer or self)}
+      @outer = outer
+      @namespace = namespace or
+                   (outer.namespace if outer) or
+                   "__ns_#{rand 10000}"
+    end
+
+    def set key, val
+      @vars[key] = val
+    end
+
+    def find key
+      if @vars.member? key
+        self
+      elsif @outer
+        @outer.find key
+      else
+        nil
+      end
+    end
+
+    def get key
+      env = find key
+      if env
+        env.vars[key]
+      else
+        raise RubyLisp::RuntimeError, "Unable to resolve symbol: #{key}"
+      end
+    end
+
+    # Copies all vars from `other_env` to this one.
+    def refer other_env
+      @vars = @vars.merge other_env.vars do |key, oldval, newval|
+        if key == '*ns*'
+          oldval
+        else
+          puts "WARNING: #{namespace}/#{key} being replaced by " +
+               "#{other_env.namespace}/#{key}"
+          newval
+        end
+      end
+    end
+
+    # TODO: some notion of "required namespaces" whose vars can be accessed when
+    # qualified with the namespace name
+
+    def load_rbl_file path
+      root = File.expand_path '../..', File.dirname(__FILE__)
+      input = File.read "#{root}/#{path}"
+
+      namespace = RubyLisp::Environment.new
+      RubyLisp::Parser.parse input, namespace
+      namespace
+    end
+
+    def stdlib
+      namespace = load_rbl_file 'rubylisp/core.rbl'
+      refer namespace
+      self
+    end
+
+    def repl
+      namespace = load_rbl_file 'rubylisp/repl.rbl'
+      refer namespace
+      self
+    end
+  end
+end

data/lib/rubylisp/evaluator.rb

@@ -0,0 +1,227 @@
+require 'rubylisp/environment'
+require 'rubylisp/printer'
+require 'rubylisp/types'
+
+module RubyLisp
+  module Evaluator
+    module_function
+
+    def assert_number_of_args sexp, num_args
+      fn, *args = sexp.value
+      fn_name = fn.value
+      unless args.count == num_args
+        raise RubyLisp::RuntimeError,
+              "Wrong number of arguments passed to `#{fn_name}`; " +
+              "got #{args.count}, expected #{num_args}."
+      end
+    end
+
+    def assert_at_least_n_args sexp, num_args
+      fn, *args = sexp.value
+      fn_name = fn.value
+      unless args.count >= num_args
+        raise RubyLisp::RuntimeError,
+              "Wrong number of arguments passed to `#{fn_name}`; " +
+              "got #{args.count}, expected at least #{num_args}."
+      end
+    end
+
+    def assert_arg_type sexp, arg_number, arg_type
+      fn = sexp.value[0]
+      fn_name = fn.value
+      arg = if arg_number == 'last'
+              sexp.value.last
+            else
+              sexp.value[arg_number]
+            end
+
+      arg_description = if arg_number == 'last'
+                          'The last argument'
+                        else
+                          "Argument ##{arg_number}"
+                        end
+
+      arg_types = if arg_type.class == Array
+                    arg_type
+                  else
+                    [arg_type]
+                  end
+
+      expected = case arg_types.count
+                 when 1
+                   arg_types.first
+                 when 2
+                   arg_types.join(' or ')
+                 else
+                   last_arg_type = arg_types.pop
+                   arg_types.join(', ') + " or #{last_arg_type}"
+                 end
+
+      if arg_types.none? {|type| arg.is_a? type}
+        raise RubyLisp::RuntimeError,
+              "#{arg_description} to `#{fn_name}` must be a " +
+              "#{expected}; got a #{arg.class}."
+      end
+    end
+
+    def eval_ast input, env
+      case input
+      when Array # of ASTs to be evaluated, e.g. multiple expressions in a file
+        input.compact.map {|form| eval_ast(form, env)}.last
+      when RubyLisp::HashMap
+        input.value.map {|k, v| [eval_ast(k, env), eval_ast(v, env)]}
+      when RubyLisp::List
+        if input.value.empty?
+          input.value
+        elsif input.value[0].value == 'apply'
+          coll = eval_ast(input.value[-1], env) || Hamster::Vector[]
+
+          # evaluate the last argument
+          sexp = RubyLisp::List.new(input.value.fill(coll, -1, 1))
+          # assert that it's enumerable
+          assert_arg_type sexp, 'last', Enumerable
+
+          # drop `apply` and pull the last form's contents into the sexp as
+          # multiple arguments
+          all_but_last_arg = sexp.value[1..-2].map {|arg| eval_ast arg, env}
+          fn, *args = all_but_last_arg + coll.to_list
+          sexp = RubyLisp::List.new([RubyLisp::Symbol.new("apply"), fn])
+          assert_arg_type sexp, 1, Proc
+          fn.call(*args)
+        elsif input.value[0].value == 'def'
+          assert_arg_type input, 1, RubyLisp::Symbol
+          key, val = input.value[1..-1]
+          env.set key.value, eval_ast(val, env)
+        elsif input.value[0].value == 'do'
+          body = input.value[1..-1]
+          body.map {|form| eval_ast(form, env)}.last
+        elsif input.value[0].value == 'fn'
+          if input.value[1].class == RubyLisp::Symbol
+            fn_name = input.value[1].value
+            bindings, *body = input.value[2..-1]
+          else
+            fn_name = "__fn_#{rand 10000}"
+            bindings, *body = input.value[1..-1]
+          end
+
+          unless bindings.class == RubyLisp::Vector
+            raise RubyLisp::RuntimeError,
+                  "The bindings of `fn` must be a RubyLisp::Vector."
+          end
+
+          ampersand_indices = bindings.value.to_list.indices {|x| x.value == '&'}
+          if ampersand_indices.any? {|i| i != bindings.value.count - 2}
+            raise RubyLisp::RuntimeError,
+                  "An '&' can only occur right before the last binding."
+          end
+
+          fn = lambda do |*args|
+            inner_env = RubyLisp::Environment.new(outer: env)
+            inner_env.set(fn_name, fn) # self-referential lambda omg
+
+            sexp = RubyLisp::List.new([RubyLisp::Symbol.new(fn_name), *args])
+            if bindings.value.any? {|binding| binding.value == '&'}
+              required_args = bindings.value.count - 2
+              assert_at_least_n_args sexp, required_args
+
+              bindings.value[0..-3].zip(args.take(required_args)).each do |k, v|
+                inner_env.set(k.value, v)
+              end
+
+              rest_args = if args.count > required_args
+                            args[required_args..-1].to_list
+                          else
+                            nil
+                          end
+
+              inner_env.set(bindings.value[-1].value, rest_args)
+            else
+              required_args = bindings.value.count
+              assert_number_of_args sexp, required_args
+
+              bindings.value.zip(args).each do |k, v|
+                inner_env.set(k.value, v)
+              end
+            end
+
+            body.map {|form| eval_ast(form, inner_env)}.last
+          end
+        elsif input.value[0].value == 'if'
+          cond, then_form, else_form = input.value[1..-1]
+          unless then_form
+            raise RubyLisp::RuntimeError,
+                  "An `if` form must at least have a 'then' branch."
+          end
+
+          if (eval_ast cond, env)
+            eval_ast(then_form, env)
+          elsif else_form
+            eval_ast(else_form, env)
+          end
+        elsif input.value[0].value == 'in-ns'
+          assert_number_of_args input, 1
+          input.value[1] = eval_ast(input.value[1], env)
+          assert_arg_type input, 1, RubyLisp::Symbol
+          ns_name = input.value[1].to_s
+          # TODO: register ns and switch to it
+          env.namespace = ns_name
+        elsif input.value[0].value == 'let'
+          assert_arg_type input, 1, RubyLisp::Vector
+          inner_env = RubyLisp::Environment.new(outer: env)
+          bindings, *body = input.value[1..-1]
+          unless bindings.value.count.even?
+            raise RubyLisp::RuntimeError,
+                  "The bindings vector of `let` must contain an even number " +
+                  " of forms."
+          end
+
+          bindings.value.each_slice(2) do |(k, v)|
+            inner_env.set k.value, eval_ast(v, inner_env)
+          end
+
+          body.map {|form| eval_ast(form, inner_env)}.last
+        elsif input.value[0].value == 'ns'
+          # ns will be defined more robustly in rbl.core, but rbl.core also
+          # needs the `ns` form in order to declare that it is rbl.core.
+          #
+          # defining it here in a minimal form where it is equivalent to in-ns,
+          # except that you don't have to quote the namespace name
+          assert_number_of_args input, 1
+          assert_arg_type input, 1, RubyLisp::Symbol
+          ns_name = input.value[1].to_s
+          # TODO: register ns and switch to it
+          env.namespace = ns_name
+        elsif input.value[0].value == 'quote'
+          assert_number_of_args input, 1
+          fn, *args = input.value
+          quoted_form = args[0]
+
+          if [RubyLisp::List, RubyLisp::Vector].member? quoted_form.class
+            quoted_form.quote.value
+          else
+            quoted_form.quote
+          end
+        elsif input.value[0].value == 'resolve'
+          assert_number_of_args input, 1
+          symbol = eval_ast(input.value[1], env)
+          sexp = RubyLisp::List.new(input.value.fill(symbol, 1, 1))
+          assert_arg_type sexp, 1, RubyLisp::Symbol
+          symbol.resolve(env)
+        else
+          fn, *args = input.value.map {|value| eval_ast(value, env)}
+          fn.call(*args)
+        end
+      when RubyLisp::Symbol
+        if input.quoted
+          input
+        else
+          input.resolve(env)
+        end
+      when RubyLisp::Vector
+        input.value.map {|value| eval_ast(value, env)}
+      else
+        input.value
+      end
+    end
+  end
+end

data/lib/rubylisp/parser.rb

@@ -0,0 +1,28 @@
+require 'rubylisp/printer'
+require 'rubylisp/reader'
+require 'rubylisp/environment'
+require 'rubylisp/evaluator'
+
+module RubyLisp
+  module Parser
+    module_function
+
+    def read input
+      RubyLisp::Reader.read_str input
+    end
+
+    def eval_ast input, env
+      RubyLisp::Evaluator.eval_ast input, env
+    end
+
+    def print input
+      RubyLisp::Printer.pr_str input
+    end
+
+    def parse input, env = RubyLisp::Environment.new.stdlib
+      ast = read input
+      result = eval_ast ast, env
+      print result
+    end
+  end
+end

data/lib/rubylisp/printer.rb

@@ -0,0 +1,33 @@
+require 'rubylisp/types'
+
+module RubyLisp
+  module Printer
+    module_function
+
+    def pr_str(*xs)
+      if xs.count > 1
+        xs.map {|x| pr_str(x)}.join(' ')
+      else
+        x = xs.first
+        case x
+        when Array, Hamster::Vector
+          "[#{x.map {|item| pr_str(item)}.join(' ')}]"
+        when Hash
+          "{#{x.map {|k, v| "#{pr_str(k)} #{pr_str(v)}"}.join ", "}}"
+        when Hamster::Hash
+          pr_str x.to_hash
+        when Hamster::List
+          "(#{x.map {|item| pr_str(item)}.join(' ')})"
+        when RubyLisp::Keyword
+          ":#{x.value}"
+        when RubyLisp::List
+          "(#{x.value.map {|item| pr_str(item)}.join(' ')})"
+        when RubyLisp::Symbol, RubyLisp::Int, RubyLisp::Float
+          x.value
+        else
+          x.inspect
+        end
+      end
+    end
+  end
+end