concatenative 0.1.0 → 0.2.0

data/lib/concatenative/system_extensions.rb

@@ -1,42 +1,80 @@
 #!usr/bin/env ruby
 
+module Kernel
+
+	# Execute an array as a concatenative program (clears the STACK first).
+	def concatenate(*program)
+		Concatenative.execute program
+	end
+
+	# Specify the arity of a ruby method (regardless of the receiver).
+	def set_arity(meth, arity)
+		Concatenative::ARITIES[meth] = arity
+	end
+
+end
+
 # The Array class is extended to allow execution of concatenative programs.
 class Array
 
-	# Executes a concatenative program (clears the STACK first).
+	# Execute self as a concatenative program (clears the STACK first).
 	def execute
-		Concatenative.concatenate *self
+		Concatenative.execute self
 	end
-	
+
 	# Processes each element of the array as a concatenative expression.
-	def unquote
-		each { |e| Concatenative::System.process e }
+	def ~
+		each { |e| Concatenative.process e }
 	end
+
 end
 
 # The Symbol class is extended allowing explicit arities to be specified using the | operator,
-# concatenative function definition and execution.
+# word definition and execution.
 class Symbol
 
+	attr_accessor :namespace
 	attr_reader :definition
+	attr_writer :name
 
 	# 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
+	def <=(item)
+		definition = item.respond_to?(:definition) ? item.definition : item
+		raise(RuntimeError, "'#{self}' is already defined.") if self.defined?
+		raise(RuntimeError, "Cannot redefine a Ruby word") if @namespace == :ruby
+		raise(RuntimeError, "Cannot redefine a Kernel word") if @namespace == :kernel
+		case 
+		when item.is_a?(Symbol) then
+			@definition = [item]
+		when item.is_a?(Array) then
+			@definition = item
+		else
+			raise ArgumentError, "Invalid definition for '#@namespace/#@name'"
+		end
 	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
+	# 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.name, arity)
 	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
+	# Returns the symbol's name (without namespace).
+	def name
+		@name||self
+	end
+
+	# Returns whether the symbol is defined or not.
+	def defined?
+		@definition != nil
+	end
+
+	# Concatenates two symbols (used for namespaces).
+	def /(sym)
+		s = "#{self}/#{sym}".to_sym
+		s.namespace = self
+		s.name = sym
+		s
 	end
 
 end

data/spec/concatenative_spec.rb

@@ -1,7 +1,25 @@
 #!/usr/bin/env ruby
 
-dir = File.dirname(File.expand_path(__FILE__))
+dir = File.dirname(File.expand_path(__FILE__))+'/../lib/' 
 
-require dir+"/system_extensions_spec"
-require dir+"/system_spec"
-require dir+"/definitions_spec"
+require dir+"concatenative"
+
+describe Concatenative do
+
+	it "should process Ruby methods and 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 process operators" do
+		[2, 2, :dup].execute.should == [2, 2, 2]
+	end
+
+	it "should process combinators" do
+		[2, 3, [:swap, :dup], :i].execute.should == [3, 2, 2]
+	end
+
+end

data/spec/kernel_spec.rb

