concatenative 0.1.0 → 0.2.0

data/CHANGELOG.rdoc

@@ -1,3 +1,19 @@
+== Version 0.2.0
+
+* Implemented new combinators:
+	* :binrec
+	* :split
+	* :twodip
+	* :threedip
+* Moved combinators to kernel.rb.
+* Removed definitions.rb (all words are now defined in kernel.rb).
+* Performance improvement: stack is never copied.
+* Performance improvement: no symbol/string conversion when processing words.
+* Added ~ operator (call, unquote) for Symbols and Arrays. Removed Array#unquote and Symbol#unquote
+* Added Symbol#<= to define words and Symbol#/ to concatenate them.
+* Added Symbol#/ to concatenate symbols and simulate namespaces.
+* Removed Symbol#define (use Symbol#<= instead)
+
 == Version 0.1.0
 
 First preview release of Concatenative, implementing all the most basic operators and

data/README.rdoc

@@ -22,16 +22,16 @@ Execute a Concatenative program:
 		10, 
 		[0, :==], 
 		[1, :+], 
-		[:DUP, 1, :-], 
+		[:dup, 1, :-], 
 		[:*], 
-		:LINREC
+		: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).
+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, as folows:
 
 
-		:FACTORIAL.define [0, :==], [:POP, 1], [:DUP, 1, :- , :FACTORIAL, :*], :IFTE
-		[5, :FACTORIAL].execute
+		:factorial <= [0, :==], [:pop, 1], [:dup, 1, :- , :factorial, :*], :if
+		[5, :factorial].execute
 
 The program above calculates the factorial of 5, using explicit recursion. 
 

data/examples/benchmarks.rb

@@ -4,7 +4,7 @@ require 'benchmark'
 dir = File.dirname(File.expand_path(__FILE__))+'/../lib/' 
 require dir+"concatenative"
 
-n = 5_000
+n = 3_000
 
 def factorial(n)
 	(n == 0) ? 1 : factorial(n-1)
@@ -22,9 +22,9 @@ 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) }
+	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
@@ -33,6 +33,6 @@ 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) }
+	x.report("Concatenative (times):") { concatenate(n, 0, 1, :rolldown, [:dup, [:+], :dip, :swap], :times, :pop) }
 end
 

data/examples/concatenative_cli.rb

@@ -11,7 +11,7 @@ puts " ========================================="
 loop do
 	print " => "
 	begin
-		Concatenative::System.process(instance_eval(gets))	
+		Concatenative.process(instance_eval(gets))	
 	rescue Exception => e
 		if e.is_a? SystemExit then
 			puts " Exiting."
@@ -21,5 +21,5 @@ loop do
 		puts e.message
 	end
 	print " STACK: "
-	pp Concatenative::System::STACK
+	pp Concatenative::STACK
 end

data/lib/concatenative.rb

@@ -1,27 +1,24 @@
+#!/usr/bin/env ruby
+
 require 'pp'
 
 libdir = File.dirname(File.expand_path(__FILE__))+'/concatenative/'
 
 class EmptyStackError < RuntimeError; end
 
-require libdir+'system'
+require libdir+'kernel'
 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
 
+	extend Concatenative::Kernel
+
+	STACK = []
 	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#|). 
+	# RubyMessage objects wrap a symbol and its arity
+	# (returned by Symbol#|).
 	class RubyMessage
 		attr_reader :name, :arity
 		def initialize(name, arity)
@@ -30,19 +27,86 @@ module Concatenative
 		end
 	end
 
-	# Execute an array as a concatenative program (clears the STACK first).
-	def concatenate(*program)
-		System.execute program
+	class << self
+		attr_accessor :frozen, :popped, :pushed
 	end
 
-	# Execute an array as a concatenative program (clears the STACK first).
-	def self.concatenate(*program)
-		System.execute program
+	@frozen = nil
+	@popped = nil
+	@pushed = nil
+
+	# Pushes an item on the stack.
+	def self.push(element)
+		STACK.push element
+		@pushed += 1 if @frozen
+		element
 	end
-		
-end
 
