concatenative 0.1.0

data/CHANGELOG.rdoc

@@ -0,0 +1,4 @@
+== Version 0.1.0
+
+First preview release of Concatenative, implementing all the most basic operators and
+combinators.

data/LICENSE

@@ -0,0 +1,11 @@
+Copyright (c) 2009, Fabio Cevasco
+All rights reserved.
+
+- Redistribution and use in source and binary forms, with or without modification, are permitted provided that the following conditions are met:
+- Redistributions of source code must retain the above copyright notice, this list of conditions and the following disclaimer.
+- Redistributions in binary form must reproduce the above copyright notice, this list of conditions and the following disclaimer in the documentation and/or other materials provided with the distribution.
+Neither the name of the organization nor the names of its contributors may be used to endorse or promote products derived from this software without specific prior written permission.
+
+THIS SOFTWARE IS PROVIDED BY THE COPYRIGHT HOLDERS AND CONTRIBUTORS "AS IS" AND ANY EXPRESS OR IMPLIED WARRANTIES, INCLUDING, BUT NOT LIMITED TO, THE IMPLIED WARRANTIES OF MERCHANTABILITY AND FITNESS FOR A PARTICULAR PURPOSE ARE DISCLAIMED. IN NO EVENT SHALL THE COPYRIGHT OWNER OR CONTRIBUTORS BE LIABLE FOR ANY DIRECT, INDIRECT, INCIDENTAL, SPECIAL, EXEMPLARY, OR CONSEQUENTIAL DAMAGES (INCLUDING, BUT NOT LIMITED TO, PROCUREMENT OF SUBSTITUTE GOODS OR SERVICES; LOSS OF USE, DATA, OR PROFITS; OR BUSINESS INTERRUPTION) HOWEVER CAUSED AND ON ANY THEORY OF LIABILITY, WHETHER IN CONTRACT, STRICT LIABILITY, OR TORT (INCLUDING NEGLIGENCE OR OTHERWISE) ARISING IN ANY WAY OUT OF THE USE OF THIS SOFTWARE, EVEN IF ADVISED OF THE POSSIBILITY OF SUCH DAMAGE.
+
+

data/README.rdoc

