risp-lang 0.1.0

checksums.yaml

@@ -0,0 +1,7 @@
+---
+SHA1:
+  metadata.gz: dee12380e1191bbf433642063e884fa3a25ef51e
+  data.tar.gz: 77dec2a46e3b2c3cffcd4d904ac52c1b5dfb4e56
+SHA512:
+  metadata.gz: 0de0e23fc14fa6c155748d942ced4a60d7be29aace0635c0d596da28261566ccf0b247ed5eb4ac3331cb70a00ad84e81e0a88e8496bae9e323fcd1b357964798
+  data.tar.gz: d22e9e7e96b632e12f2f98c8975e3d0980a77a0c083c2489eb6d116047f067f154ec722846ce8b22e28a395e83a173087cc5566f67ccc4b693e40e8b2ed4e1fd

data/.gitignore

@@ -0,0 +1,9 @@
+/.bundle/
+/.yardoc
+/Gemfile.lock
+/_yardoc/
+/coverage/
+/doc/
+/pkg/
+/spec/reports/
+/tmp/

data/.rspec

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

data/.travis.yml

@@ -0,0 +1,4 @@
+language: ruby
+rvm:
+  - 2.2.0
+before_install: gem install bundler -v 1.10.5

data/Gemfile

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

data/LICENSE.txt