@@ -0,0 +1,149 @@
+#!/usr/bin/env ruby
+
+dir = File.dirname(File.expand_path(__FILE__))+'/../lib/' 
+
+require dir+"concatenative"
+
+describe Concatenative::Kernel 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 UNCONS and UNSWONS" do
+		[[1,2,3,4], :uncons].execute.should == [1, [2,3,4]]
+		[[1,2,3,4], :unswons].execute.should == [[2,3,4], 1]
+	end
+
+	it "should expose CAT" do
+		[[1,2],[3,4], :cat].execute.should == [1,2,3,4]
+	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 TWODIP" do
+		[2, 3, 9, 4, [:+], :twodip].execute.should == [5, 9, 4]
+	end
+	
+	it "should expose THREEDIP" do
+		[2, 3, 10, 8, 4, [:+], :threedip].execute.should == [5, 10, 8, 4]
+	end
+
+	it "should expose 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 expose POPD" do
+		[1,2,3, :popd].execute.should == [1,3]
+	end
+
+	it "should expose DUPD" do
+		[1,2,3, :dupd].execute.should == [1,2,2,3]
+	end
+
+	it "should expose SWAPD" do
+		[1,2,3, :swapd].execute.should == [2,1,3]
+	end
+	
+	it "should expose 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
+
+
+	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 <= [[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
+
+	it "should expose SPLIT" do
+		[4, [1,2,3,4,5,6], [:>], :split].execute.should == [4, [1,2,3], [4,5,6]]
+	end
+
+	it "should expose BINREC" do
+		# quicksort
+		[[6,4,2,8,1,7,9], 
+		 [:length, 2, :<], [], [:uncons, [:>], :split], [[:swap], :dip, :cons, :concat],	
+		 :binrec].execute.should == [1,2,4,6,7,8,9]
+	end
+
+end

data/spec/system_extensions_spec.rb

@@ -5,14 +5,10 @@ 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
+	it "should be unquotable" do
+		~[2, 3, :*]
+		Concatenative::STACK.last.should == 6
 	end
 
 end
@@ -28,27 +24,41 @@ describe Kernel do
 		).should == "Hello, World!"
 		concatenate(
 			[1,2,3],
-			[:DUP, :*],
-			:STEP
+			[:dup, :*],
+			:step
 		).should == [1,4,9]
 	end
 	
 end
 
 describe Symbol do
+
+	it "should support namespaces" do
+		lambda { :local/:a }.should_not raise_error
+		[[1,2,3],[4,5,6],:concat].execute.should == [1,2,3,4,5,6]
+		[[1,2,3],[4,5,6],:kernel/:concat].execute.should == [1,2,3,4,5,6]
+		[[1,2,3],[4,5,6],:ruby/:concat|1].execute.should == [1,2,3,4,5,6]
+
+	end
 	
 	it "should allow definitions" do
-		lambda {:SQUARE.define [:DUP, :*]}.should_not raise_error
+		lambda {:square <= [:dup, :*]}.should_not raise_error
+		lambda {:square <= [:dup, :+]}.should raise_error
+		lambda {:kernel/:dup <= [:dup]}.should raise_error
+		lambda {:ruby/:gsub <= []}.should raise_error
+		a = :test <= :square
+		a.class.to_s.should == "Array"
+		[4, :test].execute.should == 16
 	end
 
 	it "should be executable" do
-		:SQUARE.define [:DUP, :*]
-		[3, :SQUARE, 2, :+].execute.should == 11 
+		:square <= [:dup, :*] unless :square.defined?
+		[3, :square, 2, :+].execute.should == 11 
 	end
 
-	it "should allo arity to be specified" do
+	it "should allow arity to be specified" do
 		msg = :gsub|2
-		msg.is_a?(RubyMessage).should == true
+		msg.is_a?(Concatenative::RubyMessage).should == true
 		msg.arity.should == 2
 		msg.name.should == :gsub
 	end

metadata

@@ -1,7 +1,7 @@
 --- !ruby/object:Gem::Specification 
 name: concatenative
 version: !ruby/object:Gem::Version 
-  version: 0.1.0
+  version: 0.2.0
 platform: ruby
 authors: 
 - Fabio Cevasco
@@ -9,7 +9,7 @@ autorequire:
 bindir: bin
 cert_chain: []
 
-date: 2009-03-29 00:00:00 +01:00
+date: 2009-04-19 00:00:00 +02:00
 default_executable: 
 dependencies: []
 
@@ -26,15 +26,13 @@ extra_rdoc_files:
 files: 
 - lib/concatenative
 - lib/concatenative/system_extensions.rb
-- lib/concatenative/definitions.rb
-- lib/concatenative/system.rb
+- lib/concatenative/kernel.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
+- spec/kernel_spec.rb
 - README.rdoc
 - LICENSE
 - CHANGELOG.rdoc
@@ -46,6 +44,7 @@ rdoc_options:
 - README.rdoc
 - --exclude
 - spec
+- --line-numbers
 require_paths: 
 - lib
 required_ruby_version: !ruby/object:Gem::Requirement 
@@ -63,7 +62,7 @@ required_rubygems_version: !ruby/object:Gem::Requirement
 requirements: []
 
 rubyforge_project: concatenative
-rubygems_version: 1.2.0
+rubygems_version: 1.3.1
 signing_key: 
 specification_version: 2
 summary: A Ruby DSL for concatenative programming.

data/lib/concatenative/definitions.rb

@@ -1,12 +0,0 @@
-#!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

@@ -1,334 +0,0 @@
-#!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
-