From 920ea92cb9b6fbb7a001b414006ffe5e4febe71a Mon Sep 17 00:00:00 2001
From: Taylor <taylorpat@umsystem.edu>
Date: Thu, 16 Jan 2025 12:38:18 -0600
Subject: [PATCH] refactored names of genes for consistency
---
src/Push.hs | 46 +++++++++++++++++++++++-----------------------
tests/Main.hs | 27 +++++++++++++--------------
2 files changed, 36 insertions(+), 37 deletions(-)
diff --git a/src/Push.hs b/src/Push.hs
index 348ec56..3154933 100644
--- a/src/Push.hs
+++ b/src/Push.hs
@@ -9,20 +9,20 @@ import qualified Data.Map as Map
-- One solution is for the exec stack to be a list of [Gene].
-- The parameter stack could be singular [Gene] or multiple [atomic] types.
data Gene
- = IntGene Int
- | FloatGene Float
- | BoolGene Bool
- | StringGene String
+ = GeneInt Int
+ | GeneFloat Float
+ | GeneBool Bool
+ | GeneString String
| StateFunc (State -> State)
| PlaceInput String
| Close
| Block [Gene]
instance Eq Gene where
- IntGene x == IntGene y = x == y
- FloatGene x == FloatGene y = x == y
- BoolGene x == BoolGene y = x == y
- StringGene x == StringGene y = x == y
+ GeneInt x == GeneInt y = x == y
+ GeneFloat x == GeneFloat y = x == y
+ GeneBool x == GeneBool y = x == y
+ GeneString x == GeneString y = x == y
PlaceInput x == PlaceInput y = x == y
Close == Close = True
StateFunc x == StateFunc y = True -- This line is probably not the best thing to do
@@ -30,10 +30,10 @@ instance Eq Gene where
_ == _ = False
instance Show Gene where
- show (IntGene x) = "Int: " <> show x
- show (FloatGene x) = "Float: " <> show x
- show (BoolGene x) = "Bool: " <> show x
- show (StringGene x) = "String: " <> x
+ show (GeneInt x) = "Int: " <> show x
+ show (GeneFloat x) = "Float: " <> show x
+ show (GeneBool x) = "Bool: " <> show x
+ show (GeneString x) = "String: " <> x
show (StateFunc func) = "Func: unnamed"
show (PlaceInput x) = "In: " <> x
show Close = "Close"
@@ -138,7 +138,7 @@ instructionExecDup state = state
instructionExecDoRange :: State -> State
instructionExecDoRange (State (e1 : es) (i0 : i1 : is) fs bs ss ps im) =
if increment i0 i1 /= 0
- then State (e1 : Block [IntGene (i1 + increment i0 i1), IntGene i0, StateFunc instructionExecDoRange, e1] : es) (i1 : is) fs bs ss ps im
+ then State (e1 : Block [GeneInt (i1 + increment i0 i1), GeneInt i0, StateFunc instructionExecDoRange, e1] : es) (i1 : is) fs bs ss ps im
else State (e1 : es) (i1 : is) fs bs ss ps im
where
increment :: Int -> Int -> Int
@@ -152,14 +152,14 @@ instructionExecDoCount :: State -> State
instructionExecDoCount state@(State (e1 : es) (i1 : is) fs bs ss ps im) =
if i1 < 1
then state
- else state {exec = Block [IntGene 0, IntGene $ i1 - 1, StateFunc instructionExecDoRange, e1] : es, int = is}
+ else state {exec = Block [GeneInt 0, GeneInt $ i1 - 1, StateFunc instructionExecDoRange, e1] : es, int = is}
instructionExecDoCount state = state
instructionExecDoTimes :: State -> State
instructionExecDoTimes state@(State (e1 : es) (i1 : is) fs bs ss ps im) =
if i1 < 1
then state
- else state {exec = Block [IntGene 0, IntGene $ i1 - 1, StateFunc instructionExecDoRange, Block [StateFunc instructionIntPop, e1]] : es, int = is}
+ else state {exec = Block [GeneInt 0, GeneInt $ i1 - 1, StateFunc instructionExecDoRange, Block [StateFunc instructionIntPop, e1]] : es, int = is}
instructionExecDoTimes state = state
instructionExecWhile :: State -> State
@@ -188,10 +188,10 @@ instructionExecWhen state = state
-- Optionally, split this off into independent functions
instructionParameterLoad :: State -> State
instructionParameterLoad (State es is fs bs ss (p : ps) im) = case p of
- (IntGene val) -> State es (val : is) fs bs ss ps im
- (FloatGene val) -> State es is (val : fs) bs ss ps im
- (BoolGene val) -> State es is fs (val : bs) ss ps im
- (StringGene val) -> State es is fs bs (val : ss) ps im
+ (GeneInt val) -> State es (val : is) fs bs ss ps im
+ (GeneFloat val) -> State es is (val : fs) bs ss ps im
+ (GeneBool val) -> State es is fs (val : bs) ss ps im
+ (GeneString val) -> State es is fs bs (val : ss) ps im
instructionParameterLoad state = state
-- Loads a genome into the exec stack
@@ -212,10 +212,10 @@ interpretExec :: State -> State
interpretExec (State [] is fs bs ss ps im) = State [] is fs bs ss ps im
interpretExec (State (e : es) is fs bs ss ps im) =
case e of
- (IntGene val) -> interpretExec (State es (val : is) fs bs ss ps im)
- (FloatGene val) -> interpretExec (State es is (val : fs) bs ss ps im)
- (BoolGene val) -> interpretExec (State es is fs (val : bs) ss ps im)
- (StringGene val) -> interpretExec (State es is fs bs (val : ss) ps im)
+ (GeneInt val) -> interpretExec (State es (val : is) fs bs ss ps im)
+ (GeneFloat val) -> interpretExec (State es is (val : fs) bs ss ps im)
+ (GeneBool val) -> interpretExec (State es is fs (val : bs) ss ps im)
+ (GeneString val) -> interpretExec (State es is fs bs (val : ss) ps im)
(StateFunc func) -> interpretExec (func (State es is fs bs ss ps im))
(Block block) -> interpretExec (State (block ++ es) is fs bs ss ps im)
(PlaceInput input) -> interpretExec (State (im Map.! input : es) is fs bs ss ps im)
diff --git a/tests/Main.hs b/tests/Main.hs
index 47e462d..d101105 100644
--- a/tests/Main.hs
+++ b/tests/Main.hs
@@ -7,21 +7,20 @@ intTestFunc name goal genome startState =
let state = loadProgram genome startState
in assert (goal == int (interpretExec state)) putStrLn (name ++ " passed test.")
-
main :: IO ()
main = do
- intTestFunc "instructionIntAdd" [8] [IntGene 6, IntGene 2, StateFunc instructionIntAdd] emptyState
- intTestFunc "instructionIntSub" [4] [IntGene 6, IntGene 2, StateFunc instructionIntSub] emptyState
- intTestFunc "instructionIntMul" [12] [IntGene 6, IntGene 2, StateFunc instructionIntMul] emptyState
- intTestFunc "instructionIntDiv" [3] [IntGene 6, IntGene 2, StateFunc instructionIntDiv] emptyState
- intTestFunc "instructionExecIf" [6, 5] [BoolGene True, StateFunc instructionExecIf, Block [IntGene 5, IntGene 6], Block [IntGene 7, IntGene 8]] emptyState
- intTestFunc "instructionExecDup" [8] [StateFunc instructionExecDup, IntGene 4, StateFunc instructionIntAdd] emptyState
- intTestFunc "instructionExecDoRange" [12] [IntGene 2, Block [IntGene 4, IntGene 1, StateFunc instructionExecDoRange], StateFunc instructionIntAdd] emptyState
- intTestFunc "instructionExecDoCount" [8] [IntGene 2, Block [IntGene 4, StateFunc instructionExecDoCount], StateFunc instructionIntAdd] emptyState
- intTestFunc "instructionIntAdd" [69, 69, 69, 69, 2] [IntGene 2, Block [IntGene 4, StateFunc instructionExecDoTimes], IntGene 69] emptyState
- intTestFunc "instructionExecDoTimes" [70, 70] [BoolGene False, BoolGene True, BoolGene True, StateFunc instructionExecWhile, IntGene 70] emptyState
- intTestFunc "instructionExecWhile" [70, 70, 70] [BoolGene False, BoolGene True, BoolGene True, StateFunc instructionExecDoWhile, IntGene 70] emptyState
- intTestFunc "instructionExecDoWhile" [71] [BoolGene True, StateFunc instructionExecWhen, IntGene 71] emptyState
+ intTestFunc "instructionIntAdd" [8] [GeneInt 6, GeneInt 2, StateFunc instructionIntAdd] emptyState
+ intTestFunc "instructionIntSub" [4] [GeneInt 6, GeneInt 2, StateFunc instructionIntSub] emptyState
+ intTestFunc "instructionIntMul" [12] [GeneInt 6, GeneInt 2, StateFunc instructionIntMul] emptyState
+ intTestFunc "instructionIntDiv" [3] [GeneInt 6, GeneInt 2, StateFunc instructionIntDiv] emptyState
+ intTestFunc "instructionExecIf" [6, 5] [GeneBool True, StateFunc instructionExecIf, Block [GeneInt 5, GeneInt 6], Block [GeneInt 7, GeneInt 8]] emptyState
+ intTestFunc "instructionExecDup" [8] [StateFunc instructionExecDup, GeneInt 4, StateFunc instructionIntAdd] emptyState
+ intTestFunc "instructionExecDoRange" [12] [GeneInt 2, Block [GeneInt 4, GeneInt 1, StateFunc instructionExecDoRange], StateFunc instructionIntAdd] emptyState
+ intTestFunc "instructionExecDoCount" [8] [GeneInt 2, Block [GeneInt 4, StateFunc instructionExecDoCount], StateFunc instructionIntAdd] emptyState
+ intTestFunc "instructionIntAdd" [69, 69, 69, 69, 2] [GeneInt 2, Block [GeneInt 4, StateFunc instructionExecDoTimes], GeneInt 69] emptyState
+ intTestFunc "instructionExecDoTimes" [70, 70] [GeneBool False, GeneBool True, GeneBool True, StateFunc instructionExecWhile, GeneInt 70] emptyState
+ intTestFunc "instructionExecWhile" [70, 70, 70] [GeneBool False, GeneBool True, GeneBool True, StateFunc instructionExecDoWhile, GeneInt 70] emptyState
+ intTestFunc "instructionExecDoWhile" [71] [GeneBool True, StateFunc instructionExecWhen, GeneInt 71] emptyState
- let loadedState = loadProgram [BoolGene False, StateFunc instructionExecWhen, IntGene 71] emptyState
+ let loadedState = loadProgram [GeneBool False, StateFunc instructionExecWhen, GeneInt 71] emptyState
assert (emptyState == interpretExec loadedState) putStrLn "instructionExecWhen passed test."