bus-scheme 0.7.5 → 0.7.6

data/COPYING

@@ -1,4 +1,4 @@
-Copyright (c) 2007, Phil Hagelberg
+Copyright (c) 2007 - 2008, Phil Hagelberg
 All rights reserved.
 
 Redistribution and use in source and binary forms, with or without

data/Manifest.txt

@@ -1,8 +1,10 @@
 COPYING
 Manifest.txt
+R5RS.diff
 README.txt
 Rakefile
 bin/bus
+examples/fib.scm
 lib/array_extensions.rb
 lib/bus_scheme.rb
 lib/cons.rb
@@ -12,10 +14,20 @@ lib/object_extensions.rb
 lib/parser.rb
 lib/primitives.rb
 lib/scheme/core.scm
+lib/scheme/list.scm
+lib/scheme/predicates.scm
+lib/scheme/test.scm
+lib/stack_frame.rb
 test/foo.scm
 test/test_core.rb
 test/test_eval.rb
 test/test_helper.rb
 test/test_lambda.rb
+test/test_list_functions.scm
 test/test_parser.rb
+test/test_predicates.scm
 test/test_primitives.rb
+test/test_primitives.scm
+test/test_stack_frame.rb
+test/tracer.scm
+tutorials/getting_started.html

data/R5RS.diff

@@ -0,0 +1,30 @@
+= Differences between Bus Scheme and R5RS
+
+== Parsing
+
+Unsupported:
+* Quasiquote, unquote, unquote-splice
+* Backslash in strings
+* Character literals
+* Alternate-base numbers
+* Alternate define lambda forms
+
+* []{}| should be reserved
+
+== Functions
+
+=== Basic
+Unsupported:
+* cond
+* case
+* let*
+* letrec
+* do
+* delay
+* read - uses Ruby's gets
+
+== General
+Tail-recursion
+
+Continuations
+

data/README.txt

@@ -1,4 +1,4 @@
-Bus Scheme
+= Bus Scheme
     by Phil Hagelberg (c) 2007 - 2008
     http://bus-scheme.rubyforge.org
 
@@ -6,63 +6,122 @@ Bus Scheme
 
 Bus Scheme is a Scheme written in Ruby, but implemented on the bus!
 Every programmer must implement Scheme as a rite of passage; this is
-mine. Note that all the implementation of Bus Scheme must be written
-while on a bus. Documentation, tests, and administrivia may be
-accomplished elsewhere, but all actual implementation code is strictly
-bus-driven. Patches are welcome as long as they were written while
-riding a bus. (If your daily commute does not involve a bus but you
-want to submit a patch, we may be able to work something out regarding
-code written on trains, ferries, or perhaps even carpool lanes.) Bus
-Scheme is primarily a toy; using it for anything serious is (right
-now) ill-advised.
+mine. Note that at least half of the implementation of Bus Scheme must
+be written while on a bus. Documentation, tests, and administrivia may
+be accomplished elsewhere, but the majority of actual implementation
+code is strictly bus-driven. Bus Scheme is primarily a toy; using it
+for anything serious is (right now) ill-advised.
 
 Bus Scheme aims for general Scheme usefulness optimized for learning
-and fun. It's not targeting R5RS or anything like that.
+and fun. It's loosely targeting R5RS, but varies in huge ways. (For
+the purposes of this project we pretend that R6RS never happened.) See
+the file R5RS.diff for ways in which Bus Scheme differs from the
+standard, both things that are yet unimplemented and things that are
+intentionally different.
 
-== Install
+== Usage
 
-* sudo gem install bus-scheme
+$ bus # drop into the REPL
 
-For the source:
+$ bus -e "(do some stuff)"
 
-* git clone git://git.caboo.se/bus_scheme.git
+$ bus foo.scm # load a file
 
-== Usage
+== Tutorial
 
-$ bus # drop into a repl
+See http://technomancy.us/104 for a "Getting Started" tutorial.
 
-$ bus -e "(do some stuff)"
+== What makes Bus Scheme different?
 