@@ -0,0 +1,50 @@
+= Concatenative
+
+Concatenative implements a stack-based DSL to use concatenative programming in Ruby. Because of its high-level implementation, it is not nearly as fast as ordinary Ruby code, but it can be used to learn the basics of concatenative programming without having to learn another programming language.
+
+Concatenative's syntax is still valid Ruby code, but resambles a concatenative programming language like Joy (http://www.latrobe.edu.au/philosophy/phimvt/joy.html).
+
+== Installation
+
+The simplest method to install Concatenative is to install the gem:
+
+	gem install concatenative
+
+== Usage
+
+Initialization:
+	
+	require 'concatentive'
+
+Execute a Concatenative program:
+
+	concatenate(
+		10, 
+		[0, :==], 
+		[1, :+], 
+		[:DUP, 1, :-], 
+		[:*], 
+		:LINREC
+	)
+
+The program above returns the factorial of 10, computed using the linrec combinator. It is also possible to execute arrays directly and define concatenative programs as symbols (tey must be all uppercase).
+
+
+		:FACTORIAL.define [0, :==], [:POP, 1], [:DUP, 1, :- , :FACTORIAL, :*], :IFTE
+		[5, :FACTORIAL].execute
+
+The program above calculates the factorial of 5, using explicit recursion. 
+
+You can use all Ruby methods in Concatenative programs as well, making sure that the right number of arguments (and the method's receiver) are retrieved from the stack correctly. For this to work, Concatenative must know the arity of the method in advance, so the following rules are applied:
+
+* All operators have an arity of 1
+* All other method have an arity of 0
+* If a method has a different arity, you must specify it explicitly using the pipe (|) operator.
+
+Example:
+
+	concatenate(
+		"Goodbye, World!", /Goodbye/, "Hello", :sub|2
+	)
+
+The program above is equivalent to <tt>"Goodbye, World!".sub(/Goodbye/, "Hello")</tt>.

data/examples/benchmarks.rb

@@ -0,0 +1,38 @@
+#!/usr/bin/env ruby
+
+require 'benchmark'
+dir = File.dirname(File.expand_path(__FILE__))+'/../lib/' 
+require dir+"concatenative"
+
+n = 5_000
+
+def factorial(n)
+	(n == 0) ? 1 : factorial(n-1)
+end
+
+def fibonacci(n)
+	x1,x2 = 0, 1 
+	res = []
+	0.upto(n){ res << x1; x1+=x2; x1,x2= x2,x1}
+	res[res.length-1]
+end
+
+puts "======================================================================"
+puts "=====> Factorial of #{n}"
+puts "======================================================================"
+Benchmark.bmbm(20) do |x|
+  x.report("Standard Ruby Code:") { factorial n }
+	x.report("Concatenative (times):") { concatenate(n, 1, 1, :ROLLDOWN, [:DUP, [:*], :DIP, :succ], :TIMES, :POP) }
+  x.report("Concatenative (linrec):") { concatenate(n, [0, :==], [1, :+], [:DUP, 1, :-], [:*], :LINREC) }
+  x.report("Concatenative (primrec):") { concatenate(n, [1], [:*], :PRIMREC) }
+end
+puts
+puts
+puts "======================================================================"
+puts "=====> Fibonacci number for #{n}"
+puts "======================================================================"
+Benchmark.bmbm(20) do |x|
+  x.report("Standard Ruby Code:") { fibonacci n }
+	x.report("Concatenative (times):") { concatenate(n, 0, 1, :ROLLDOWN, [:DUP, [:+], :DIP, :SWAP], :TIMES, :POP) }
+end
+

data/examples/concatenative_cli.rb

@@ -0,0 +1,25 @@
+#!/usr/bin/env ruby
+
+dir = File.dirname(File.expand_path(__FILE__))+'/../lib/' 
+require dir+"concatenative"
+
+puts " ========================================="
+puts " => Concatenative CLI"
+puts "    Enter an item to push it on the stack"
+puts "    or 'exit' to end the program."
+puts " ========================================="
+loop do
+	print " => "
+	begin
+		Concatenative::System.process(instance_eval(gets))	
+	rescue Exception => e
+		if e.is_a? SystemExit then
+			puts " Exiting."
+			exit
+		end
+		print " ERROR: "
+		puts e.message
+	end
+	print " STACK: "
+	pp Concatenative::System::STACK
+end

data/lib/concatenative.rb

@@ -0,0 +1,78 @@
+require 'pp'
+
+libdir = File.dirname(File.expand_path(__FILE__))+'/concatenative/'
+
+class EmptyStackError < RuntimeError; end
+
+require libdir+'system'
+require libdir+'system_extensions'
+require libdir+'definitions'
+
+# The Concatenative module (included automatically when required) defines
+# some constants, the <tt>concatenate</tt> method and the RubyMessage class.
+module Concatenative
+
+	ARITIES = {}
+	DEBUG = false
+
+	# Specify the arity of a ruby method (regardless of the receiver).
+	def set_arity(meth, arity)
+		ARITIES[meth] = arity
+	end
+
+	# RubyMessage objects wrap a symbol and its arity 
+	# (returned by Symbol#|). 
+	class RubyMessage
+		attr_reader :name, :arity
+		def initialize(name, arity)
+			@name = name
+			@arity = arity
+		end
+	end
+
+	# Execute an array as a concatenative program (clears the STACK first).
+	def concatenate(*program)
+		System.execute program
+	end
+
+	# Execute an array as a concatenative program (clears the STACK first).
+	def self.concatenate(*program)
+		System.execute program
+	end
+		
+end
+
+include Concatenative
+
+# Setting some default arities
+set_arity :+, 1
+set_arity :*, 1
+set_arity :-, 1
+set_arity :/, 1
+set_arity :|, 1
+set_arity :&, 1
+set_arity :^, 1
+set_arity :%, 1
+set_arity :>, 1
+set_arity :<, 1
+set_arity :~, 1
+set_arity :**, 1
+set_arity :[], 1
+set_arity :[]=, 1
+set_arity :<<, 1
+set_arity :>>, 1
+set_arity :==, 1
+set_arity :'!=', 1
+set_arity :>=, 1
+set_arity :<=, 1
+set_arity :'%=', 1
+set_arity :'*=', 1
+set_arity :'+=', 1
+set_arity :'-=', 1
+set_arity :'/=', 1
+set_arity :'||', 1
+set_arity :'&&', 1
+set_arity :'-=', 1
+set_arity :===, 1
+set_arity :<=>, 1
+set_arity :'**=', 1

data/lib/concatenative/definitions.rb

@@ -0,0 +1,12 @@
+#!usr/bin/env ruby
+
+# Some definitions of common concatenative functions
+:REP.define :I, :DUP
+:SWONS.define :SWAP, :CONS
+:POPD.define [:POP], :DIP
+:DUPD.define [:DUP], :DIP
+:SWAPD.define [:SWAP], :DIP
+:SIP.define :DUPD, :SWAP, [:I], :DIP
+:ROLLUP.define :SWAP, [:SWAP], :DIP
+:ROLLDOWN.define [:SWAP], :DIP, :SWAP
+:ROTATE.define :SWAP, [:SWAP], :DIP, :SWAP

data/lib/concatenative/system.rb

@@ -0,0 +1,334 @@
+#!usr/bin/env ruby
+
+module Concatenative
+
+	# The System module includes the STACK constant, methods to interpret items pushed on 
+	# the stack and the implementations of all concatenative combinators and operators. 
+	module System
+		
+		STACK = []
+
+		# Executes an array as a concatenative program (clears the stack first).
+		def self.execute(array)
+			STACK.clear
+			array.each { |e| process e }
+			(STACK.length == 1) ? STACK[0] : STACK
+		end
+
+		# Processes an item (without clearning the stack).
+		def self.process(item)
+			case
+			when !item.is_a?(Symbol) && !item.is_a?(Concatenative::RubyMessage) then
+				_push item
+			when item.is_a?(Symbol) && item.definition then
+				item.definition.each {|e| process e}
+			else
+				call_function item
+			end
+		end
+
+		# Calls a function (defined using Symbol#define) or a Ruby method identified by item (a Symbol or RubyMessage).
+		def self.call_function(item)
+			name = "_#{item.to_s.downcase}".to_sym
+			if (item.to_s.upcase == item.to_s) && !ARITIES[item] then
+				respond_to?(name) ?	send(name) : raise(RuntimeError, "Unknown function: #{item}")
+			else
+				_push send_message(item)
+			end
+		end
+
+		# Calls a Ruby method, consuming elements from the stack according to its
+		# explicit or implicit arity.
+		def self.send_message(message)
+			raise EmptyStackError, "Empty stack" if STACK.empty?
+			case
+			when message.is_a?(Concatenative::RubyMessage) then
+				n = message.arity
+				method = message.name
+			when message.is_a?(Symbol) then
+				n = ARITIES[message] || 0
+				method = message
+			end
+			elements = []
+			(n+1).times { elements << _pop }
+			receiver = elements.pop
+			args = []
+			(elements.length).times { args << elements.pop }
+			begin
+				(args.length == 0)	? receiver.send(method) :	receiver.send(method, *args)
+			rescue Exception => e
+				raise RuntimeError, 
+					"Error when calling: #{receiver}##{method}(#{args.join(', ')}) [#{receiver.class}##{method}]"
+			end
+		end
+
+		# Operators & Combinators
+
+		# Clears the stack.
+		def self._clear
+			STACK.clear
+		end
+
+		# Pops an item out of the stack.
+		#
+		# A, B => A
+		def self._pop
+			raise EmptyStackError, "Empty stack" if STACK.empty?
+			STACK.pop
+		end
+
+		# Pushes an item on the stack.
+		#
+		# A => A, B
+		def self._push(element)
+			STACK.push element
+		end
+
+		# Prints the top stack item.
+		def self._put
+			puts STACK.last 
+		end
+
+		# Pushes a user-entered string on the stack. 
+		def self._get
+			_push gets
+		end
+
+		# Duplicates the top stack item.
+		#
+		# A => A, A
+		def self._dup
+			raise EmptyStackError, "Empty stack" if STACK.empty?
+			_push STACK.last
+		end
+
+		# Swaps the first two elements on the stack.
+		#
+		# A, B => B, A 
+		def self._swap
+			a = _pop
+			b = _pop
+			_push a
+			_push b
+		end
+
+		# Prepends an element to an Array.  
+		#
+		# [A], B => [A, B]
+		def self._cons
+			array = _pop
+			element = _pop
+			raise ArgumentError, "CONS: first element is not an Array." unless array.is_a? Array
+			_push array.insert(0, element)
+		end
+
+		# Concatenates two arrays.
+		#
+		# [A], [B] => [A, B]
+		def self._cat
+			array1 = _pop
+			array2 = _pop
+			raise ArgumentError, "CAT: first element is not an Array." unless array1.is_a? Array
+			raise ArgumentError, "CAT: first element is not an Array." unless array2.is_a? Array
+			_push array2.concat(array1)
+		end
+
+		# Returns the first element of an array.
+		#
+		# [A, B] => A
+		def self._first
+			array = _pop
+			raise ArgumentError, "FIRST: first element is not an Array." unless array.is_a? Array
+			raise ArgumentError, "FIRST: empty array." if array.length == 0
+			_push array.first
+		end
+
+		# Returns everything but the first element of an array.
+		#
+		# [A, B, C] => [B, C]
+		def self._rest
+			array = _pop
+			raise ArgumentError, "REST: first element is not an Array." unless array.is_a? Array
+			raise ArgumentError, "REST: empty array." if array.length == 0
+			array.delete_at 0
+			_push array
+		end
+
+		instance_eval do
+			alias _zap _pop
+			alias _concat _cat
+		end
+
+		# Saves A, executes P, pushes A back.
+		#
+		# A, [P] => B, A
+		def self._dip
+			program = _pop
+			raise ArgumentError, "DIP: first element is not an Array." unless program.is_a? Array
+			arg = _pop
+			program.unquote
+			_push arg
+		end
+
+		# Executes a quoted program.
+		#
+		# [P] => A
+		def self._i
+			program = _pop
+			raise ArgumentError, "I: first element is not an Array." unless program.is_a? Array
+			program.unquote
+		end
+
+		# Executes THEN if IF is true, otherwise executes ELSE.
+		#
+		# A, [IF], [THEN], [ELSE] => B
+		def self._ifte
+			_else = _pop
+			_then = _pop
+			_if = _pop
+			raise ArgumentError, "IFTE: first element is not an Array." unless _if.is_a? Array
+			raise ArgumentError, "IFTE: second element is not an Array." unless _then.is_a? Array
+			raise ArgumentError, "IFTE: third element is not an Array." unless _else.is_a? Array
+			snapshot = STACK.clone
+			_if.unquote
+			condition = _pop
+			STACK.replace snapshot
+			if condition then
+				_then.unquote
+			else
+				_else.unquote
+			end
+		end
+
+		# Quotes the top stack element.
+		#
+		# A => [A]
+		def self._unit
+			_push [_pop]
+		end
+
+		# Executes P for each element of A, pushes an array containing the results on the stack.
+		# 
+		# [A], [P] => [B]
+		def self._map
+			program = _pop
+			list = _pop
+			raise ArgumentError, "MAP: first element is not an Array." unless program.is_a? Array
+			raise ArgumentError, "MAP: second element is not an array." unless list.is_a? Array
+			_push []
+			list.map do |e| 
+				_push e
+				program.unquote
+				_unit
+				_cat
+			end
+		end
+
+		# Executes P for each element of A, pushes the results on the stack.
+		# 
+		# [A], [P] => B
+		def self._step
+			program = _pop
+			list = _pop
+			raise ArgumentError, "STEP: first element is not an Array." unless program.is_a? Array
+			raise ArgumentError, "STEP: second element is not an array." unless list.is_a? Array
+			list.map do |e| 
+				_push e
+				program.unquote
+			end
+		end
+
+		# If IF is true, executes THEN. Otherwise, executes REC1, recurses and then executes REC2.
+		#
+		# A, [IF], [THEN], [REC1], [REC2] => B
+		def self._linrec
+			rec2 = _pop
+			rec1 = _pop
+			_then = _pop
+			_if = _pop
+			raise ArgumentError, "LINREC: first element is not an Array." unless _if.is_a? Array
+			raise ArgumentError, "LINREC: second element is not an Array." unless _then.is_a? Array
+			raise ArgumentError, "LINREC: third element is not an Array." unless rec1.is_a? Array
+			raise ArgumentError, "LINREC: fourth element is not an Array." unless rec2.is_a? Array
+			snapshot = STACK.clone
+			_if.unquote
+			condition = _pop
+			STACK.replace snapshot
+			if condition then
+				_then.unquote
+			else
+				rec1.unquote
+				STACK.concat [_if, _then, rec1, rec2]
+				_linrec
+				rec2.unquote
+			end
+		end
+
+    #	Same as _linrec, but it is only necessary to specify THEN and REC2.
+		#
+		#	* REC1 = a program to reduce A to its zero value (0, [], "").
+		#	* IF = a condition to verify if A is its zero value (0, [], "") or not.
+		#
+		# A, [THEN], [REC2] => B 
+		def self._primrec
+			rec2 = _pop
+			_then = [:POP, _pop, :I]
+			arg = _pop
+			# Guessing IF
+			case 
+			when arg.respond_to?(:blank?) then
+				_if = [:blank?]
+			when arg.respond_to?(:empty?) then
+				_if = [:empty]
+			when arg.is_a?(Numeric) then
+				_if = [0, :==]
+			when arg.is_a?(String) then
+				_if = ["", :==]
+			else
+				raise ArgumentError, "PRIMREC: Unable to create IF element for #{arg} (#{arg.class})"
+			end
+			# Guessing REC1
+			case
+			when arg.respond_to?(:length) && arg.respond_to?(:slice) then
+				rec1 = [0, (arg.length-2), :slice|2]
+			when arg.respond_to?(:-) then
+				rec1 = [:DUP, 1, :-]
+			else
+				raise ArgumentError, "PRIMREC: Unable to create REC1 element for #{arg} (#{arg.class})"
+			end
+			STACK.concat [arg, _if, _then, rec1, rec2]
+			_linrec
+		end
+
+		# Executes P N times.
+		#
+		# N [P] => A
+		def self._times
+			program = _pop
+			n = _pop
+			raise ArgumentError, "TIMEs: second element is not an Array." unless program.is_a? Array
+			n.times { program.clone.unquote }
+		end
+
+		# While COND is true, executes P
+		#
+		# [P] [COND] => A
+		def self._while
+			program = _pop
+			cond = _pop
+			raise ArgumentError, "WHILE: first element is not an Array." unless cond.is_a? Array
+			raise ArgumentError, "WHILE: second element is not an Array." unless program.is_a? Array
+			snapshot = STACK.clone
+			cond.unquote
+			res = _pop
+			STACK.replace snapshot
+			if res then 
+				program.unquote
+				STACK.concat [cond, program]
+				_while
+			end
+		end
+		
+	end
+end
+

data/lib/concatenative/system_extensions.rb

@@ -0,0 +1,42 @@
+#!usr/bin/env ruby
+
+# The Array class is extended to allow execution of concatenative programs.
+class Array
+
+	# Executes a concatenative program (clears the STACK first).
+	def execute
+		Concatenative.concatenate *self
+	end
+	
+	# Processes each element of the array as a concatenative expression.
+	def unquote
+		each { |e| Concatenative::System.process e }
+	end
+end
+
+# The Symbol class is extended allowing explicit arities to be specified using the | operator,
+# concatenative function definition and execution.
+class Symbol
+
+	attr_reader :definition
+
+	# Assigns a quoted program (Array) as the symbol's definition.
+	def define(*array)
+		d = (array.length == 1) ? array.first : array
+		raise ArgumentError, "Argument for :#{self} definition is not a quoted program" unless d.is_a? Array
+		@definition = d
+	end
+
+	# Executes a concatenative function identified by the symbol (if it has been defined).
+	def execute
+		raise RuntimeError, ":#{self} is not defined" unless @definition
+		@definition.execute
+	end
+
+	# Specifies the arity of a ruby method. Example: :gsub|2 will return a RubyMessage with name = :gsub and
+	# arity = 2.
+	def |(arity)
+		Concatenative::RubyMessage.new self, arity
+	end
+
+end

data/spec/concatenative_spec.rb

@@ -0,0 +1,7 @@
+#!/usr/bin/env ruby
+
+dir = File.dirname(File.expand_path(__FILE__))
+
+require dir+"/system_extensions_spec"
+require dir+"/system_spec"
+require dir+"/definitions_spec"

data/spec/definitions_spec.rb

@@ -0,0 +1,44 @@
+#!usr/bin/env ruby
+
+dir = File.dirname(File.expand_path(__FILE__))+'/../lib/' 
+
+require dir+"concatenative"
+
+describe Concatenative do
+
+	it "should define SWONS" do
+		[[2], 1, :SWAP, :CONS].execute.should == [1,2]
+		[[2],1, :SWONS].execute.should == [[2],1, :SWAP, :CONS].execute
+		[[2],1, :SWONS].execute.should ==  [1,2]
+	end
+
+	it "should define POPD" do
+		[1,2,3, :POPD].execute.should == [1,3]
+	end
+
+	it "should define DUPD" do
+		[1,2,3, :DUPD].execute.should == [1,2,2,3]
+	end
+
+	it "should define SWAPD" do
+		[1,2,3, :SWAPD].execute.should == [2,1,3]
+	end
+
+	it "should define SIP" do
+		[[1,2],[3,4],:SIP].execute.should == [[1,2],3,4,[1,2]]
+	end
+
+	it "should define REP" do
+		[[2,3, :*], :REP, 2].execute.should == [6,6,2]
+	end
+	
+	it "should define ROLLUP, ROLLDOWN and ROTATE" do
+		a = [3,2,1]
+		(a.dup << :ROLLUP).execute.should == [1,3,2]
+		(a.dup << :ROLLDOWN).execute.should == [2,1,3]
+		(a.dup << :ROTATE).execute.should == [1,2,3]
+	end
+
+end
+
+

data/spec/system_extensions_spec.rb

@@ -0,0 +1,56 @@
+#!/usr/bin/env ruby
+
+dir = File.dirname(File.expand_path(__FILE__))+'/../lib/' 
+
+require dir+"concatenative"
+
+describe Array do
+	
+	it "should be executable" do
+		[2, 3, :+].execute.should == 5
+	end
+
+	it "should be dequotable" do
+		[2, 3, :*].unquote
+		Concatenative::System::STACK.last.should == 6
+	end
+
+end
+
+describe Kernel do
+
+	it "should concatenate programs" do
+		concatenate(
+			"Goodbye, World!",
+			/Goodbye/,
+			"Hello",
+			:sub|2
+		).should == "Hello, World!"
+		concatenate(
+			[1,2,3],
+			[:DUP, :*],
+			:STEP
+		).should == [1,4,9]
+	end
+	
+end
+
+describe Symbol do
+	
+	it "should allow definitions" do
+		lambda {:SQUARE.define [:DUP, :*]}.should_not raise_error
+	end
+
+	it "should be executable" do
+		:SQUARE.define [:DUP, :*]
+		[3, :SQUARE, 2, :+].execute.should == 11 
+	end
+
+	it "should allo arity to be specified" do
+		msg = :gsub|2
+		msg.is_a?(RubyMessage).should == true
+		msg.arity.should == 2
+		msg.name.should == :gsub
+	end
+
+end

data/spec/system_spec.rb

@@ -0,0 +1,107 @@
+#!/usr/bin/env ruby
+
+dir = File.dirname(File.expand_path(__FILE__))+'/../lib/' 
+
+require dir+"concatenative"
+
+describe Concatenative::System do
+
+	it "should expose CLEAR" do
+		[1,2,3,4,5, :CLEAR].execute.should == [] 
+	end
+
+	it "should expose POP " do
+		lambda { concatenate :POP }.should raise_error(EmptyStackError)
+		concatenate(1,2,3,4,:POP, :POP, :POP).should == 1
+	end
+
+	it "should expose DUP" do
+		lambda { concatenate :DUP }.should raise_error(EmptyStackError)
+		concatenate(1,2,:DUP).should == [1,2,2]
+	end
+
+	it "should expose SWAP" do
+		lambda { concatenate :SWAP }.should raise_error(EmptyStackError)
+		[1,3,2, :SWAP].execute.should == [1,2,3]
+	end
+
+	it "should expose CONS, FIRST and REST" do
+		[1, [2], :CONS].execute.should == [1,2]
+		[4, [3], [2, 1], :CONS, :CONS, 5, :SWAP, :CONS].execute.should == [5,4,[3],2,1]
+		[[1,2,3,4], :REST].execute.should == [2,3,4]
+		[[1,2,3,4], :FIRST].execute.should == 1
+		lambda { [1,2,3, :CONS].execute}.should raise_error
+	end
+
+	it "should expose CAT" do
+		[[1,2],[3,4], :CAT].execute.should == [1,2,3,4]
+	end
+
+	it "should handle method arities" do
+		# Fixnum#>: arity = 1
+		[2, 20, :>].execute.should == false	
+		["Test", /T/, 'F', :sub|2].execute.should == "Fest"	
+		[[1,2,3],:join].execute.should == "123"
+		[[1,2,3],'|',:join|1].execute.should == "1|2|3"
+	end
+
+	it "should expose I" do
+		[2, 5, [:*, 6,:+], :I].execute.should == 16
+		# Check other definitions of :I according to http://tunes.org/~iepos/joy.html
+		[2, 5, [:*, 6,:+], :DUP, :DIP, :ZAP].execute.should == 16
+		[2, 5, [:*, 6,:+], [[]], :DIP, :DIP, :ZAP].execute.should == 16
+		[2, 5, [:*, 6,:+], [[]], :DIP, :DIP, :DIP].execute.should == 16
+	end
+
+	it "should expose DIP" do
+		[2, 3, 4, [:+], :DIP].execute.should == [5, 4]
+	end
+
+	it "should expose UNIT" do
+		[2, 3, :UNIT].execute.should == [2, [3]]
+	end
+
+	it "should expose IFTE" do
+		t = [1000, :>], [2, :/], [3, :*], :IFTE
+		[1200, *t].execute.should == 600
+		[800, *t].execute.should == 2400
+		# Test factorial with explicit recursion
+		:FACTORIAL.define [0, :==], [:POP, 1], [:DUP, 1, :- , :FACTORIAL, :*], :IFTE
+		[5, :FACTORIAL].execute.should == 120
+	end
+
+	it "should expose MAP" do
+		[[1,2,3,4], [:DUP, :*], :MAP, 1].execute.should == [[1,4,9,16], 1]
+	end
+
+	it "should expose STEP" do
+		[[1,2,3,4], [:DUP, :*], :STEP, 1].execute.should == [1,4,9,16, 1]
+	end
+
+	it "should expose LINREC" do
+		# factorial
+		[5, [0, :==], [1, :+], [:DUP, 1, :-], [:*], :LINREC].execute.should == 120
+	end
+
+	it "should expose PRIMREC" do
+		# factorial
+		[5, [1], [:*], :PRIMREC].execute.should == 120
+	end
+
+	it "should expose TIMES" do
+		[4, [5, 2, :*], :TIMES].execute.should == [10, 10, 10, 10]	
+		# factorial
+		[5, 1, 1, :ROLLDOWN, [:DUP, [:*], :DIP, :succ], :TIMES, :POP].execute.should == 120
+		x1,x2 = 0, 1 
+		res = []
+		0.upto(50){ res << x1; x1+=x2; x1,x2= x2,x1} 
+		# Fibonacci number
+		[50, 0, 1, :ROLLDOWN, [:DUP, [:+], :DIP, :SWAP], :TIMES, :POP].execute.should == res[res.length-1]
+	end
+
+	it "should expose WHILE" do
+		# gcd
+		[40, 25, [0, :>], [:DUP, :ROLLUP, :remainder|1], :WHILE, :POP].execute.should == 5
+	end
+
+end

metadata

@@ -0,0 +1,71 @@
+--- !ruby/object:Gem::Specification 
+name: concatenative
+version: !ruby/object:Gem::Version 
+  version: 0.1.0
+platform: ruby
+authors: 
+- Fabio Cevasco
+autorequire: 
+bindir: bin
+cert_chain: []
+
+date: 2009-03-29 00:00:00 +01:00
+default_executable: 
+dependencies: []
+
+description: Concatenative can be used to program in Ruby using a concatenative syntax through ordinary arrays. Because of its high-level implementation, it is not nearly as fast as standard Ruby code.
+email: h3rald@h3rald.com
+executables: []
+
+extensions: []
+
+extra_rdoc_files: 
+- README.rdoc
+- LICENSE
+- CHANGELOG.rdoc
+files: 
+- lib/concatenative
+- lib/concatenative/system_extensions.rb
+- lib/concatenative/definitions.rb
+- lib/concatenative/system.rb
+- lib/concatenative.rb
+- examples/concatenative_cli.rb
+- examples/benchmarks.rb
+- spec/concatenative_spec.rb
+- spec/definitions_spec.rb
+- spec/system_spec.rb
+- spec/system_extensions_spec.rb
+- README.rdoc
+- LICENSE
+- CHANGELOG.rdoc
+has_rdoc: true
+homepage: http://rubyforge.org/projects/concatenative
+post_install_message: 
+rdoc_options: 
+- --main
+- README.rdoc
+- --exclude
+- spec
+require_paths: 
+- lib
+required_ruby_version: !ruby/object:Gem::Requirement 
+  requirements: 
+  - - ">="
+    - !ruby/object:Gem::Version 
+      version: "0"
+  version: 
+required_rubygems_version: !ruby/object:Gem::Requirement 
+  requirements: 
+  - - ">="
+    - !ruby/object:Gem::Version 
+      version: "0"
+  version: 
+requirements: []
+
+rubyforge_project: concatenative
+rubygems_version: 1.2.0
+signing_key: 
+specification_version: 2
+summary: A Ruby DSL for concatenative programming.
+test_files: 
+- spec/concatenative_spec.rb