@@ -0,0 +1,21 @@
+The MIT License (MIT)
+
+Copyright (c) 2015 Luca Ongaro
+
+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,135 @@
+# Risp
+
+`Risp` is a LISP implementation written in Ruby. The syntax is reminescent of
+Clojure, and it interoperates with Ruby.
+
+
+## Why?
+
+Why not? :P
+
+Mostly I did this to learn a bit more about programming language design. Or
+maybe I was bored. And also I really like LISPs and I like the idea of writing
+LISP leveraging on the Ruby ecosystem. But still this is mostly an experiment,
+so if you use it you cannot blame me if it ends up eating your laundry or
+setting your kitchen on fire.
+
+
+## Installation
+
+Add this line to your application's Gemfile:
+
+```ruby
+gem 'risp-lang'
+```
+
+And then execute:
+
+    $ bundle
+
+Or install it yourself as:
+
+    $ gem install risp
+
+
+## Usage
+
+### Start a REPL
+
+Just run `risp-repl`
+
+### Execute a file
+
+`risp my_program.risp`
+
+### Inside Ruby
+
+Instantiate an interpreter and evaluate code:
+
+```ruby
+require 'risp'
+risp = Risp::Interpreter.new
+
+risp.eval <<-CODE
+(def double [x]
+  (* 2 x))
+
+(double 5)
+CODE
+```
+
+
+## Syntax
+
+The LISP syntax is very similar to Clojure:
+
+```lisp
+; Define a function
+(defn dec [n]
+  (- n 1))
+
+; Define recursive factorial
+(defn fact [n]
+  (if (<= n 1)
+    1
+    (* n (fact (dec n)))))
+
+(fact 10) ; => 3628800
+
+; Rest argument
+(defn foo [a b &more]
+  [a b more])
+
+(foo 1 2 3 4 5) ; => [1 2 [3 4 5]]
+
+; Argument destructuring
+(defn swap-pairs [[a b] [c d]]
+  [[a c] [b d]])
+
+(swap-pairs [1 2] [3 4]) ; => [[1 3] [2 4]]
+```
+
+
+## Macro support
+
+Macros, quoting and unquoting are supported:
+
+```lisp
+(defmacro defn- [name args body]
+  '(def ~name (fn ~args ~body)))
+
+(defn- sum [a b]
+  (+ a b))
+
+(sum 4 5)
+```
+
+
+## Ruby interoperability
+
+```lisp
+; Ruby methods can be called the same way as LISP functions, just prepend a
+; dot to the method name, pass the receiver as the first argument, followed
+; by any other argument:
+
+(.join ["highway" "to" "the" "danger" "zone"] " ")
+
+; Ruby constants, modules and classes are available, just use Foo/Bar instead
+; of Foo::Bar:
+
+(defn circle-area [radius]
+  (* 2 Math/PI radius))
+```
+
+
+## Contributing
+
+Bug reports and pull requests are welcome on GitHub at
+https://github.com/lucaong/risp.
+
+
+## License
+
+The gem is available as open source under the terms of the [MIT
+License](http://opensource.org/licenses/MIT).
+

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 "risp"
+
+# 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

data/bin/setup

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

data/exe/risp

@@ -0,0 +1,7 @@
+#!/usr/bin/env ruby
+
+require "bundler/setup"
+require "risp"
+
+risp = Risp::Interpreter.new
+risp.eval(File.new(ARGV[0], 'r').read)

data/exe/risp-repl

@@ -0,0 +1,31 @@
+#!/usr/bin/env ruby
+
+require "bundler/setup"
+require "risp"
+require "readline"
+
+risp = Risp::Interpreter.new
+
+def complete?(input)
+  input.count('(') == input.count(')') &&
+    input.count('[') == input.count(']') &&
+    input.count('{') == input.count('}')
+end
+
+puts "The Risp v#{Risp::VERSION} REPL"
+
+input = ''
+while line = Readline.readline('> ', true)
+  begin
+    input << "\n#{line}"
+    if complete?(input) && input.gsub(/\s/, '').size > 0
+      puts "=> #{risp.eval(input).inspect}"
+      input = ''
+    else
+      next
+    end
+  rescue => e
+    puts e.inspect
+    input = ''
+  end
+end

data/lib/risp.rb

@@ -0,0 +1,22 @@
+require "risp/version"
+require "risp/interpreter"
+
+module Risp
+  class Symbol < Struct.new(:name)
+    def inspect
+      name.to_s
+    end
+  end
+
+  class Method < Struct.new(:name)
+    def inspect
+      name.to_s
+    end
+  end
+
+  class Splat < Struct.new(:name)
+    def inspect
+      "&#{name.to_s}"
+    end
+  end
+end

data/lib/risp/core.risp

@@ -0,0 +1,103 @@
+(defmacro defn [name args body]
+  '(def ~name (fn ~args ~body)))
+
+(defmacro ->> [coll &forms]
+  (.reduce forms coll (fn [a f] (.<< f a))))
+
+(defmacro -> [coll &forms]
+  (.reduce forms coll
+           (fn [a f]
+             (.concat '(~(first f) ~a) (rest f)))))
+
+(defn + [&xs]
+  (.reduce xs 0 :+))
+
+(defn - [x &xs]
+  (if (.empty? xs)
+    (- 0 x)
+    (.reduce xs x :-)))
+
+(defn * [&xs]
+  (.reduce xs 1 :*))
+
+(defn / [x &xs]
+  (if (.empty? xs)
+    (/ 1 x)
+    (.reduce xs x :/)))
+
+(defn > [&xs]
+  (.all? (.each_cons xs 2) (fn [[a b]] (.> a b))))
+
+(defn >= [&xs]
+  (.all? (.each_cons xs 2) (fn [[a b]] (.>= a b))))
+
+(defn < [&xs]
+  (.all? (.each_cons xs 2) (fn [[a b]] (.< a b))))
+
+(defn <= [&xs]
+  (.all? (.each_cons xs 2) (fn [[a b]] (.<= a b))))
+
+(defn = [&xs]
+  (.all? (.each_cons xs 2) (fn [[a b]] (.== a b))))
+
+(defn compare [a b]
+  (.<=> a b))
+
+(defn vector [&xs]
+  (.new Hamster/Vector xs))
+
+(defn set [&xs]
+  (.new Hamster/Set xs))
+
+(defn sorted-set [&xs]
+  (.new Hamster/SortedSet xs))
+
+(defn sorted-set-by [comparator &xs]
+  (.new Hamster/SortedSet xs comparator))
+
+(defn list [&xs]
+  (.new Hamster/List xs))
+
+(defn hash-map [&xs]
+  (.new Hamster/Hash (.each_slice xs 2)))
+
+(defn ruby-array [&xs]
+  (.new Array xs))
+
+(defn ruby-set [&xs]
+  (.new Set xs))
+
+(defn ruby-hash [&xs]
+  (.to_h (.each_slice xs 2)))
+
+(defn nil? [x]
+  (.nil? x))
+
+(defn filter [f coll]
+  (.select coll f))
+
+(defn map [f coll]
+  (.map coll f))
+
+(defn reduce [f s coll]
+  (if (nil? coll)
+    (.reduce s f)
+    (.reduce coll s f)))
+
+(defn take [n coll]
+  (.take coll n))
+
+(defn drop [n coll]
+  (.drop coll n))
+
+(defn first [coll]
+  (.first coll))
+
+(defn rest [coll]
+  (drop 1 coll))
+
+(defn get [coll k default]
+  (.fetch coll k default))
+
+(defn println [&xs]
+  (.puts (.new Object) (.join xs " ")))

data/lib/risp/interpreter.rb

@@ -0,0 +1,149 @@
+require "risp/lexer"
+require "risp/parser"
+require "hamster"
+
+module Risp
+  class Interpreter
+    attr_reader :binding, :macros, :lexer, :parser
+
+    SPECIAL_FORMS = {
+      def: -> (elems, binding, locals, macros) {
+        symbol, value = elems
+        binding[symbol.name] = eval(value, binding, locals, macros)
+      },
+      let: -> (elems, binding, locals, macros) {
+        (*assigns), *forms = elems
+        locals = assigns.each_slice(2).reduce(locals.dup) do |locals, (s, v)|
+          locals.merge assign_args([s], [eval(v, binding, locals, macros)])
+        end
+        forms.map { |form| eval(form, binding, locals, macros) }.last
+      },
+      fn: -> (elems, binding, locals, macros) {
+        (*as), body = elems
+        -> (*args) do
+          locals = locals.merge(assign_args(as, args))
+          eval(body, binding, locals, macros)
+        end
+      },
+      do: -> (elems, binding, locals, macros) {
+        elems.map { |el| eval(el, binding, locals, macros) }.last
+      },
+      if: -> (elems, binding, locals, macros) {
+        condition, _then, _else = elems
+        if eval(condition, binding, locals, macros)
+          eval(_then, binding, locals, macros)
+        else
+          eval(_else, binding, locals, macros)
+        end
+      },
+      quote: -> (elems, binding, locals, macros) {
+        unquote(elems.first, binding, locals, macros)
+      },
+      defmacro: -> (elems, binding, locals, macros) {
+        symbol, (*as), body = elems
+        macros[symbol.name] = -> (*args) do
+          locals = locals.merge(assign_args(as, args))
+          eval(body, binding, locals, macros)
+        end
+      },
+      apply: -> (elems, binding, locals, macros) {
+        fn, args = elems.map { |x| eval(x, binding, locals, macros) }
+        fn.call(*args)
+      },
+      require: -> (elems, binding, locals, macros) {
+        elems.each do |lib|
+          require lib
+        end
+      }
+    }
+
+    def initialize()
+      @binding = {}
+      @macros  = {}
+      @lexer   = Risp::Lexer.new
+      @parser  = Risp::Parser.new
+      corelib  = File.read(File.expand_path('core.risp', File.dirname(__FILE__)))
+      eval(corelib)
+    end
+
+    def eval(code)
+      parser.parse(lexer.lex(code)).map { |x| self.class.eval(x, binding, {}, macros) }.last
+    end
+
+    def self.eval(expr, binding, locals, macros)
+      case expr
+      when Hamster::List
+        first = expr.first
+        if special = first.is_a?(Risp::Symbol) && SPECIAL_FORMS[first.name]
+          special.call(expr.drop(1), binding, locals, macros)
+        elsif macro = first.is_a?(Risp::Symbol) && macros[first.name]
+          _, *args = expr
+          eval(macro.call(*args), binding, locals, macros)
+        elsif first.is_a?(Risp::Method)
+          receiver, *args = expr.drop(1).map { |x| eval(x, binding, locals, macros) }
+          if args.last.is_a?(Proc) && receiver.method(first.name).arity < args.size
+            *args, block = args
+            receiver.send(first.name, *args, &block)
+          else
+            receiver.send(first.name, *args)
+          end
+        else
+          fn, *args = expr.map { |x| eval(x, binding, locals, macros) }
+          fn.call(*args)
+        end
+      when Risp::Symbol
+        symbol = expr.name
+        resolve(symbol, binding, locals, macros)
+      when Enumerable
+        expr.map { |x| eval(x, binding, locals, macros) }
+      else
+        expr
+      end
+    end
+
+    def self.unquote(expr, binding, locals, macros)
+      if expr.is_a?(Enumerable) && !expr.is_a?(Risp::Symbol)
+        first, second = expr
+        if first.is_a?(Risp::Symbol) && first.name == :unquote
+          eval(second, binding, locals, macros)
+        else
+          expr.map { |x| unquote(x, binding, locals, macros) }
+        end
+      else
+        expr
+      end
+    end
+
+    def self.resolve(symbol, binding, locals, macros)
+      if locals.has_key?(symbol)
+        locals[symbol]
+      elsif binding.has_key?(symbol)
+        binding[symbol]
+      else
+        begin
+          symbol.to_s.split('/').reduce(Object) do |c, p|
+            c.const_get(p)
+          end
+        rescue NameError => e
+          raise "cannot resolve #{symbol}"
+        end
+      end
+    end
+
+    def self.assign_args(symbols, values)
+      symbols.each_with_index.reduce({}) do |a, (s, i)|
+        v = values[i]
+        if s.is_a?(Hamster::Vector) && v.is_a?(Enumerable)
+          a.merge(assign_args(s, v))
+        elsif s.is_a?(Risp::Splat)
+          a[s.name] = values.drop(i)
+          a
+        else
+          a[s.name] = v
+          a
+        end
+      end
+    end
+  end
+end
+

data/lib/risp/lexer.rb

@@ -0,0 +1,26 @@
+require "rltk/lexer"
+
+module Risp
+  class Lexer < RLTK::Lexer
+    rule(/"[^"]*"/)    { |t| [:STRING, t[1...-1]] }
+    rule(/-?\d+\.\d+/) { |t| [:FLOAT, t.to_f] }
+    rule(/-?\d+/)      { |t| [:INTEGER, t.to_i] }
+    rule(/true|false/) { |b| [:BOOLEAN, b == 'true'] }
+    rule(/nil|\(\)/)   { :NIL }
+    rule(/\(/)         { :LPAREN }
+    rule(/\)/)         { :RPAREN }
+    rule(/\[/)         { :LSQBRACK }
+    rule(/\]/)         { :RSQBRACK }
+    rule(/\{/)         { :LBRACE }
+    rule(/\}/)         { :RBRACE }
+    rule(/\./)         { :DOT }
+    rule(/#/)          { :POUND }
+    rule(/'/)          { :QUOTE }
+    rule(/~/)          { :UNQUOTE }
+    rule(/&/)          { :AMPERSAND }
+    rule(/;[^\n]*/)    # ignore comments
+    rule(/:[^&'~\(\)\{\}\[\]\.#\s,]+/i) { |t| [:KEYWORD, t] }
+    rule(/[^:&'~\(\)\{\}\[\]\.#\s,]+/i) { |t| [:SYMBOL, t] }
+    rule(/[\s,]/)      # ignore whitespaces and commas
+  end
+end

data/lib/risp/parser.rb

@@ -0,0 +1,75 @@
+require 'rltk/parser'
+
+module Risp
+  class Parser < RLTK::Parser
+    build_list_production(:expressions, :expression)
+
+    production(:expression) do
+      clause('atom') do |atom|
+        atom
+      end
+      clause('list') do |list|
+        list
+      end
+      clause('QUOTE expression') do |_, expr|
+        Hamster::List[Risp::Symbol.new(:quote), expr]
+      end
+      clause('UNQUOTE expression') do |_, expr|
+        Hamster::List[Risp::Symbol.new(:unquote), expr]
+      end
+    end
+
+    production(:list) do
+      clause('LPAREN expressions RPAREN') do |_, elems, _|
+        Hamster::List[*elems]
+      end
+    end
+
+    production(:atom) do
+      clause('literal') do |l|
+        l
+      end
+      clause('SYMBOL') do |name|
+        Risp::Symbol.new(name.to_sym)
+      end
+      clause('DOT SYMBOL') do |_, name|
+        Risp::Method.new(name.to_sym)
+      end
+      clause('AMPERSAND SYMBOL') do |_, name|
+        Risp::Splat.new(name.to_sym)
+      end
+    end
+
+    production(:literal) do
+      clause('INTEGER') do |n|
+        n
+      end
+      clause('FLOAT') do |f|
+        f
+      end
+      clause('STRING') do |s|
+        s
+      end
+      clause('BOOLEAN') do |b|
+        b
+      end
+      clause('KEYWORD') do |k|
+        k[1..-1].to_sym
+      end
+      clause('LSQBRACK expressions RSQBRACK') do |_, exprs, _|
+        Hamster::Vector.new(exprs)
+      end
+      clause('POUND LBRACE expressions RBRACE') do |_, _, exprs, _|
+        Hamster::Set.new(exprs)
+      end
+      clause('LBRACE expressions RBRACE') do |_, keyvals, _|
+        Hamster::Hash.new(keyvals.each_slice(2).to_h)
+      end
+      clause('NIL') do |_|
+        nil
+      end
+    end
+
+    finalize
+  end
+end

data/lib/risp/version.rb

@@ -0,0 +1,3 @@
+module Risp
+  VERSION = "0.1.0"
+end

data/risp.gemspec

@@ -0,0 +1,36 @@
+# coding: utf-8
+lib = File.expand_path('../lib', __FILE__)
+$LOAD_PATH.unshift(lib) unless $LOAD_PATH.include?(lib)
+require 'risp/version'
+
+Gem::Specification.new do |spec|
+  spec.name          = "risp-lang"
+  spec.version       = Risp::VERSION
+  spec.authors       = ["Luca Ongaro"]
+  spec.email         = ["lukeongaro@gmail.com"]
+
+  spec.summary       = "LISP implementation in Ruby"
+  spec.description   = "LISP implementation in Ruby"
+  spec.homepage      = "https://github.com/lucaong/risp"
+  spec.license       = "MIT"
+
+  # Prevent pushing this gem to RubyGems.org by setting 'allowed_push_host', or
+  # delete this section to allow pushing this gem to any host.
+  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 { |f| f.match(%r{^(test|spec|features)/}) }
+  spec.bindir        = "exe"
+  spec.executables   = spec.files.grep(%r{^exe/}) { |f| File.basename(f) }
+  spec.require_paths = ["lib"]
+
+  spec.add_dependency "rltk", "~> 3.0"
+  spec.add_dependency "hamster", "~> 1.0"
+
+  spec.add_development_dependency "bundler", "~> 1.10"
+  spec.add_development_dependency "rake", "~> 10.0"
+  spec.add_development_dependency "rspec"
+end

metadata

@@ -0,0 +1,135 @@
+--- !ruby/object:Gem::Specification
+name: risp-lang
+version: !ruby/object:Gem::Version
+  version: 0.1.0
+platform: ruby
+authors:
+- Luca Ongaro
+autorequire: 
+bindir: exe
+cert_chain: []
+date: 2015-08-10 00:00:00.000000000 Z
+dependencies:
+- !ruby/object:Gem::Dependency
+  name: rltk
+  requirement: !ruby/object:Gem::Requirement
+    requirements:
+    - - "~>"
+      - !ruby/object:Gem::Version
+        version: '3.0'
+  type: :runtime
+  prerelease: false
+  version_requirements: !ruby/object:Gem::Requirement
+    requirements:
+    - - "~>"
+      - !ruby/object:Gem::Version
+        version: '3.0'
+- !ruby/object:Gem::Dependency
+  name: hamster
+  requirement: !ruby/object:Gem::Requirement
+    requirements:
+    - - "~>"
+      - !ruby/object:Gem::Version
+        version: '1.0'
+  type: :runtime
+  prerelease: false
+  version_requirements: !ruby/object:Gem::Requirement
+    requirements:
+    - - "~>"
+      - !ruby/object:Gem::Version
+        version: '1.0'
+- !ruby/object:Gem::Dependency
+  name: bundler
+  requirement: !ruby/object:Gem::Requirement
+    requirements:
+    - - "~>"
+      - !ruby/object:Gem::Version
+        version: '1.10'
+  type: :development
+  prerelease: false
+  version_requirements: !ruby/object:Gem::Requirement
+    requirements:
+    - - "~>"
+      - !ruby/object:Gem::Version
+        version: '1.10'
+- !ruby/object:Gem::Dependency
+  name: rake
+  requirement: !ruby/object:Gem::Requirement
+    requirements:
+    - - "~>"
+      - !ruby/object:Gem::Version
+        version: '10.0'
+  type: :development
+  prerelease: false
+  version_requirements: !ruby/object:Gem::Requirement
+    requirements:
+    - - "~>"
+      - !ruby/object:Gem::Version
+        version: '10.0'
+- !ruby/object:Gem::Dependency
+  name: rspec
+  requirement: !ruby/object:Gem::Requirement
+    requirements:
+    - - ">="
+      - !ruby/object:Gem::Version
+        version: '0'
+  type: :development
+  prerelease: false
+  version_requirements: !ruby/object:Gem::Requirement
+    requirements:
+    - - ">="
+      - !ruby/object:Gem::Version
+        version: '0'
+description: LISP implementation in Ruby
+email:
+- lukeongaro@gmail.com
+executables:
+- risp
+- risp-repl
+extensions: []
+extra_rdoc_files: []
+files:
+- ".gitignore"
+- ".rspec"
+- ".travis.yml"
+- Gemfile
+- LICENSE.txt
+- README.md
+- Rakefile
+- bin/console
+- bin/setup
+- exe/risp
+- exe/risp-repl
+- lib/risp.rb
+- lib/risp/core.risp
+- lib/risp/interpreter.rb
+- lib/risp/lexer.rb
+- lib/risp/parser.rb
+- lib/risp/version.rb
+- risp.gemspec
+homepage: https://github.com/lucaong/risp
+licenses:
+- MIT
+metadata:
+  allowed_push_host: https://rubygems.org
+post_install_message: 
+rdoc_options: []
+require_paths:
+- lib
+required_ruby_version: !ruby/object:Gem::Requirement
+  requirements:
+  - - ">="
+    - !ruby/object:Gem::Version
+      version: '0'
+required_rubygems_version: !ruby/object:Gem::Requirement
+  requirements:
+  - - ">="
+    - !ruby/object:Gem::Version
+      version: '0'
+requirements: []
+rubyforge_project: 
+rubygems_version: 2.2.2
+signing_key: 
+specification_version: 4
+summary: LISP implementation in Ruby
+test_files: []