commit 084994e2df4b197dbdd067333a7207c12eb8ec33
parent a76c7fea68278a5017d4913b40c4a4947368e026
Author: James Eversole <james@eversole.co>
Date: Thu, 24 Apr 2025 12:14:38 -0500
Clean up and list SKI conversion fix
Diffstat:
6 files changed, 141 insertions(+), 81 deletions(-)
diff --git a/src/Eval.hs b/src/Eval.hs
@@ -62,27 +62,39 @@ evalAST env term
elimLambda :: TricuAST -> TricuAST
elimLambda = go
where
- -- η-reduction
- go (SLambda [v] (SApp f (SVar x)))
- | v == x && not (isFree v f) = elimLambda f
- -- Triage optimization
- go (SLambda [a] (SLambda [b] (SLambda [c] body)))
- | body == triageBody = _TRIAGE
- where
- triageBody =
- SApp (SApp TLeaf (SApp (SApp TLeaf (SVar a)) (SVar b))) (SVar c)
- -- Composition optimization
- go (SLambda [f] (SLambda [g] (SLambda [x] body)))
- | body == SApp (SVar f) (SApp (SVar g) (SVar x)) = _B
- -- General elimination
- go (SLambda [v] (SList xs))
- = elimLambda (SLambda [v] (foldr wrapTLeaf TLeaf xs))
- where wrapTLeaf m r = SApp (SApp TLeaf m) r
- go (SLambda (v:vs) body)
- | null vs = toSKI v (elimLambda body)
- | otherwise = elimLambda (SLambda [v] (SLambda vs body))
- go (SApp f g) = SApp (elimLambda f) (elimLambda g)
- go x = x
+ go term
+ | etaReduction term = elimLambda $ etaReduceResult term
+ | triagePattern term = _TRI
+ | composePattern term = _B
+ | lambdaList term = elimLambda $ lambdaListResult term
+ | nestedLambda term = nestedLambdaResult term
+ | application term = applicationResult term
+ | otherwise = term
+
+ etaReduction (SLambda [v] (SApp f (SVar x))) = v == x && not (isFree v f)
+ etaReduction _ = False
+ etaReduceResult (SLambda [_] (SApp f _)) = f
+
+ triagePattern (SLambda [a] (SLambda [b] (SLambda [c] body))) = body == triageBody a b c
+ triagePattern _ = False
+
+ composePattern (SLambda [f] (SLambda [g] (SLambda [x] body))) = body == composeBody f g x
+ composePattern _ = False
+
+ lambdaList (SLambda [_] (SList _)) = True
+ lambdaList _ = False
+ lambdaListResult (SLambda [v] (SList xs)) = SLambda [v] (foldr wrapTLeaf TLeaf xs)
+ wrapTLeaf m r = SApp (SApp TLeaf m) r
+
+ nestedLambda (SLambda (_:_) _) = True
+ nestedLambda _ = False
+ nestedLambdaResult (SLambda (v:vs) body)
+ | null vs = toSKI v (elimLambda body)
+ | otherwise = elimLambda (SLambda [v] (SLambda vs body))
+
+ application (SApp _ _) = True
+ application _ = False
+ applicationResult (SApp f g) = SApp (elimLambda f) (elimLambda g)
toSKI x (SVar y)
| x == y = _I
@@ -90,30 +102,38 @@ elimLambda = go
toSKI x t@(SApp n u)
| not (isFree x t) = SApp _K t
| otherwise = SApp (SApp _S (toSKI x n)) (toSKI x u)
+ toSKI x (SList xs)
+ | not (isFree x (SList xs)) = SApp _K (SList xs)
+ | otherwise = SList (map (toSKI x) xs)
toSKI x t
| not (isFree x t) = SApp _K t
| otherwise = errorWithoutStackTrace "Unhandled toSKI conversion"
- _S = parseSingle "t (t (t t t)) t"
- _K = parseSingle "t t"
- _I = parseSingle "t (t (t t)) t"
- _B = parseSingle "t (t (t t (t (t (t t t)) t))) (t t)"
- _TRIAGE = parseSingle "t (t (t t (t (t (t t t))))) t"
+ -- Combinators and special forms
+ _S = parseSingle "t (t (t t t)) t"
+ _K = parseSingle "t t"
+ _I = parseSingle "t (t (t t)) t"
+ _B = parseSingle "t (t (t t (t (t (t t t)) t))) (t t)"
+ _TRI = parseSingle "t (t (t t (t (t (t t t))))) t"
+
+ -- Pattern bodies
+ triageBody a b c = SApp (SApp TLeaf (SApp (SApp TLeaf (SVar a)) (SVar b))) (SVar c)
+ composeBody f g x = SApp (SVar f) (SApp (SVar g) (SVar x))
isFree :: String -> TricuAST -> Bool
isFree x = Set.member x . freeVars
freeVars :: TricuAST -> Set.Set String
freeVars (SVar v ) = Set.singleton v
-freeVars (SInt _ ) = Set.empty
-freeVars (SStr _ ) = Set.empty
freeVars (SList s ) = foldMap freeVars s
+freeVars (SLambda v b ) = foldr Set.delete (freeVars b) v
freeVars (SApp f a ) = freeVars f <> freeVars a
-freeVars TLeaf = Set.empty
+freeVars (TFork l r ) = freeVars l <> freeVars r
freeVars (SDef _ _ b) = freeVars b
freeVars (TStem t ) = freeVars t
-freeVars (TFork l r ) = freeVars l <> freeVars r
-freeVars (SLambda v b ) = foldr Set.delete (freeVars b) v
+freeVars (SInt _ ) = Set.empty
+freeVars (SStr _ ) = Set.empty
+freeVars TLeaf = Set.empty
freeVars _ = Set.empty
reorderDefs :: Env -> [TricuAST] -> [TricuAST]
@@ -131,7 +151,7 @@ reorderDefs env defs
graph = buildDepGraph defsOnly
sortedDefs = sortDeps graph
defMap = Map.fromList [(name, def) | def@(SDef name _ _) <- defsOnly]
- orderedDefs = map (\name -> defMap Map.! name) sortedDefs
+ orderedDefs = map (defMap Map.!) sortedDefs
freeVarsDefs = foldMap snd defsWithFreeVars
freeVarsOthers = foldMap freeVars others
@@ -139,8 +159,8 @@ reorderDefs env defs
validNames = Set.fromList defNames `Set.union` Set.fromList (Map.keys env)
missingDeps = Set.toList (allFreeVars `Set.difference` validNames)
- isDef (SDef _ _ _) = True
- isDef _ = False
+ isDef SDef {} = True
+ isDef _ = False
buildDepGraph :: [TricuAST] -> Map.Map String (Set.Set String)
buildDepGraph topDefs
diff --git a/src/Main.hs b/src/Main.hs
@@ -63,18 +63,17 @@ main = do
case args of
Repl -> do
putStrLn "Welcome to the tricu REPL"
- putStrLn "You can exit with `CTRL+D` or the `!exit` command.`"
+ putStrLn "You may exit with `CTRL+D` or the `!exit` command."
+ putStrLn "Try typing `!` with tab completion for more commands."
repl Map.empty
Evaluate { file = filePaths, form = form } -> do
result <- case filePaths of
- [] -> do
- t <- getContents
- pure $ runTricu t
+ [] -> runTricuT <$> getContents
(filePath:restFilePaths) -> do
initialEnv <- evaluateFile filePath
finalEnv <- foldM evaluateFileWithContext initialEnv restFilePaths
pure $ mainResult finalEnv
- let fRes = formatResult form result
+ let fRes = formatT form result
putStr fRes
TDecode { file = filePaths } -> do
value <- case filePaths of
@@ -82,8 +81,48 @@ main = do
(filePath:_) -> readFile filePath
putStrLn $ decodeResult $ result $ evalTricu Map.empty $ parseTricu value
-runTricu :: String -> T
-runTricu input =
+-- Simple interfaces
+
+runTricu :: String -> String
+runTricu = formatT TreeCalculus . runTricuT
+
+runTricuT :: String -> T
+runTricuT input =
let asts = parseTricu input
finalEnv = evalTricu Map.empty asts
in result finalEnv
+
+runTricuEnv :: Env -> String -> String
+runTricuEnv env = formatT TreeCalculus . runTricuTEnv env
+
+runTricuTEnv :: Env -> String -> T
+runTricuTEnv env input =
+ let asts = parseTricu input
+ finalEnv = evalTricu env asts
+ in result finalEnv
+
+runTricuWithEnvT :: String -> (Env, T)
+runTricuWithEnvT input =
+ let asts = parseTricu input
+ finalEnv = evalTricu Map.empty asts
+ in (finalEnv, result finalEnv)
+
+runTricuWithEnv :: String -> (Env, String)
+runTricuWithEnv input =
+ let asts = parseTricu input
+ finalEnv = evalTricu Map.empty asts
+ res = result finalEnv
+ in (finalEnv, formatT TreeCalculus res)
+
+runTricuEnvWithEnvT :: Env -> String -> (Env, T)
+runTricuEnvWithEnvT env input =
+ let asts = parseTricu input
+ finalEnv = evalTricu env asts
+ in (finalEnv, result finalEnv)
+
+runTricuEnvWithEnv :: Env -> String -> (Env, String)
+runTricuEnvWithEnv env input =
+ let asts = parseTricu input
+ finalEnv = evalTricu env asts
+ res = result finalEnv
+ in (finalEnv, formatT TreeCalculus res)
+\ No newline at end of file
diff --git a/src/REPL.hs b/src/REPL.hs
@@ -152,7 +152,7 @@ repl env = runInputT settings (withInterrupt (loop env Decode))
newEnv = evalTricu env asts
case Map.lookup "!result" newEnv of
Just r -> do
- putStrLn $ "tricu > " ++ formatResult form r
+ putStrLn $ "tricu > " ++ formatT form r
Nothing -> pure ()
return newEnv
@@ -182,7 +182,7 @@ repl env = runInputT settings (withInterrupt (loop env Decode))
liftIO $ writeFile filepath ""
outputStrLn "File created..."
forM_ definitions $ \(name, value) -> do
- let content = name ++ " = " ++ formatResult TreeCalculus value ++ "\n"
+ let content = name ++ " = " ++ formatT TreeCalculus value ++ "\n"
outputStrLn $ "Writing definition: " ++ name ++ " with length " ++ show (length content)
liftIO $ appendFile filepath content
outputStrLn $ "Saved " ++ show (length definitions) ++ " definitions to " ++ p
diff --git a/src/Research.hs b/src/Research.hs
@@ -15,7 +15,7 @@ data T = Leaf | Stem T | Fork T T
-- Abstract Syntax Tree for tricu
data TricuAST
= SVar String
- | SInt Int
+ | SInt Integer
| SStr String
| SList [TricuAST]
| SDef String [String] TricuAST
@@ -33,7 +33,7 @@ data LToken
= LKeywordT
| LIdentifier String
| LNamespace String
- | LIntegerLiteral Int
+ | LIntegerLiteral Integer
| LStringLiteral String
| LAssign
| LColon
@@ -84,9 +84,9 @@ _not = Fork (Fork _true (Fork Leaf _false)) Leaf
-- Marshalling
ofString :: String -> T
-ofString str = ofList $ map (ofNumber . fromEnum) str
+ofString str = ofList $ map (ofNumber . toInteger . fromEnum) str
-ofNumber :: Int -> T
+ofNumber :: Integer -> T
ofNumber 0 = Leaf
ofNumber n =
Fork
@@ -96,7 +96,7 @@ ofNumber n =
ofList :: [T] -> T
ofList = foldr Fork Leaf
-toNumber :: T -> Either String Int
+toNumber :: T -> Either String Integer
toNumber Leaf = Right 0
toNumber (Fork Leaf rest) = case toNumber rest of
Right n -> Right (2 * n)
@@ -108,7 +108,7 @@ toNumber _ = Left "Invalid Tree Calculus number"
toString :: T -> Either String String
toString tc = case toList tc of
- Right list -> traverse (fmap toEnum . toNumber) list
+ Right list -> traverse (fmap (toEnum . fromInteger) . toNumber) list
Left err -> Left "Invalid Tree Calculus string"
toList :: T -> Either String [T]
@@ -119,13 +119,13 @@ toList (Fork x rest) = case toList rest of
toList _ = Left "Invalid Tree Calculus list"
-- Outputs
-formatResult :: EvaluatedForm -> T -> String
-formatResult TreeCalculus = toSimpleT . show
-formatResult FSL = show
-formatResult AST = show . toAST
-formatResult Ternary = toTernaryString
-formatResult Ascii = toAscii
-formatResult Decode = decodeResult
+formatT :: EvaluatedForm -> T -> String
+formatT TreeCalculus = toSimpleT . show
+formatT FSL = show
+formatT AST = show . toAST
+formatT Ternary = toTernaryString
+formatT Ascii = toAscii
+formatT Decode = decodeResult
toSimpleT :: String -> String
toSimpleT s = T.unpack
@@ -166,7 +166,7 @@ decodeResult tc =
(_, _, Right n) -> show n
(_, Right xs@(_:_), _) -> "[" ++ intercalate ", " (map decodeResult xs) ++ "]"
(_, Right [], _) -> "[]"
- _ -> formatResult TreeCalculus tc
+ _ -> formatT TreeCalculus tc
where
isCommonChar c =
let n = fromEnum c
diff --git a/test/Spec.hs b/test/Spec.hs
@@ -21,8 +21,8 @@ import qualified Data.Set as Set
main :: IO ()
main = defaultMain tests
-runTricu :: String -> String
-runTricu s = show $ result (evalTricu Map.empty $ parseTricu s)
+tricuTestString :: String -> String
+tricuTestString s = show $ result (evalTricu Map.empty $ parseTricu s)
tests :: TestTree
tests = testGroup "Tricu Tests"
@@ -266,7 +266,7 @@ simpleEvaluation = testGroup "Evaluation Tests"
, testCase "Immutable definitions" $ do
let input = "x = t t\nx = t\nx"
env = evalTricu Map.empty (parseTricu input)
- result <- try (evaluate (runTricu input)) :: IO (Either SomeException String)
+ result <- try (evaluate (tricuTestString input)) :: IO (Either SomeException String)
case result of
Left _ -> return ()
Right _ -> assertFailure "Expected evaluation error"
@@ -283,84 +283,84 @@ lambdas :: TestTree
lambdas = testGroup "Lambda Evaluation Tests"
[ testCase "Lambda Identity Function" $ do
let input = "id = (x : x)\nid t"
- runTricu input @?= "Leaf"
+ tricuTestString input @?= "Leaf"
, testCase "Lambda Constant Function (K combinator)" $ do
let input = "k = (x y : x)\nk t (t t)"
- runTricu input @?= "Leaf"
+ tricuTestString input @?= "Leaf"
, testCase "Lambda Application with Variable" $ do
let input = "id = (x : x)\nval = t t\nid val"
- runTricu input @?= "Stem Leaf"
+ tricuTestString input @?= "Stem Leaf"
, testCase "Lambda Application with Multiple Arguments" $ do
let input = "apply = (f x y : f x y)\nk = (a b : a)\napply k t (t t)"
- runTricu input @?= "Leaf"
+ tricuTestString input @?= "Leaf"
, testCase "Nested Lambda Application" $ do
let input = "apply = (f x y : f x y)\nid = (x : x)\napply (f x : f x) id t"
- runTricu input @?= "Leaf"
+ tricuTestString input @?= "Leaf"
, testCase "Lambda with a complex body" $ do
let input = "f = (x : t (t x))\nf t"
- runTricu input @?= "Stem (Stem Leaf)"
+ tricuTestString input @?= "Stem (Stem Leaf)"
, testCase "Lambda returning a function" $ do
let input = "f = (x : (y : x))\ng = f t\ng (t t)"
- runTricu input @?= "Leaf"
+ tricuTestString input @?= "Leaf"
, testCase "Lambda with Shadowing" $ do
let input = "f = (x : (x : x))\nf t (t t)"
- runTricu input @?= "Stem Leaf"
+ tricuTestString input @?= "Stem Leaf"
, testCase "Lambda returning another lambda" $ do
let input = "k = (x : (y : x))\nk_app = k t\nk_app (t t)"
- runTricu input @?= "Leaf"
+ tricuTestString input @?= "Leaf"
, testCase "Lambda with free variables" $ do
let input = "y = t t\nf = (x : y)\nf t"
- runTricu input @?= "Stem Leaf"
+ tricuTestString input @?= "Stem Leaf"
, testCase "SKI Composition" $ do
let input = "s = (x y z : x z (y z))\nk = (x y : x)\ni = (x : x)\ncomp = s k i\ncomp t (t t)"
- runTricu input @?= "Stem (Stem Leaf)"
+ tricuTestString input @?= "Stem (Stem Leaf)"
, testCase "Lambda with multiple parameters and application" $ do
let input = "f = (a b c : t a b c)\nf t (t t) (t t t)"
- runTricu input @?= "Stem Leaf"
+ tricuTestString input @?= "Stem Leaf"
, testCase "Lambda with nested application in the body" $ do
let input = "f = (x : t (t (t x)))\nf t"
- runTricu input @?= "Stem (Stem (Stem Leaf))"
+ tricuTestString input @?= "Stem (Stem (Stem Leaf))"
, testCase "Lambda returning a function and applying it" $ do
let input = "f = (x : (y : t x y))\ng = f t\ng (t t)"
- runTricu input @?= "Fork Leaf (Stem Leaf)"
+ tricuTestString input @?= "Fork Leaf (Stem Leaf)"
, testCase "Lambda applying a variable" $ do
let input = "id = (x : x)\na = t t\nid a"
- runTricu input @?= "Stem Leaf"
+ tricuTestString input @?= "Stem Leaf"
, testCase "Nested lambda abstractions in the same expression" $ do
let input = "f = (x : (y : x y))\ng = (z : z)\nf g t"
- runTricu input @?= "Leaf"
+ tricuTestString input @?= "Leaf"
, testCase "Lambda applied to string literal" $ do
let input = "f = (x : x)\nf \"hello\""
- runTricu input @?= "Fork (Fork Leaf (Fork Leaf (Fork Leaf (Fork (Stem Leaf) (Fork Leaf (Fork (Stem Leaf) (Fork (Stem Leaf) Leaf))))))) (Fork (Fork (Stem Leaf) (Fork Leaf (Fork (Stem Leaf) (Fork Leaf (Fork Leaf (Fork (Stem Leaf) (Fork (Stem Leaf) Leaf))))))) (Fork (Fork Leaf (Fork Leaf (Fork (Stem Leaf) (Fork (Stem Leaf) (Fork Leaf (Fork (Stem Leaf) (Fork (Stem Leaf) Leaf))))))) (Fork (Fork Leaf (Fork Leaf (Fork (Stem Leaf) (Fork (Stem Leaf) (Fork Leaf (Fork (Stem Leaf) (Fork (Stem Leaf) Leaf))))))) (Fork (Fork (Stem Leaf) (Fork (Stem Leaf) (Fork (Stem Leaf) (Fork (Stem Leaf) (Fork Leaf (Fork (Stem Leaf) (Fork (Stem Leaf) Leaf))))))) Leaf))))"
+ tricuTestString input @?= "Fork (Fork Leaf (Fork Leaf (Fork Leaf (Fork (Stem Leaf) (Fork Leaf (Fork (Stem Leaf) (Fork (Stem Leaf) Leaf))))))) (Fork (Fork (Stem Leaf) (Fork Leaf (Fork (Stem Leaf) (Fork Leaf (Fork Leaf (Fork (Stem Leaf) (Fork (Stem Leaf) Leaf))))))) (Fork (Fork Leaf (Fork Leaf (Fork (Stem Leaf) (Fork (Stem Leaf) (Fork Leaf (Fork (Stem Leaf) (Fork (Stem Leaf) Leaf))))))) (Fork (Fork Leaf (Fork Leaf (Fork (Stem Leaf) (Fork (Stem Leaf) (Fork Leaf (Fork (Stem Leaf) (Fork (Stem Leaf) Leaf))))))) (Fork (Fork (Stem Leaf) (Fork (Stem Leaf) (Fork (Stem Leaf) (Fork (Stem Leaf) (Fork Leaf (Fork (Stem Leaf) (Fork (Stem Leaf) Leaf))))))) Leaf))))"
, testCase "Lambda applied to integer literal" $ do
let input = "f = (x : x)\nf 42"
- runTricu input @?= "Fork Leaf (Fork (Stem Leaf) (Fork Leaf (Fork (Stem Leaf) (Fork Leaf (Fork (Stem Leaf) Leaf)))))"
+ tricuTestString input @?= "Fork Leaf (Fork (Stem Leaf) (Fork Leaf (Fork (Stem Leaf) (Fork Leaf (Fork (Stem Leaf) Leaf)))))"
, testCase "Lambda applied to list literal" $ do
let input = "f = (x : x)\nf [t (t t)]"
- runTricu input @?= "Fork Leaf (Fork (Stem Leaf) Leaf)"
+ tricuTestString input @?= "Fork Leaf (Fork (Stem Leaf) Leaf)"
, testCase "Lambda containing list literal" $ do
let input = "(a : [(a)]) 1"
- runTricu input @?= "Fork (Fork (Stem Leaf) Leaf) Leaf"
+ tricuTestString input @?= "Fork (Fork (Stem Leaf) Leaf) Leaf"
]
providedLibraries :: TestTree
diff --git a/tricu.cabal b/tricu.cabal
@@ -1,7 +1,7 @@
cabal-version: 1.12
name: tricu
-version: 0.18.1
+version: 0.19.0
description: A micro-language for exploring Tree Calculus
author: James Eversole
maintainer: james@eversole.co
