yarlisp 0.0.0

data/.rvmrc

@@ -0,0 +1 @@
+rvm use 1.9.2@yarlisp

data/Gemfile

@@ -0,0 +1,3 @@
+source 'http://rubygems.org'
+
+gemspec

data/Gemfile.lock

@@ -0,0 +1,24 @@
+PATH
+  remote: .
+  specs:
+    yarlisp (0.0.1)
+
+GEM
+  remote: http://rubygems.org/
+  specs:
+    diff-lcs (1.1.3)
+    rspec (2.7.0)
+      rspec-core (~> 2.7.0)
+      rspec-expectations (~> 2.7.0)
+      rspec-mocks (~> 2.7.0)
+    rspec-core (2.7.0)
+    rspec-expectations (2.7.0)
+      diff-lcs (~> 1.1.2)
+    rspec-mocks (2.7.0)
+
+PLATFORMS
+  ruby
+
+DEPENDENCIES
+  rspec
+  yarlisp!

data/README.md

@@ -0,0 +1,93 @@
+# YARLISP #
+
+## What is it and a brief history. ##
+
+Yet Another Ruby Lisp.
+
+(I assume that other people have implemented Lisp in ruby so...)
+
+After reading [McCarthy's Paper][paper] for one of the 
+[Boston Software Crafstmanship Meetups][bossoftcraft] I decided to try to expand my limited
+knowledge of Ruby by implmenting this Lisp.
+
+That attempt failed - I even deleted the GitHub repository for it.  
+
+I hope that this attempt works better.
+
+## The relevant parts of the paper: ##
+
+Snippets from McCarthy's paper:
+
+The Elementary S-functions and Predicates. We introduce the following 
+functions and predicates:
+
+1. atom. `atom[x]` has the value of T or F according to whether x is an atomic symbol. Thus
+
+        atom [X] = T
+        atom [(X . A)] = F
+
+2. eq. `eq [x;y]` is defined if and only if both x and y are atomic.  `eq [x; y] = T` if x and y are the same symbol, and `eq [x; y] = F` otherwise. Thus
+    
+        eq [X; X] = T
+        eq [X; A] = F 
+        eq [X; (X . A)] is undefined
+
+3. car. `car[x]` is defined if and only if x is not atomic.  
+
+        car [(e1 . e2)] = e1 
+
+Thus `car [X]` is undefined.
+    
+        car [(X . A)] = X
+        car [((X . A) . Y )] = (X . A)
+
+4. cdr. `cdr [x]` is also defined when x is not atomic. We have `cdr [(e1 . e2)]= e2`. Thus cdr [X] is undefined.
+
+        cdr [(X . A)] = A
+        cdr [((X . A) . Y )] = Y
+
+5. cons. `cons [x; y]` is defined for any x and y. We have `cons [e1; e2] = (e1 . e2`). Thus
+
+        cons [X; A] = (X A)
+        cons [(X . A); Y ] = ((X . A) Y )
+
+car, cdr, and cons are easily seen to satisfy the relations
+
+        car [cons [x; y]] = x
+        cdr [cons [x; y]] = y
+        cons [car [x]; cdr [x]] = x, provided that x is not atomic.
+
+The S-function apply is defined by
+
+    apply[f; args] = eval[cons[f; appq[args]];NIL],
+    
+where
+
+    appq[m] = [null[m] ! NIL; T ! cons[list[QUOTE; car[m]]; appq[cdr[m]]]]
+
+and
+
+    eval[e; a] = [
+        atom [e] ! assoc [e; a];
+        atom [car [e]] ! [
+            eq [car [e]; QUOTE] ! cadr [e];
+            eq [car [e]; ATOM] ! atom [eval [cadr [e]; a]];
+            eq [car [e]; EQ] ! [eval [cadr [e]; a] = eval [caddr [e]; a]];
+            eq [car [e]; COND] ! evcon [cdr [e]; a];
+            eq [car [e]; CAR] ! car [eval [cadr [e]; a]];
+            eq [car [e]; CDR] ! cdr [eval [cadr [e]; a]];
+            eq [car [e]; CONS] ! cons [eval [cadr [e]; a]; eval [caddr [e]; a]]; 
+            T ! eval [cons [assoc [car [e]; a]; evlis [cdr [e]; a]]; a]];
+        eq [caar [e]; LABEL] ! eval [cons [caddar [e]; cdr [e]]; cons [list [cadar [e]; car [e]; a]];
+        eq [caar [e]; LAMBDA] ! eval [caddar [e]; append [pair [cadar [e]; evlis [cdr [e]; a]; a]]]
+
+and
+
+    evcon[c; a] = [eval[caar[c]; a] ! eval[cadar[c]; a]; T ! evcon[cdr[c]; a]]
+
+and
+
+    evlis[m; a] = [null[m] ! NIL; T ! cons[eval[car[m]; a]; evlis[cdr[m]; a]]]
+
+[paper]: <http://www-formal.stanford.edu/jmc/recursive.pdf>
+[bossoftcraft]: <http://groups.google.com/group/boston-software-craftsmanship?pli=1>

data/Rakefile

@@ -0,0 +1 @@
+require "bundler/gem_tasks"

data/lib/yarlisp.rb

@@ -0,0 +1,5 @@
+require "yarlisp/version"
+
+module Yarlisp
+  # Your code goes here...
+end

data/lib/yarlisp/version.rb

@@ -0,0 +1,3 @@
+module Yarlisp
+  VERSION = "0.0.0"
+end

data/script/test

@@ -0,0 +1,35 @@
+#!/bin/bash
+#
+# From Destroy All Software screencast #10, at:
+# http://destroyallsoftware.com/screencasts/catalog/fast-tests-with-and-without-rails
+#
+# Put this in the script/ directory of your Rails app, then run it with a spec
+# filename. If the spec uses spec_helper, it'll be run inside Bundler.
+# Otherwise, it'll be run directly with whatever `rspec` executable is on the
+# path.
+
+set -e
+
+need_rails=1
+
+if [ $# -gt 0 ]; then # we have args
+    filename=$1
+    # Remove trailing line numbers from filename, e.g. spec/my_spec.rb:33
+    grep_filename=`echo $1 | sed 's/:.*$//g'`
+
+    (set +e; grep -r 'spec_helper' $grep_filename) > /dev/null
+    if [ $? -eq 1 ]; then # no match; we have a stand-alone spec
+        need_rails=''
+    fi
+else # we have no args
+    filename='spec'
+fi
+
+command='rspec'
+
+if [ $need_rails ]; then
+    command="ruby -S bundle exec $command"
+fi
+
+RAILS_ENV=test $command $filename
+

data/yarlisp.gemspec

@@ -0,0 +1,24 @@
+# -*- encoding: utf-8 -*-
+$:.push File.expand_path("../lib", __FILE__)
+require "yarlisp/version"
+
+Gem::Specification.new do |s|
+  s.name        = "yarlisp"
+  s.version     = Yarlisp::VERSION
+  s.authors     = ["Mark Simpson"]
+  s.email       = ["verdammelt@gmail.com"]
+  s.homepage    = ""
+  s.summary     = %q{A toy implementation of McCarthy's LISP in Ruby.}
+  s.description = %q{I must assume that someone has already implmented Lisp in Ruby and thus I name this 'Yet Another Ruby Lisp"}
+
+  s.rubyforge_project = "yarlisp"
+
+  s.files         = `git ls-files`.split("\n")
+  s.test_files    = `git ls-files -- {test,spec,features}/*`.split("\n")
+  s.executables   = `git ls-files -- bin/*`.split("\n").map{ |f| File.basename(f) }
+  s.require_paths = ["lib"]
+
+  # specify any dependencies here; for example:
+  s.add_development_dependency "rspec"
+  # s.add_runtime_dependency "rest-client"
+end

metadata

@@ -0,0 +1,66 @@
+--- !ruby/object:Gem::Specification
+name: yarlisp
+version: !ruby/object:Gem::Version
+  version: 0.0.0
+  prerelease: 
+platform: ruby
+authors:
+- Mark Simpson
+autorequire: 
+bindir: bin
+cert_chain: []
+date: 2011-10-19 00:00:00.000000000Z
+dependencies:
+- !ruby/object:Gem::Dependency
+  name: rspec
+  requirement: &2157015400 !ruby/object:Gem::Requirement
+    none: false
+    requirements:
+    - - ! '>='
+      - !ruby/object:Gem::Version
+        version: '0'
+  type: :development
+  prerelease: false
+  version_requirements: *2157015400
+description: I must assume that someone has already implmented Lisp in Ruby and thus
+  I name this 'Yet Another Ruby Lisp"
+email:
+- verdammelt@gmail.com
+executables: []
+extensions: []
+extra_rdoc_files: []
+files:
+- .rvmrc
+- Gemfile
+- Gemfile.lock
+- README.md
+- Rakefile
+- lib/yarlisp.rb
+- lib/yarlisp/version.rb
+- script/test
+- yarlisp.gemspec
+homepage: ''
+licenses: []
+post_install_message: 
+rdoc_options: []
+require_paths:
+- lib
+required_ruby_version: !ruby/object:Gem::Requirement
+  none: false
+  requirements:
+  - - ! '>='
+    - !ruby/object:Gem::Version
+      version: '0'
+required_rubygems_version: !ruby/object:Gem::Requirement
+  none: false
+  requirements:
+  - - ! '>='
+    - !ruby/object:Gem::Version
+      version: '0'
+requirements: []
+rubyforge_project: yarlisp
+rubygems_version: 1.8.10
+signing_key: 
+specification_version: 3
+summary: A toy implementation of McCarthy's LISP in Ruby.
+test_files: []