-include Concatenative
+	# Saves the stack state
+	def self.save_stack
+		@frozen = STACK.length
+		@popped = 0
+		@pushed = 0
+	end
+
+	# Restored the previously saved stack state
+	def self.restore_stack
+		diff = STACK.length - @frozen
+		@frozen = nil
+		diff.times { _pop }
+	end	
+
+	# 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) then
+			if item.defined?
+				~item.definition
+			else
+				case item.namespace
+				when :kernel then
+					Concatenative.send(item.name) rescue raise(RuntimeError, "Kernel word '#{item.name}' is not defined.") 
+				when :ruby then
+					push ruby_method(item.name)
+				else
+					return Concatenative.send(item.name) if Concatenative::Kernel.method_defined? item.name
+					push ruby_method(item.name)
+				end
+			end
+		when item.is_a?(RubyMessage) then
+			push ruby_method(item.name, item.arity)
+		else
+			push item
+		end
+	end
+
+	# Calls a Ruby method, consuming elements from the stack according to its
+	# explicit or implicit arity.
+	def self.ruby_method(message, arity=nil)
+		raise EmptyStackError, "Empty stack" if STACK.empty?
+		n = arity || ARITIES[message] || 0
+		method = message
+		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
+
+end
 
 # Setting some default arities
 set_arity :+, 1

data/lib/concatenative/kernel.rb

