gonna abandon TH

src/HushGP/Instructions/CodeInstructions.hs

@@ -96,19 +96,11 @@ instructionCodeDoThenPop :: State -> State
 instructionCodeDoThenPop state@(State {_code = c1 : _, _exec = es}) = state {_exec = c1 : StateFunc (instructionCodePop, "instructionCodePop") : es}
 instructionCodeDoThenPop state = state
 
--- |Utility: A shorthand for instrucitonCodeFromExec to make code instructions less bloated
-codeFromExec :: Gene
-codeFromExec = StateFunc (instructionCodeFromExec, "instructionCodeFromExec")
-
--- |Utility: A shorthand for instructionCodoDoRange to make code instructions less bloated
-codeDoRange :: Gene
-codeDoRange = StateFunc (instructionCodeDoRange, "instructionCodeDoRange")
-
 -- |Evaluates the top item on the code stack for each step along the range i to j. Both i and j are taken from the int stack.
 instructionCodeDoRange :: State -> State
 instructionCodeDoRange state@(State {_code = c1 : cs, _int = i0 : i1 : is, _exec = es}) =
   if increment i0 i1 /= 0
-    then state {_exec = c1 : Block [GeneInt (i1 + increment i0 i1), GeneInt i0, codeFromExec, c1, codeDoRange] : es, _int = i1 : is, _code = cs}
+    then state {_exec = c1 : Block [GeneInt (i1 + increment i0 i1), GeneInt i0, StateFunc (instructionCodeFromExec, "instructionCodeFromExec"), c1, StateFunc (instructionCodeDoRange, "instructionCodeDoRange")] : es, _int = i1 : is, _code = cs}
     else state {_exec = c1: es, _int = i1 : is, _code = cs}
   where
     increment :: Int -> Int -> Int
@@ -123,7 +115,7 @@ instructionCodeDoCount :: State -> State
 instructionCodeDoCount state@(State {_code = c : cs, _int = i1 : is, _exec = es}) =
   if i1 < 1
     then state
-    else state {_code = cs, _int = is, _exec = Block [GeneInt 0, GeneInt $ i1 - 1, codeFromExec, c, codeDoRange] : es}
+    else state {_code = cs, _int = is, _exec = Block [GeneInt 0, GeneInt $ i1 - 1, StateFunc (instructionCodeFromExec, "instructionCodeFromExec"), c, StateFunc (instructionCodeDoRange, "instructionCodeDoRange")] : es}
 instructionCodeDoCount state = state
 
 -- |Evaluates the top item on the code stack n times, where n comes from the n comes from the top of the int stack.
@@ -131,7 +123,7 @@ instructionCodeDoTimes :: State -> State
 instructionCodeDoTimes state@(State {_code = c : cs, _int = i1 : is, _exec = es}) =
   if i1 < 1
     then state
-    else state {_code = cs, _int = is, _exec = Block [GeneInt 0, GeneInt $ i1 - 1, codeFromExec, Block [StateFunc (instructionIntPop, "instructionIntPop"), c], codeDoRange] : es}
+    else state {_code = cs, _int = is, _exec = Block [GeneInt 0, GeneInt $ i1 - 1, StateFunc (instructionCodeFromExec, "instructionCodeFromExec"), Block [StateFunc (instructionIntPop, "instructionIntPop"), c], StateFunc (instructionCodeDoRange, "instructionCodeDoRange")] : es}
 instructionCodeDoTimes state = state
 
 -- |If the top boolean is true, execute the top element of the code stack and skip the second. Otherwise, skip the top element of the code stack and execute the second.

src/HushGP/Instructions/ExecInstructions.hs

@@ -70,16 +70,12 @@ instructionExecShoveDup = instructionShoveDup exec
 instructionExecIsStackEmpty :: State -> State
 instructionExecIsStackEmpty = instructionIsStackEmpty exec
 
--- |Utility: Shorthand for instructionExecDoRange
-execDoRange :: Gene
-execDoRange = StateFunc (instructionExecDoRange, "instructionExecDoRange")
-
 -- |Evaluates the top item on the exec stack for each step along the range i to j. Both i and j are 
 -- taken from the int stack. Differs from code_do_range only in the source of the code and the recursive call.
 instructionExecDoRange :: State -> State
 instructionExecDoRange state@(State {_exec = e1 : es, _int = i0 : i1 : is}) =
   if increment i0 i1 /= 0
-    then state {_exec = e1 : Block [GeneInt (i1 + increment i0 i1), GeneInt i0, execDoRange, e1] : es, _int = i1 : is}
+    then state {_exec = e1 : Block [GeneInt (i1 + increment i0 i1), GeneInt i0, StateFunc (instructionExecDoRange, "instructionExecDoRange"), e1] : es, _int = i1 : is}
     else state {_exec = e1 : es, _int = i1 : is}
   where
     increment :: Int -> Int -> Int
@@ -95,7 +91,7 @@ instructionExecDoCount :: State -> State
 instructionExecDoCount state@(State {_exec = e1 : es, _int = i1 : is}) =
   if i1 < 1
     then state
-    else state {_exec = Block [GeneInt 0, GeneInt $ i1 - 1, execDoRange, e1] : es, _int = is}
+    else state {_exec = Block [GeneInt 0, GeneInt $ i1 - 1, StateFunc (instructionExecDoRange, "instructionExecDoRange"), e1] : es, _int = is}
 instructionExecDoCount state = state
 
 -- |Evaluates the top item on the code stack n times, where n comes from the n comes from the top of the int stack.
@@ -103,7 +99,7 @@ instructionExecDoTimes :: State -> State
 instructionExecDoTimes state@(State {_exec = e1 : es, _int = i1 : is}) =
   if i1 < 1
     then state
-    else state {_exec = Block [GeneInt 0, GeneInt $ i1 - 1, execDoRange, Block [StateFunc (instructionIntPop, "instructionIntPop"), e1]] : es, _int = is}
+    else state {_exec = Block [GeneInt 0, GeneInt $ i1 - 1, StateFunc (instructionExecDoRange, "instructionExecDoRange"), Block [StateFunc (instructionIntPop, "instructionIntPop"), e1]] : es, _int = is}
 instructionExecDoTimes state = state
 
 -- |Utility: A shorthand for instructionExecWhile

src/HushGP/TH.hs

@@ -2,11 +2,35 @@
 module HushGP.TH where
 
 import System.IO
+import Text.Regex.TDFA
+import Data.List
+import HushGP.State
+import Language.Haskell.TH
+import Language.Haskell.TH.Syntax
+
+-- listFields :: Name -> Q [Dec]
+-- listFields name = do
+  -- TyConI (DataD _ _ _ [RecC _ fields] _ ) <- reify name
+
+strHead :: [String] -> String
+strHead strxs =
+  case uncons strxs of
+    Just (str, _) -> str
+    _ -> []
+
+instructionRegex :: String
+instructionRegex = "instruction[a-zA-Z0-9]* ::" 
+
+testRegex :: String -> Bool
+testRegex str = str =~ instructionRegex :: Bool
 
 thTest :: IO ()
 thTest = do
   handle <- openFile "src/HushGP/Instructions/IntInstructions.hs" ReadMode
   let list = hGetContents handle
   toPrint <- list
-  print toPrint
+  let funcs = map (strHead . words) (filter testRegex (lines toPrint))
+  let names = map (newName :: (String -> IO Name)) funcs
   hClose handle
+  print "hello"
+  -- let instruction = "instructionIntAdd"