Rename from sapling to tricu

src/Eval.hs

@@ -8,7 +8,7 @@ import qualified Data.Map as Map
 import Data.List (foldl')
 import qualified Data.Set as Set
 
-evalSingle :: Map String T -> SaplingAST -> Map String T
+evalSingle :: Map String T -> TricuAST -> Map String T
 evalSingle env term = case term of
   SFunc name [] body ->
     let lineNoLambda = eliminateLambda body
@@ -28,18 +28,18 @@ evalSingle env term = case term of
     let result = evalAST env term
     in Map.insert "__result" result env
 
-evalSapling :: Map String T -> [SaplingAST] -> Map String T
-evalSapling env [] = env
-evalSapling env [lastLine] =
+evalTricu :: Map String T -> [TricuAST] -> Map String T
+evalTricu env [] = env
+evalTricu env [lastLine] =
     let lastLineNoLambda = eliminateLambda lastLine
         updatedEnv = evalSingle env lastLineNoLambda
     in Map.insert "__result" (result updatedEnv) updatedEnv
-evalSapling env (line:rest) =
+evalTricu env (line:rest) =
     let lineNoLambda = eliminateLambda line
         updatedEnv = evalSingle env lineNoLambda
-    in evalSapling updatedEnv rest
+    in evalTricu updatedEnv rest
 
-evalAST :: Map String T -> SaplingAST -> T
+evalAST :: Map String T -> TricuAST -> T
 evalAST env term = case term of
     SVar name -> case Map.lookup name env of
         Just value -> value
@@ -56,7 +56,7 @@ evalAST env term = case term of
         ++ " in evalAST; define via evalSingle."
     SLambda {} -> error "Internal error: SLambda found in evalAST after elimination."
 
-eliminateLambda :: SaplingAST -> SaplingAST
+eliminateLambda :: TricuAST -> TricuAST
 eliminateLambda (SLambda (v:vs) body)
   | null vs = lambdaToT v (eliminateLambda body)
   | otherwise = eliminateLambda (SLambda [v] (SLambda vs body))
@@ -69,7 +69,7 @@ eliminateLambda other = other
 -- This is my attempt to implement the lambda calculus elimination rules defined
 -- in "Typed Program Analysis without Encodings" by Barry Jay.
 -- https://github.com/barry-jay-personal/typed_tree_calculus/blob/main/typed_program_analysis.pdf
-lambdaToT :: String -> SaplingAST -> SaplingAST
+lambdaToT :: String -> TricuAST -> TricuAST
 lambdaToT x (SVar y)
   | x == y = tI
 lambdaToT x (SVar y)
@@ -83,7 +83,7 @@ lambdaToT x body
   | not (isFree x body) = SApp tK body
   | otherwise = SApp (SApp tS (lambdaToT x body)) TLeaf
 
-freeVars :: SaplingAST -> Set.Set String
+freeVars :: TricuAST -> Set.Set String
 freeVars (SVar v) = Set.singleton v
 freeVars (SInt _) = Set.empty
 freeVars (SStr _) = Set.empty
@@ -95,23 +95,23 @@ freeVars (TStem t) = freeVars t
 freeVars (TFork l r) = freeVars l <> freeVars r
 freeVars (SLambda vs b) = foldr Set.delete (freeVars b) vs
 
-isFree :: String -> SaplingAST -> Bool
+isFree :: String -> TricuAST -> Bool
 isFree x = Set.member x . freeVars
 
-toAST :: T -> SaplingAST
+toAST :: T -> TricuAST
 toAST Leaf = TLeaf
 toAST (Stem a) = TStem (toAST a)
 toAST (Fork a b) = TFork (toAST a) (toAST b)
 
--- We need the SKI operators in an unevaluated SaplingAST tree form so that we
+-- We need the SKI operators in an unevaluated TricuAST tree form so that we
 -- can keep the evaluation functions straightforward
-tI :: SaplingAST
+tI :: TricuAST
 tI = SApp (SApp TLeaf (SApp TLeaf (SApp TLeaf TLeaf))) TLeaf
 
-tK :: SaplingAST
+tK :: TricuAST
 tK = SApp TLeaf TLeaf
 
-tS :: SaplingAST
+tS :: TricuAST
 tS = SApp (SApp TLeaf (SApp TLeaf (SApp (SApp TLeaf TLeaf) TLeaf))) TLeaf
 
 result :: Map String T -> T