@@ -0,0 +1,419 @@
+#!usr/bin/env ruby
+
+module Concatenative
+
+	module Kernel
+
+		# Clears the stack.
+		def clear
+			STACK.clear
+		end
+
+		# Pops an item out of the stack.
+		#
+		# <tt>A =></tt>
+		def pop
+			raise EmptyStackError, "Empty stack" if STACK.empty?
+			return STACK.pop unless @frozen
+			if @pushed > 0 then
+				@pushed -= 1
+				STACK.pop
+			else
+				raise EmptyStackError, "Empty stack" if @frozen <= 0
+				@popped += 1
+				STACK[@frozen-@popped]
+			end	
+		end
+
+		# Prints the top stack item.
+		def put
+			puts STACK.last 
+		end
+
+		# Pushes a user-entered string on the stack. 
+		def get
+			push gets
+		end
+
+		# Duplicates the top stack item.
+		#
+		# <tt>A => A A</tt>
+		def dup
+			raise EmptyStackError, "Empty stack" if STACK.empty?
+			push STACK.last
+		end
+
+		# Swaps the first two elements on the stack.
+		#
+		# <tt>A B => B A</tt> 
+		def swap
+			a = pop
+			b = pop
+			push a
+			push b
+		end
+
+		# Prepends an element to an Array.  
+		#
+		# <tt>[A] B => [A B]</tt>
+		def 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
+
+		def swons
+			swap
+			cons
+		end
+
+		# Removes the first element of an array and puts it on the stack, along with the
+		# new array
+		#
+		# <tt>[A] => B [C]</tt> 
+		def uncons
+			array = pop
+			raise ArgumentError, "UNCONS: first element is not an Array." unless array.is_a? Array
+			push array.first
+			push array.drop 1
+		end
+
+		def unswons
+			uncons
+			swap
+		end
+
+		# Concatenates two arrays.
+		#
+		# <tt>[A] [B] => [A B]</tt>
+		def 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.
+		#
+		# <tt>[A B] => A</tt>
+		def 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.
+		#
+		# <tt>[A B C] => [B C]</tt>
+		def 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
+
+		alias drop pop
+		alias zap pop
+		alias concat cat
+
+		# Saves A, executes P, restores A.
+		#
+		# <tt>A [P] => A</tt>
+		def dip
+			program = pop
+			raise ArgumentError, "DIP: first element is not an Array." unless program.is_a? Array
+			item = pop
+			~program
+			push item
+		end
+
+		# Saves A and B, executes P, restores A and B.
+		#
+		# <tt>A B [P] => A B</tt>
+		def twodip
+			program = pop
+			raise ArgumentError, "2DIP: first element is not an Array." unless program.is_a? Array
+			items = []
+			2.times { items << pop }
+			~program
+			items.reverse.each {|i| push i }
+		end
+
+		# Saves A, B and C, executes P, restores A, B and C.
+		#
+		# <tt>A B C [P] => A B C</tt>
+		def threedip
+			program = pop
+			raise ArgumentError, "2DIP: first element is not an Array." unless program.is_a? Array
+			items = []
+			3.times { items << pop }
+			~program
+			items.reverse.each {|i| push i }
+		end
+		
+		# Removes the second item on the stack.
+		#
+		# <tt>A B => B</tt>
+		def popd
+			push [:pop]
+			dip
+		end
+
+		# Duplicates the second item on the stack
+		#
+		# <tt>A B => A A B</tt>
+		def dupd
+			push [:dup]
+			dip
+		end
+
+		# Swaps the second and third items on the stack
+		#
+		# <tt>A B C => B A C</tt>
+		def swapd
+			push [:swap]
+			dip
+		end
+
+		# 
+		# <tt>A B C => B C A</tt>
+		def rollup
+			swap
+			push [:swap]
+			dip
+		end
+
+		# 
+		# <tt>A B C => C A B</tt>
+		def rolldown
+			push [:swap]
+			dip
+			swap
+		end
+
+		#
+		# <tt>A B C => C B A</tt>
+		def rotate
+			swap
+			push [:swap]
+			dip
+			swap
+		end
+
+		# Executes a quoted program.
+		#
+		# <tt>[P] => </tt>
+		def i
+			program = pop
+			raise ArgumentError, "I: first element is not an Array." unless program.is_a? Array
+			~program
+		end
+
+		# Executes THEN if IF is true, otherwise executes ELSE.
+		#
+		# <tt>[IF] [THEN] [ELSE] =></tt> 
+		def 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
+			save_stack
+			~_if
+			condition = pop
+			restore_stack
+			if condition then
+				~_then
+			else
+				~_else
+			end
+		end
+
+		alias if ifte
+
+		# Quotes the top stack element.
+		#
+		# <tt>A => [A]</tt>
+		def unit
+			push [pop]
+		end
+
+		# Executes P for each element of A, pushes an array containing the results on the stack.
+		# 
+		# <tt>[A] [P] => [B]</tt>
+		def 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
+				unit
+				cat
+			end
+		end
+
+		# Executes P for each element of A, pushes the results on the stack.
+		# 
+		# <tt>[A] [P] => B</tt>
+		def 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
+			end
+		end
+
+		# If IF is true, executes THEN. Otherwise, executes REC1, recurses and then executes REC2.
+		#
+		# <tt>[IF] [THEN] [REC1] [REC2] =></tt>
+		def 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
+			save_stack
+			~_if
+			condition = pop
+			restore_stack
+			if condition then
+				~_then
+			else
+				~rec1
+				[_if, _then, rec1, rec2].each {|e| push e }
+				linrec
+				~rec2
+			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.
+		#
+		# <tt>A [THEN] [REC2] =><tt> 
+		def 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
+			[arg, _if, _then, rec1, rec2].each {|e| push e }
+			linrec
+		end
+
+		# Executes P N times.
+		#
+		# <tt>N [P] => </tt>
+		def times
+			program = pop
+			n = pop
+			raise ArgumentError, "TIMEs: second element is not an Array." unless program.is_a? Array
+			n.times { ~program.dup }
+		end
+
+		# While COND is true, executes P
+		#
+		# <tt>[P] [COND] => </tt>
+		def 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
+			save_stack
+			~cond
+			res = pop
+			restore_stack
+			if res then 
+				~program
+				[cond, program].each {|e| push e }
+				self.while
+			end
+		end
+
+		# Splits an Array into two parts, depending on which element satisfy a condition
+		#
+		# <tt>[A] [P] => [B] [C]</tt>
+		def split
+			cond = pop
+			array = pop
+			raise ArgumentError, "SPLIT: first element is not an Array." unless cond.is_a? Array
+			raise ArgumentError, "SPLIT: second element is not an Array." unless array.is_a? Array
+			yes, no = [], []
+			array.each do |e|
+				save_stack
+				push e
+				~cond.dup
+				pop ? yes << e : no << e
+				restore_stack
+			end
+			push yes
+			push no
+		end
+		
+		# If IF is true, executes THEN. Otherwise, executes REC1 (which must return two elements),
+		# recurses twice and then executes REC2.
+		#
+		# <tt>[IF] [THEN] [REC1] [REC2] =></tt>
+		def binrec
+			rec2 = pop
+			rec1 = pop
+			_then = pop
+			_if = pop
+			raise ArgumentError, "BINREC: first element is not an Array." unless _if.is_a? Array
+			raise ArgumentError, "BINREC: second element is not an Array." unless _then.is_a? Array
+			raise ArgumentError, "BINREC: third element is not an Array." unless rec1.is_a? Array
+			raise ArgumentError, "BINREC: fourth element is not an Array." unless rec2.is_a? Array
+			save_stack
+			~_if
+			condition = pop
+			restore_stack
+			if condition then
+				~_then
+			else
+				~rec1
+				a = pop
+				b = pop
+				[b, _if, _then, rec1, rec2].each {|e| push e }
+				binrec
+				[a, _if, _then, rec1, rec2].each {|e| push e }
+				binrec
+				~rec2
+			end
+		end
+
+	end
+end