Add input handler and refactor interpreter

src/propeller/problems/simple_regression.clj

@@ -28,28 +28,9 @@
         :integer_eq
         :exec_dup
         :exec_if
-        :boolean_and
-        :boolean_or
-        :boolean_not
-        :boolean_eq
-        :string_eq
-        :string_take
-        :string_drop
-        :string_reverse
-        :string_concat
-        :string_length
-        :string_includes?
         'close
         0
-        1
+        1))
-        true
-        false
-        ""
-        "ABCDEFGHIJKLMNOPQRSTUVWXYZ"
-        "A"
-        "C"
-        "G"
-        "T"))
 
 (defn error-function
   "Finds the behaviors and errors of an individual. The error is the absolute

src/propeller/problems/software/number_io.clj

@@ -0,0 +1,3 @@
+(ns propeller.problems.software.number-io)
+
+

src/propeller/push/instructions/input_output.clj

@@ -3,11 +3,19 @@
             [propeller.push.utils :refer [def-instruction]]))
 
 ;; =============================================================================
-;; INPUT and OUTPUT Instructions
+;; INPUT Instructions
 ;; =============================================================================
 
-;; Pushes the input labeled :in1 on the inputs map onto the :exec stack
+;; Allows Push to handle input instructions of the form :inN, e.g. :in2, taking
-(def-instruction
+;; elements thus labeled from the :input stack and pushing them onto the :exec
-  :in1
+;; stack. We can tell whether a particular inN instruction is valid if N-1
-  (fn [state]
+;; values are on the input stack.
-    (state/push-to-stack state :exec (:in1 (:input state)))))
+(defn handle-input-instruction
+  [state instruction]
+  (if-let [input (instruction (:input state))]
+    (state/push-to-stack state :exec input)
+    (throw (Exception. (str "Undefined input instruction " instruction)))))
+
+;; =============================================================================
+;; OUTPUT and PRINT Instructions
+;; =============================================================================

src/propeller/push/interpreter.clj

@@ -1,34 +1,38 @@
 (ns propeller.push.interpreter
   (:require [propeller.push.core :as push]
-            [propeller.push.state :as state]))
+            [propeller.push.state :as state]
+            [propeller.push.utils :refer [get-literal-type]]
+            [propeller.push.instructions.input-output :as io]))
 
 (defn interpret-one-step
   "Takes a Push state and executes the next instruction on the exec stack."
   [state]
   (let [popped-state (state/pop-stack state :exec)
-        first-instruction-raw (first (:exec state))
+        instruction (first (:exec state))
-        first-instruction (if (keyword? first-instruction-raw)
+        literal-type (get-literal-type instruction)] ; nil for non-literals
-                            (first-instruction-raw @push/instruction-table)
-                            first-instruction-raw)]
     (cond
-      (fn? first-instruction)
+      ;;
-      (first-instruction popped-state)
+      ;; Recognize functional instruction or input instruction
-      ;
+      (keyword? instruction)
-      (integer? first-instruction)
+      (if-let [function (instruction @push/instruction-table)]
-      (state/push-to-stack popped-state :integer first-instruction)
+        (function popped-state)
-      ;
+        (io/handle-input-instruction popped-state instruction))
-      (string? first-instruction)
+      ;;
-      (state/push-to-stack popped-state :string first-instruction)
+      ;; Recognize constant literal instruction
-      ;
+      literal-type
-      (seq? first-instruction)
+      (if (= :generic-vector literal-type)
-      (update popped-state :exec #(concat %2 %1) first-instruction)
+        ;; Empty vector gets pushed on all vector stacks
-      ;
+        (reduce #(update-in % [%2] conj []) popped-state
-      (or (= first-instruction true) (= first-instruction false))
+                [:vector_boolean :vector_float :vector_integer :vector_string])
-      (state/push-to-stack popped-state :boolean first-instruction)
+        (state/push-to-stack popped-state literal-type instruction))
-      ;
+      ;;
+      ;; Recognize parenthesized group of instructions
+      (seq? instruction)
+      (update popped-state :exec #(concat %2 %1) instruction)
+      ;;
       :else
       (throw (Exception. (str "Unrecognized Push instruction in program: "
-                              (name first-instruction-raw)))))))
+                              (name instruction)))))))
 
 (defn interpret-program
   "Runs the given problem starting with the stacks in start-state."

src/propeller/push/utils.clj

@@ -55,7 +55,17 @@
                   :char           char?
                   :float          float?
                   :integer        integer?
-                  :string  string?}]
+                  :string         string?
+                  :vector_boolean (fn [thing] (and (vector? thing)
+                                                   (or (true? (first thing))
+                                                       (false? (first thing)))))
+                  :vector_float   (fn [thing] (and (vector? thing)
+                                                   (float? (first thing))))
+                  :vector_integer (fn [thing] (and (vector? thing)
+                                                   (integer? (first thing))))
+                  :vector_string  (fn [thing] (and (vector? thing)
+                                                   (string? (first thing))))
+                  :generic-vector (fn [thing] (= [] thing))}]
     (first (for [[stack function] literals
                  :when (function data)]
              stack))))

src/propeller/utils.clj

@@ -1,5 +1,10 @@
 (ns propeller.utils)
 
+(defn get-vector-literal-type
+  "Returns the literal stack corresponding to some vector stack."
+  [vector-stack]
+  (keyword (clojure.string/replace (str vector-stack) ":vector_" "")))
+
 (defn indexof
   "Returns the first index of an element in a collection. If the element is not
   present in the collection, returns -1."
@@ -26,9 +31,6 @@
   ERC-producing functions to a constant literal."
   [instructions]
   (let [instruction (rand-nth instructions)]
-    (if (fn? instruction) (instruction) instruction)))
+    (if (fn? instruction)
-
+      (instruction)
-(defn get-vector-literal-type
+      instruction)))
-  "Returns the literal stack corresponding to some vector stack."
-  [vector-stack]
-  (keyword (clojure.string/replace (str vector-stack) ":vector_" "")))