schaefer 0.0.4 → 0.0.5

data/lib/schaefer/Library/additionOperator.sch

@@ -2,6 +2,6 @@
   (native_function "
     Proc.new do |arguments, interpreter|
       tmp = arguments.map {|item| interpreter.evaluate(item)}
-      tmp.inject {|sum, n| sum + n.to_i}
+      tmp.inject {|sum, n| sum + n}
     end
    "))

data/lib/schaefer/Library/append.sch

@@ -1,6 +1,26 @@
 (define append
   (native_function "
     Proc.new() do |arguments, interpreter|
-      arguments.map {|x| interpreter.evaluate(x) }.flatten
+      arg1 = interpreter.evaluate(arguments[0])
+      if arg1.is_a? Array
+        arguments.map {|x| interpreter.evaluate(x) }.flatten
+      elsif arg1.is_a? Hash
+        result = arg1
+        args = arguments.dup
+        args.shift
+        args.each do |argument|
+          argument = interpreter.evaluate(argument)
+          if argument.is_a?(Hash) 
+            result.merge!(argument)
+          else
+            if argument.count != 2
+              raise 'When appendind to hash each argument must be a pair'
+            else
+              result[argument[0]] = argument[1]
+            end
+          end
+        end
+        result
+      end
     end
   "))

data/lib/schaefer/Library/assoc.sch

@@ -0,0 +1,16 @@
+(define assoc
+  (native_function "
+    Proc.new do |arguments, interpreter|
+      result = {}
+      arguments.each do |x|
+        element = interpreter.evaluate(x)
+        if element.count != 2
+          raise 'Each element must be a key value pair!'
+        else
+          result[element[0]] = element[1]
+        end
+      end
+      result
+    end
+  "))
+

data/lib/schaefer/Library/deleteAt.sch

@@ -0,0 +1,13 @@
+(define deleteAt
+  (native_function "
+    Proc.new do |arguments, interpreter|
+      arg1 = interpreter.evaluate(arguments[0])
+      arg2 = interpreter.evaluate(arguments[1])
+      if arg1.is_a?(Array)
+        arg1.delete_at(arg2)
+      elsif arg1.is_a?(Hash)
+        arg1.delete(arg2)
+      end
+      arg1
+    end
+  "))

data/lib/schaefer/Library/each.sch

@@ -0,0 +1,43 @@
+(define each
+  (native_function "
+    Proc.new do |arguments, interpreter|
+      list = interpreter.evaluate(arguments[0])
+      if list.is_a? Array
+        formals = arguments[1]
+      elsif list.is_a? Hash
+        formals = arguments[1,2]
+      end
+      body = arguments.slice(2, arguments.length)
+    
+      raise 'Error: Each function takes a minimum of three arguments!' unless arguments.length > 2
+      raise 'Error: Argument one must be a list or hash!' unless list.is_a?(Array) || list.is_a?(Hash)
+      raise 'Error: Formal cannot be defined as a string!' if formals.is_a? String
+      
+      sub_env = Schaefer::Environment.new(interpreter.current_environment)
+
+      executeList = Proc.new do |body, environment, interpreter|
+        interpreter.current_environment = environment
+        result = nil
+        if list.is_a?(Array)
+          list.each do |element|
+            interpreter.current_environment.define(formals, element)
+            body.each do |expression|
+              result = interpreter.evaluate(expression)
+            end
+          end
+        else
+          list.each do |key, value|
+            interpreter.current_environment.define(formals[0], key)
+            interpreter.current_environment.define(formals[1], value)
+            body.each do |expression|
+              result = interpreter.evaluate(expression)
+            end
+          end
+        end
+        interpreter.current_environment = environment.parent
+        result
+      end
+      
+      executeList.call(body, sub_env, interpreter)
+    end
+  "))

data/lib/schaefer/Library/first.sch

@@ -0,0 +1,11 @@
+(define first
+  (native_function "
+    Proc.new do |argument, interpreter|
+      arg1 = interpreter.evaluate(argument[0])
+      if arg1.is_a? Array      
+        arg1[0]
+      elsif arg1.is_a? String
+        arg1[0,1]
+      end
+    end
+  "))

data/lib/schaefer/Library/index.sch

@@ -0,0 +1,20 @@
+(define index
+  (native_function "
+    Proc.new do |arguments, interpreter|
+      arg1 = interpreter.evaluate(arguments[0])
+      arg2 = interpreter.evaluate(arguments[1])  
+      index = []
+      i = 0 
+      arg1.each do |element|
+        if arg2 == element
+          index << i 
+        end
+        i += 1
+      end
+      if index.length == 1
+        index[0]
+      else
+        index
+      end
+    end
+  "))

data/lib/schaefer/Library/integer.sch

@@ -0,0 +1,8 @@
+(define integer
+  (native_function "
+    Proc.new do |arguments, interpreter|
+      9
+    end
+  "))
+
+(define int integer)

data/lib/schaefer/Library/isA.sch

@@ -0,0 +1,16 @@
+(define isA?
+  (native_function "
+    Proc.new do |arguments, interpreter|
+      if arguments.count != 2
+        raise 'The isA? comparitor accepts two arguments'
+      else
+        arg1 = interpreter.evaluate(arguments[0])
+        arg2 = interpreter.evaluate(arguments[1])
+        if arg1.is_a?(arg2.class)
+          true
+        else
+          false
+        end
+      end
+    end
+  "))

data/lib/schaefer/Library/keyfor.sch

@@ -0,0 +1,19 @@
+(define keyfor
+  (native_function "
+    Proc.new do |arguments, interpreter|
+      argument1 = interpreter.evaluate(arguments[0])
+      argument2 = interpreter.evaluate(arguments[1])
+      index = []
+      i = 0
+      argument1.each do |key, value|
+        if argument2 == value
+          index << key
+        end
+      end
+      if index.length == 1
+        index[0]
+      else
+        index
+      end
+    end
+  "))

data/lib/schaefer/Library/map.sch

@@ -0,0 +1,34 @@
+(define map
+  (native_function "
+    Proc.new do |arguments, interpreter|
+      list = interpreter.evaluate(arguments[0])
+      formals = arguments[1]
+      body = arguments.slice(2, arguments.length)
+
+      raise 'Error: Map function takes a minimum of three arguments!' unless arguments.length > 2
+      raise 'Error: Argument one must be a list!' unless list.is_a? Array
+      raise 'Error: Formal cannot be defined as a string!' if formals.is_a? String
+      
+      if formals.is_a? Array
+        raise 'Error: Map function takes one formal!' if formals.length != 1
+        formals = formals[0]
+      end
+
+      sub_env = Schaefer::Environment.new(interpreter.current_environment)
+     
+      executeList = Proc.new do |body, environment, interpreter|
+        interpreter.current_environment = environment
+        result = []
+        list.each do |element|
+          interpreter.current_environment.define(formals, element)
+          body.each do |expression|
+            result << interpreter.evaluate(expression) 
+          end
+        end
+        interpreter.current_environment = environment.parent
+        result
+      end
+      
+      executeList.call(body, sub_env, interpreter) 
+    end
+  "))

data/lib/schaefer/Library/pair.sch

@@ -0,0 +1,12 @@
+(define pair
+  (native_function "
+    Proc.new do |arguments, interpreter|
+      if arguments.count != 2
+        raise 'Pair function only takes two arguments: key and value'
+      else
+        arguments.map do |x|
+          interpreter.evaluate(x)
+        end
+      end
+    end
+  "))

data/lib/schaefer/Library/pull.sch

@@ -0,0 +1,8 @@
+(define pull
+  (native_function "
+    Proc.new do |arguments, interpreter|
+      arg1 = interpreter.evaluate(arguments[0])
+      arg2 = interpreter.evaluate(arguments[1])
+      arg1[arg2]
+    end
+  "))

data/lib/schaefer/Library/return.sch

@@ -0,0 +1,10 @@
+(define return
+  (native_function "
+    Proc.new do |arguments, interpreter|
+      if arguments.count != 1
+        raise 'Return function takes one argument'
+      else
+        interpreter.evaluate(arguments[0])
+      end 
+    end
+  "))

data/lib/schaefer/Library/reverse.sch

@@ -0,0 +1,7 @@
+(define reverse
+  (native_function "
+    Proc.new do |arguments, interpreter|
+      arg1 = interpreter.evaluate(arguments[0])
+      arg1.reverse
+    end
+  "))

data/lib/schaefer/Library/set.sch

@@ -0,0 +1,15 @@
+(define set
+  (native_function "
+    Proc.new do |arguments, interpreter|
+      if arguments.count != 3
+        raise 'Set function requires 3 arguments!'
+      else
+        arg1 = interpreter.evaluate(arguments[0])
+        if arg1.is_a?(Array) || arg1.is_a?(Hash)
+          arg2 = interpreter.evaluate(arguments[1])
+          arg3 = interpreter.evaluate(arguments[2])
+          arg1[arg2] = arg3
+        end 
+      end
+    end
+  "))

data/lib/schaefer/Library/shift.sch

@@ -2,6 +2,7 @@
   (native_function "
     Proc.new do |argument, interpreter|
       list = interpreter.evaluate(argument[0])
-      list.slice(1, list.length)
+      list.shift
+      list
     end
   "))

data/lib/schaefer/Library/split.sch

@@ -0,0 +1,40 @@
+(define splitString
+  (native_function "
+    Proc.new do |arguments, interpreter|
+      arg1 = interpreter.evaluate(arguments[0])
+      if arg1.is_a? String
+        arg1.split
+      else
+        raise 'splitString function takes a string as an argument.'
+      end
+    end
+  "))
+
+(define split 
+  (function (x) 
+    (define keys (list))
+    (define values (list))
+    (if (isA? x (assoc))
+      (do 
+        (each x k v 
+          (define keys (append keys k))
+          (define values (append values v))
+          (return (assoc (pair (quote keys) keys) (pair (quote values) values)))
+        )
+      )
+      (if (isA? x (list))
+        (do 
+          (each x element
+            (define keys (append keys (index x element)))
+            (define values (append values element))
+            (return (assoc (pair (quote keys) keys) (pair (quote values) values)))
+          )
+        )
+        (if (isA? x (str))
+          (splitString x)
+          ()
+        )
+      )
+    )
+  )
+)

data/lib/schaefer/Library/string.sch

@@ -0,0 +1,8 @@
+(define string
+  (native_function "
+    Proc.new do |arguments, interpreter| 
+      ''
+    end
+  "))
+
+(define str string)

data/lib/schaefer/environment.rb

@@ -16,5 +16,8 @@ module Schaefer
 		def define(name, value)
 			@table[name] = value
 		end
+
+    def removeDefinition(name)
+    end
 	end
 end

data/lib/schaefer/interpreter.rb

@@ -37,9 +37,10 @@ module Schaefer
 
     def loadLibrary
       pattern = File.join(File.dirname(__FILE__), "Library", "*.sch")
-
-      Dir[pattern].each do |file|
-        run(File.read(file))
+      Dir[pattern].each do |item|
+        File.open(item) do |file|
+          run(file.read)
+        end
       end
     end
 	end

data/lib/schaefer/parser.rb

@@ -57,6 +57,10 @@ class Parser
     return isMatch?(string, /"([^"\\]|\\.)*"/)
   end
 
+  def isComma?(string)
+    return isMatch?(string, /.*,.*/)
+  end
+
   def convertTokens(tokens)
     convertedTokens = []
     tokens.each do |token|
@@ -65,6 +69,7 @@ class Parser
       convertedTokens << token.to_i and next if isInteger?(token)
       convertedTokens << token.to_sym and next if isSymbol?(token)
       convertedTokens << eval(token) and next if isString?(token)
+      convertedTokens << token and next if isComma?(token)
       raise Exception, "Unrecognized token: #{token}"
     end
     return convertedTokens
@@ -118,6 +123,13 @@ class Parser
         end
       end
       "(" + mapped.join(" ") + ")"
+    elsif (data.is_a?(Hash))
+      mapped = data.map do |key, value|
+        key = toToken(key)
+        value = toToken(value)
+        key + "=>" + value
+      end
+      "(" + mapped.join(" ") + ")"
     else
       data.to_s
     end

data/lib/schaefer/version.rb

@@ -1,3 +1,3 @@
 module Schaefer
-  VERSION = "0.0.4"
+  VERSION = "0.0.5"
 end

metadata

@@ -1,13 +1,13 @@
 --- !ruby/object:Gem::Specification 
 name: schaefer
 version: !ruby/object:Gem::Version 
-  hash: 23
+  hash: 21
   prerelease: 
   segments: 
   - 0
   - 0
-  - 4
-  version: 0.0.4
+  - 5
+  version: 0.0.5
 platform: ruby
 authors: 
 - Tommy Schaefer
@@ -15,7 +15,7 @@ autorequire:
 bindir: bin
 cert_chain: []
 
-date: 2012-05-29 00:00:00 Z
+date: 2012-06-23 00:00:00 Z
 dependencies: []
 
 description: Schaefer is a small programming language deigned to show how to build a programming language. Running the command 'schaefer' begins console based execution of code and passing a file name will execute the file. SchaeferScript is a scheme-style language where the core functions are written in ruby and other functions written in the language itself. You can access the source for SchaeferScript at https://github.com/tommyschaefer/SchaeferScript.
@@ -32,31 +32,6 @@ files:
 - .DS_Store
 - .gitignore
 - .gitignore~
-- Examples/.DS_Store
-- Examples/Arithmatic/exampleAdd.sch
-- Examples/Arithmatic/exampleDivision.sch
-- Examples/Arithmatic/exampleMultipy.sch
-- Examples/Arithmatic/exampleSubtraction.sch
-- Examples/Commenting/exampleComment.sch
-- Examples/FlowControl/exampleDo.sch
-- Examples/FlowControl/exampleGreater.sch
-- Examples/FlowControl/exampleIf.sch
-- Examples/FlowControl/exampleLesser.sch
-- Examples/Functions/exampleFunction.sch
-- Examples/Functions/exampleFunction2.sch
-- Examples/Input:Output/exampleDisplay.sch
-- Examples/Input:Output/exampleInput.sch
-- Examples/Input:Output/exampleWrite.sch
-- Examples/Lists/exampleAppend.sch
-- Examples/Lists/exampleConstruct.sch
-- Examples/Lists/exampleLength.sch
-- Examples/Lists/exampleList.sch
-- Examples/Lists/exampleListFirst.sch
-- Examples/Lists/exampleQuote.sch
-- Examples/Lists/exampleShift.sch
-- Examples/Lists/exampleUnshift.sch
-- Examples/Practical/each.sch
-- Examples/Practical/fib.sch
 - Gemfile
 - LICENSE
 - README.md
@@ -67,29 +42,43 @@ files:
 - lib/schaefer.rb
 - lib/schaefer/.DS_Store
 - lib/schaefer/.environment.rb.swp
+- lib/schaefer/.interpreter.rb.swp
 - lib/schaefer/Library/.DS_Store
+- lib/schaefer/Library/.split.sch.swp
 - lib/schaefer/Library/additionOperator.sch
 - lib/schaefer/Library/append.sch
+- lib/schaefer/Library/assoc.sch
 - lib/schaefer/Library/comment.sch
 - lib/schaefer/Library/construct.sch
+- lib/schaefer/Library/deleteAt.sch
 - lib/schaefer/Library/display.sch
 - lib/schaefer/Library/divisionOperator.sch
 - lib/schaefer/Library/do.sch
-- lib/schaefer/Library/do.sch~
+- lib/schaefer/Library/each.sch
 - lib/schaefer/Library/equalTo.sch
-- lib/schaefer/Library/equalTo.sch~
+- lib/schaefer/Library/first.sch
 - lib/schaefer/Library/function.sch
 - lib/schaefer/Library/if.sch
-- lib/schaefer/Library/if.sch~
+- lib/schaefer/Library/index.sch
 - lib/schaefer/Library/input.sch
+- lib/schaefer/Library/integer.sch
+- lib/schaefer/Library/isA.sch
 - lib/schaefer/Library/isgreater.sch
 - lib/schaefer/Library/islesser.sch
+- lib/schaefer/Library/keyfor.sch
 - lib/schaefer/Library/length.sch
 - lib/schaefer/Library/list.sch
-- lib/schaefer/Library/listFirst.sch
+- lib/schaefer/Library/map.sch
 - lib/schaefer/Library/multiplicationOperator.sch
+- lib/schaefer/Library/pair.sch
+- lib/schaefer/Library/pull.sch
 - lib/schaefer/Library/quote.sch
+- lib/schaefer/Library/return.sch
+- lib/schaefer/Library/reverse.sch
+- lib/schaefer/Library/set.sch
 - lib/schaefer/Library/shift.sch
+- lib/schaefer/Library/split.sch
+- lib/schaefer/Library/string.sch
 - lib/schaefer/Library/subtractionOperator.sch
 - lib/schaefer/Library/tonum.sch
 - lib/schaefer/Library/tostr.sch

data/Examples/Arithmatic/exampleAdd.sch

@@ -1,2 +0,0 @@
-(add 1 2 3 4 5)
-

data/Examples/Arithmatic/exampleDivision.sch

@@ -1 +0,0 @@
-(write (/ (/ 100 2) 2))

data/Examples/Arithmatic/exampleMultipy.sch

@@ -1,3 +0,0 @@
-(display "2*4 = ")
-(write (* 2 4))
-

data/Examples/Arithmatic/exampleSubtraction.sch

@@ -1 +0,0 @@
-(write (- (- 100 (- 100 50) 25) 20))

data/Examples/Commenting/exampleComment.sch

@@ -1,12 +0,0 @@
-Commenting can be acheaved by simply typing outside of parenthesees. There 
-are a few things to be careful of though. Commas and some other symbols are
-not yet recognized in the parser so they return wierd values. This will be
-fixed in the next release. Also be careful not to include any parenthasees
-because otherwise they will be interpreted as commands!
-
-
-(define test
-  (function ()
-      (## When inside of parenthasees just use the double hash)
-      (write "hello")))
-(test)

data/Examples/FlowControl/exampleDo.sch

@@ -1,18 +0,0 @@
-Do is a function that steps through a list of commands. In some functions such as if as seen below
-a number of commands must be executed within a single set of parenthasees. This task is accomplished
-with the do function.																				 
-_____________________________________________________________________________________________________
-
-
-(define one 1)
-(define won 1)
-
-(if (equal? one won)
-  (do
-    (display "1 and 1 are equal")
-    (write " and thats a fact"))
-  (write "1 and 1 are not equal!"))
-
-
--------------------------------------------------------------------------------------
-This example will return "1 and 1 are equal and thats a fact" followed by a new line.

data/Examples/FlowControl/exampleGreater.sch

@@ -1,17 +0,0 @@
-The isGreater? function allows you to test weather one number is greater than the other.
-The greater check takes two arguments and compares the first to the seccond.
-----------------------------------------------------------------------------------------
-
-
-(define one 1)
-(define two 2)
-
-(if(isGreater? one two)
-  (write "1 > 2")
-  (write "1 < 2"))
-
-
-
------------------------------------------------------------------------------------------------
-In this example the correct return is "1 < 2". Because 1 is being compared to 2 isGreater? will
-return false.

data/Examples/FlowControl/exampleIf.sch

@@ -1,18 +0,0 @@
-The if function takes three arguments. The first is the comparison which will either return
-true or false. The seccond is the true case which will be executed if the result of the 
-comparison is true. And the last is the false case which will be executed if the result
-of the comparisson is false.
---------------------------------------------------------------------------------------------
-
-
-(define one 1)
-(define won 1)
-(define two 2)
-
-(if (= one won)
-  (write "1 = 1")
-  (write "1 != 1"))
-
-(if (equal? one two)
-  (write "1 = 2")
-  (write "1 != 2"))

data/Examples/FlowControl/exampleLesser.sch

@@ -1,13 +0,0 @@
-The isLesser? is a comparitive function that takes two arguments.
-TIf the first is lesser than the seccond the function will return
-true and if the first is greater than the seccond the function 
-will return false
-------------------------------------------------------------------
-
-
-(define one 1)
-(define two 2)
-
-(if(isLesser? one two)
-  (write "1 < 2")
-  (write "1 > 2"))

data/Examples/Functions/exampleFunction.sch

@@ -1,18 +0,0 @@
-The function function has many uses. When passed no variables it can be used
-to make your definition executable and allowing loops. In this example you
-are prompted to enter a password until you answer correctly. This demonstrates
-using empty functions to generate loops and executable definitions.
--------------------------------------------------------------------------------
-
-
-(define program
-  (function ()
-    (display "Enter password (Hint its password): ")
-    (define response (input))
-    (if (= response "password")
-      (write "Great Job!")
-      (do
-        (write "Im sorry. Thats incorrect!")
-        (program)))))
-
-(program)

data/Examples/Functions/exampleFunction2.sch

@@ -1,10 +0,0 @@
-This example demonstrates how functions can be used by passing them arguments.
-Using functions in this mannor allows you to create new functions much like 
-some that define this language!
-------------------------------------------------------------------------------
-
-
-(define double
-  (function (x) (+ x x)))
-
-(write (double 5))

data/Examples/Input:Output/exampleDisplay.sch

@@ -1,6 +0,0 @@
-The display command takes one argument. The function then evaluates that argument and displays
-it to the screen without a trailing newline.
-----------------------------------------------------------------------------------------------
-
-
-(display "hello")

data/Examples/Input:Output/exampleInput.sch

@@ -1,13 +0,0 @@
-The input command takes no arguments. In allows for user input up until a newline
-is detected. The function then returns a string of the input excluding the newline
-character.
-----------------------------------------------------------------------------------
-
-
-(display "Enter password (Hint: its password): ")
-(define result (input))
-
-(if(= result "password")
-  (write "Excellent!")
-  (write "Wrong!"))
-

data/Examples/Input:Output/exampleWrite.sch

@@ -1,6 +0,0 @@
-The write command is nearly identical to the display command. It takes one argument then evaluates
-that argument and displays it to the screen with a trailing newline.
---------------------------------------------------------------------------------------------------
-
-
-(write "hello")

data/Examples/Lists/exampleAppend.sch

@@ -1,9 +0,0 @@
-The append command takes an unlimited ammount of arguments. It works by constructing
-a single list given multiple in the same order that they are specified.
------------------------------------------------------------------------------------- 
-
-
-(define l1 (quote (1 2 3 4 5)))
-(define l2 (quote (6 7 8 9 0)))
-
-(write (append l1 l2))

data/Examples/Lists/exampleConstruct.sch

@@ -1,27 +0,0 @@
-Construct takes two arguments. By performing a construct argument 1 is placed before argument 3
-and the result is not flattened. This has the effect of creating multi-dimensional arrays. Notice
-that the length reflects the number of elements with a sub-list contributing one.
--------------------------------------------------------------------------------------------------
-
-
-(define list1 (list 1 2 3 4 5))
-(define list2 (list 6 7 8 9 0))
-
-(display "List1: ")
-(write list1)
-
-(display "List2: ")
-(write list2)
-
-(define ap (append list1 list2))
-(define con (construct list1 list2))
-
-(display "Appended List1-List2: ")
-(display ap)
-(display " -Length: ")
-(write (length ap))
-
-(display "Constructed List1-List2: ")
-(display con)
-(display " -Length: ")
-(write (length con))

data/Examples/Lists/exampleLength.sch

@@ -1,9 +0,0 @@
-The length function takes one argument. The argument is then evaluated
-and the length of the list is returned.
-----------------------------------------------------------------------
-
-
-(define l1 (list 0 1 2 3 4 5 6 7))
-(define l2 (list 8 9 10))
-
-(write (length (append l1 l2)))

data/Examples/Lists/exampleList.sch

@@ -1,7 +0,0 @@
-A list is a data type similar to an array in that it is a grouping of values
-but different in that they are not tied to any keys. When lists are created 
-with the list function each element is evaluated before it is stored.
-----------------------------------------------------------------------------
-
-
-(write (list 1 2 3 4 5))

data/Examples/Lists/exampleListFirst.sch

@@ -1,10 +0,0 @@
-The listFirst command takes one list as an argument. It then returns the first element
-of the provided list.
---------------------------------------------------------------------------------------
-
-
-(define l1 (quote (1 2 3 4 5)))
-
-(write l1)
-(display "First: ")
-(write (listFirst l1))

data/Examples/Lists/exampleQuote.sch

@@ -1,7 +0,0 @@
-By using quote you can create lists without evaluating each element. When you create a list
-using the list keyword each element is evaluated and symbols are interpreted as variables.
-By quoting the contents of a list are not evaluated and symbols are left unevaluated.
---------------------------------------------------------------------------------------------
-
-
-(write (quote (1 2 3 4 5 bob)))

data/Examples/Lists/exampleShift.sch

@@ -1,11 +0,0 @@
-The shift function takes one list as the argument. The function removes the first element from
-the list and returns the list again. A combination of listFirst and shift can be used to get
-a different values from a list.
------------------------------------------------------------------------------------------------
-
-
-(define l1 (list 1 2 3 4 5))
-(display "List: ")
-(write l1)
-(display "List Post-Shift: ")
-(write (shift l1))

data/Examples/Lists/exampleUnshift.sch

@@ -1,18 +0,0 @@
-The unshift function takes an unlimited number of arguments. The unshift function
-takes an array provided in argument 1 and evaluates the subsequent arguments. It
-then adds the result before the first list in the order they were provided and 
-then flattens the list. Eg. Argument 1 is the list 1 2 3. Argument 2 is the list
-3 4 5. Argument 3 is 5 6 7. The list resulting from unshifting under these conditions
-would be 3 4 5 5 6 7 1 2 3.
--------------------------------------------------------------------------------------
-
-
-(define list1 (list -4 -3 -2 -1 0))
-(define list2 (list 1 2 3 4 5))
-(define list3 (list 6 7 8 9 10))
-
-(display "Append: ")
-(write (append list1 list2 list3))
-
-(display "Unshift: ")
-(write (unshift list3 list1 list2))

data/Examples/Practical/each.sch

@@ -1,22 +0,0 @@
-THe each example demonstrates how a typical array-each would be written in 
-SchaeferScript. Rather that just writing the element that you are currently
-at you could do any task.
----------------------------------------------------------------------------
-
-
-(define i 0)
-(define offset 0)
-(define li (list 1 2 3 4 5 6))
-
-(define each
-  (function (lis)
-    (if (= (+ (length lis) offset) i)
-      (display "")
-      (do
-        (write (listFirst lis))
-        (define lis (shift lis))
-        (define i (+ i 1))
-        (define offset (+ offset 1))
-        (each lis)))))
-
-(each li)

data/Examples/Practical/fib.sch

@@ -1,44 +0,0 @@
-(define i 0)
-(define p 0)
-(define c 1)
-
-(define test
-  (function (x)
-    (if(= i x)
-      (do
-        (define i 0)
-        (define p 0)
-        (define c 1)
-      )
-      (do
-        (define np c)
-        (define nc (+ p c))
-        (define p np)
-        (define c nc)
-        (write c)
-        (define i (+ i 1))
-        (test x)
-      )
-    )
-  )
-)
-
-(define run
-  (function ()
-    (do
-      (write "How many Fibbonocci numbers would you like me to calculate?")
-      (display ">> ")
-      (define num (input))
-      (if (= num "exit")
-        (write "")
-        (do
-          (define num (->num num))
-          (test num)
-          (run)
-        )
-      )
-    )
-  )
-)
-
-(run)

data/lib/schaefer/Library/listFirst.sch

@@ -1,7 +0,0 @@
-(define listFirst
-  (native_function "
-    Proc.new do |argument, interpreter|
-      list = interpreter.evaluate(argument[0])
-      list[0]
-    end
-  "))