-$ bus foo.scm # load a file
+Well, for starters it's implemented on the bus. No other Scheme
+implementation can claim this. Here are a few other things that set
+Bus Scheme apart:
+
+=== Flexible calling syntax
+
+Taking a hint from Arc, Bus Scheme allows you to use the notation
+(mylist n) to access the nth place of the mylist list instead of (nth
+mylist n) or the (myhash key) notation to access the slot in myhash
+corresponding to the value of key instead of (gethash myhash key). 
+TODO: This notation is flexible, and other data types may have
+their own "call behaviour" specified.
+
+=== Web functionality
+
+Planned: Web and RESTful application development are part of the
+package. Bus Scheme uses the Rack library to allow scheme programs to
+serve web applications. Representations of data can be easily
+translated between s-expressions, HTML, and JSON.
+
+=== Written in a high-level language
+
+Bus Scheme is written in Ruby, which means anyone with experience in
+high-level dynamic languages (like, oh, I don't know... Scheme?)
+should be right at home poking around at the implementation. Using
+Ruby allows the implementation code to remain compact and concise. Bus
+Scheme should run on Ruby 1.8, Ruby 1.9, and Rubinius at least. Bus
+Scheme also allows you to drop into Ruby when that's convenient. TODO:
+allow real inline Ruby blocks instead of access via a function call.
+
+=== Test-Driven
+
+Bus Scheme is written in an entirely test-driven manner. As much as
+possible, it tries to keep its tests written in Scheme itself, so it
+includes a fairly comprehensive testing suite and encourages programs
+to be written test-first.
+
+== Install
+
+* sudo gem install bus-scheme
+
+For the source:
+
+* git clone git://github.com/technomancy/bus-scheme.git
 
 == Todo
 
 Bus Scheme is currently missing pieces of functionality:
 
 === Parser
- * parse character literals
- ** alternate define lambda forms
- ** parse dotted cons cells
- *** look up and enforce rules for identifier names
+* character literals
+* multiline strings
+* regular expressions
 
 === General
- * lambda args should get passed in as lists by default, not vectors/arrays
- * (lambda args body) for rest args
- * stack traces on error plz
- ** optimize tail call recursion
- ** some kind of load path?
+* filter stacktrace
+* continuations
+* macros
 
 Failing tests for some of these are already included (commented out,
 mostly) in the relevant test files.
 
 === Long Term (post 1.0)
- * continuations (?!?)
- * compile to Rubinius bytecode
- * parse rationals, scientific, complex, and polar complex numbers
+* web functions (defresource and friends)
+* (lambda (arg1 arg2 . args) body) for rest args
+* string interpolation
+* escape sequences in strings
+* Ruby blocks inline?
+* XML literals?
+* optimize tail call recursion
+* compile to Rubinius bytecode
+* custom call behaviour
+* parse non-decimal base numbers
+* parse rationals, scientific, complex, and polar complex numbers
 
 == Requirements
 
-Bus Scheme should run on (at least) Ruby 1.8, Ruby 1.9, and Rubinius.
+Bus Scheme should run on (at least) Ruby 1.8, Ruby 1.9, and
+Rubinius. Any support for Windows is entirely accidental.
+
+== Contributing
+
+Patches are welcome especially if they were written while riding a
+bus. If your daily commute does not involve a bus but you want to
+submit a patch, we may be able to work something out regarding code
+written on trains, ferries, or perhaps even carpool lanes.
+
+Join the mailing list to ask questions and discuss:
+http://rubyforge.org/mail/?group_id=5094
 
 == Bonus Fact
 

data/Rakefile

@@ -5,13 +5,15 @@ require 'hoe'
 require './lib/bus_scheme.rb'
 require 'rake/testtask'
 
+BIN = ENV['bin'] || "~/src/rubinius/shotgun/rubinius"
+
 Hoe.new('bus-scheme', BusScheme::VERSION) do |p|
   p.rubyforge_name = 'bus-scheme'
   p.author = 'Phil Hagelberg'
   p.email = 'technomancy@gmail.com'
   p.summary = 'Bus Scheme is a Scheme in Ruby, imlemented on the bus.'
   p.description = p.paragraphs_of('README.txt', 2..5).join("\n\n")
-  p.url = p.paragraphs_of('README.txt', 0).first.split(/\n/)[1..-1]
+  p.url = 'http://bus-scheme.rubyforge.org'
   p.remote_rdoc_dir = ''
 end
 
@@ -28,12 +30,37 @@ end
 
 desc "Show todo items"
 task :todo do
-  puts File.read('README.txt').match(/== Todo(.*)== Requirements/m)[1].split("\n").grep(/^( \*|===)/).join("\n")
+  puts File.read('README.txt').match(/== Todo(.*)== Requirements/m)[1].split("\n").grep(/^(\*|===)/).join("\n")
+  puts "Within the code:"
+  system "grep -r TODO lib"
 end
 
 desc "Show tests that have been commented out"
 task :commented_tests do
   Dir.glob('test/test_*.rb').each do |file|
-    puts File.read(file).grep(/^\s*#\s*def (test_[^ ]*)/)
+    puts File.read(file).grep(/^\s*#+\s*def (test_[^ ]*)/)
+  end
+
+  Dir.glob('test/test_*.scm').each do |file|
+    puts File.read(file).grep(/^\s*;+\s*\(assert/)
+  end
+end
+
+# TODO: use multiruby, duh
+desc "Run ruby tests in Rubinius"
+task :rbx_test do
+  if ENV['test']
+    system "#{BIN} test/test_#{ENV['test']}.rb"
+  else
+    system "#{BIN} -w -Ilib:test -e '#{Dir.glob('test/test_*.rb').map{ |f| "require \"" + f + "\" "}.join('; ')}'"
   end
 end
+
+desc 'Run tests written in Scheme'
+task :scheme_test do
+  Dir.glob('test/test_*.scm').each do |file|
+    BusScheme.load(file)
+  end
+end
+
+task :default => [:test, :scheme_test]

data/bin/bus

@@ -8,7 +8,7 @@ if ARGV.empty?
 elsif ARGV.first == '-e' and ARGV.length == 2
   puts BusScheme.eval_string(ARGV[1])
 elsif ARGV.length == 1 and File.exist?(ARGV.first)
-  puts BusScheme.eval_form([:load, ARGV.first])
+  puts BusScheme.eval_string("(load \"#{ARGV.first}\")")
 else
   puts "Bus Scheme: a scheme interpreter written on the bus.
 Usage: bus [file | -e \"form\"]

data/examples/fib.scm

@@ -0,0 +1,6 @@
+;; Fibonacci sequence
+(define fib (lambda (x)
+	      (if (< x 3)
+		  1
+		  (+ (fib (- x 1))
+		     (fib (- x 2))))))

data/lib/array_extensions.rb

@@ -7,15 +7,18 @@ class Array
   alias_method :car, :first
   alias_method :cdr, :rest
 
-  def to_list
-    if self.cdr.empty?
-      BusScheme::Cons.new(self.car, nil)
+  def to_list(recursive = false)
+    self[0] = first.sexp(recursive) if recursive
+
+    if self.cdr.nil? or self.cdr.empty?
+      BusScheme::Cons.new(car, nil)
     else
-      BusScheme::Cons.new(self.car, self.cdr.to_list)
+      BusScheme::Cons.new(car, self.cdr.sexp(recursive))
     end
   end
 
-  alias_method :to_sexp, :to_list
+  alias_method :sexp, :to_list
+  include Callable
 end
 
 module Enumerable # for 1.9, zip is defined on Enumerable

data/lib/bus_scheme.rb

@@ -1,40 +1,56 @@
 #!/usr/bin/env ruby
 
-begin
-  require 'readline'
-  require 'yaml'
-rescue LoadError
-end
-
 $LOAD_PATH << File.dirname(__FILE__)
+require 'readline'
 require 'object_extensions'
 require 'array_extensions'
+
 require 'parser'
 require 'eval'
-require 'primitives'
 require 'cons'
 require 'lambda'
+require 'stack_frame'
+require 'primitives'
+
+begin
+  require 'web'
+  require 'xml'
+rescue LoadError
+  puts "Could not load web functionality."
+end
 
 module BusScheme
-  VERSION = "0.7.5"
+  VERSION = "0.7.6"
 
-  SYMBOL_TABLE = {}.merge(PRIMITIVES).merge(SPECIAL_FORMS)
   PROMPT = '> '
-
-  # symbol special form predicate
-  def self.special_form?(symbol)
-    SPECIAL_FORMS.has_key?(symbol)
-  end
+  INCOMPLETE_PROMPT = ' ... '
+  BusScheme['load-path'.sym] = Cons.new("#{File.dirname(__FILE__)}/scheme/",
+                                        Cons.new(File.expand_path('.'), nil))
   
+  class BusSchemeError < StandardError; end
+  class ParseError < BusSchemeError; end
+  class EvalError < BusSchemeError; end
+  class LoadError < BusSchemeError; end
+  class IncompleteError < BusSchemeError; end
+  class ArgumentError < BusSchemeError; end
+  class AssertionFailed < BusSchemeError; end
+
   # Read-Eval-Print-Loop
   def self.repl
     loop do
       puts begin
              input = Readline.readline(PROMPT)
              exit if input.nil? # only Ctrl-D produces nil here it seems
-             BusScheme.eval_string input
+             begin # allow for multiline input
+               result = BusScheme.eval_string(input).inspect
+             rescue IncompleteError
+               input += "\n" + Readline.readline(INCOMPLETE_PROMPT)
+               retry
+             end
+             Readline::HISTORY.push(input)
+             result
            rescue Interrupt
-             'Type "(quit)" to leave Bus Scheme.'
+             'Type "(quit)" or press Ctrl-D to leave Bus Scheme.'
            rescue BusSchemeError => e
              "Error: #{e}"
            rescue StandardError => e
@@ -44,5 +60,30 @@ module BusScheme
     end
   end
 
-  ['core'].each { |file| SYMBOL_TABLE[:load].call("#{File.dirname(__FILE__)}/scheme/#{file}.scm") }
+  # Load a file if on the load path or absolute
+  def self.load(filename)
+    begin
+      loaded_files.push filename
+      eval_string File.read(add_load_path(filename))
+      loaded_files.pop
+    rescue
+      loaded_files.pop
+      raise
+    end
+  end
+
+  def self.add_load_path(filename, load_path = BusScheme['load-path'.sym])
+    return filename if filename.match(/^\//) or File.exist? filename
+    raise LoadError, "File not found: #{filename}" if load_path.empty?
+    return load_path.car + '/' + filename if File.exist? load_path.car + '/' + filename
+    return add_load_path(filename, load_path.cdr)
+  end
+
+  # For stack traces
+  def self.loaded_files
+    (@loaded_files ||= ["(eval)"])
+  end
+
+  ['core.scm', 'test.scm', 'list.scm', 'predicates.scm'
+  ].each { |f| load(f) }
 end

data/lib/cons.rb

@@ -1,18 +1,43 @@
 module BusScheme
   class Cons
     attr_accessor :car, :cdr
-    
-    def initialize(car, cdr = nil)
+
+    # TODO: figure out default values
+    def initialize(car, cdr)
       @car, @cdr = [car, cdr]
     end
 
     def ==(other)
-      @car == other.car and @cdr == other.cdr
+      other.respond_to?(:car) and @car == other.car and
+        other.respond_to?(:cdr) and @cdr == other.cdr
     end
 
     alias_method :first, :car
     alias_method :rest, :cdr
 
+    def length
+      return 0 if @car.nil? and @cdr.nil?
+      return 1 if @cdr.nil?
+      return 2 if !@cdr.respond_to? :length
+      1 + @cdr.length
+    end
+
+    alias_method :size, :length
+    def last
+      # TODO: do this list-style
+      self.to_a.last
+    end
+    
+    def map(mapper = nil, &block)
+      mapper ||= block
+      Cons.new(mapper.call(@car), @cdr ? @cdr.map(mapper) : @cdr)
+    end
+
+    def each(&block)
+      yield @car
+      @cdr.each(&block) if @cdr && @cdr.respond_to?(:each)
+    end
+    
     def to_a
       if @cdr.respond_to? :to_a
         [@car] + @cdr.to_a
@@ -23,6 +48,10 @@ module BusScheme
       end
     end
 
+    def empty?
+      @car.nil? && @cdr.nil?
+    end
+
     def inspect(open = '(', close = ')')
       str = open + @car.inspect
       if @cdr.nil?
@@ -33,9 +62,20 @@ module BusScheme
         str + ' . ' + @cdr.inspect + close
       end
     end
+
+    def to_list
+      self
+    end
+
+    # allows for (mylist 4) => (nth mylist 4)
+    def call(nth)
+      nth == 0 ? @car : @cdr.call(nth - 1)
+    end
+    include Callable
   end
 
   def cons(car, cdr = nil)
     Cons.new(car, cdr)
   end
+  module_function :cons
 end