Rename from sapling to tricu

src/Parser.hs

@@ -13,33 +13,33 @@ import Text.Megaparsec.Error (errorBundlePretty, ParseErrorBundle)
 
 type Parser = Parsec Void [LToken]
 
-data SaplingAST
+data TricuAST
   = SVar String
   | SInt Int
   | SStr String
-  | SList [SaplingAST]
-  | SFunc String [String] SaplingAST
-  | SApp SaplingAST SaplingAST
+  | SList [TricuAST]
+  | SFunc String [String] TricuAST
+  | SApp TricuAST TricuAST
   | TLeaf
-  | TStem SaplingAST
-  | TFork SaplingAST SaplingAST
-  | SLambda [String] SaplingAST
+  | TStem TricuAST
+  | TFork TricuAST TricuAST
+  | SLambda [String] TricuAST
   deriving (Show, Eq, Ord)
 
-parseSapling :: String -> [SaplingAST]
-parseSapling input =
+parseTricu :: String -> [TricuAST]
+parseTricu input =
   let nonEmptyLines = filter (not . null) (lines input)
   in map parseSingle nonEmptyLines
 
-parseSingle :: String -> SaplingAST
-parseSingle input = case runParser parseExpression "" (lexSapling input) of
+parseSingle :: String -> TricuAST
+parseSingle input = case runParser parseExpression "" (lexTricu input) of
   Left err -> error $ handleParseError err
   Right ast -> ast
 
 scnParser :: Parser ()
 scnParser = skipMany (satisfy isNewline)
 
-parseExpression :: Parser SaplingAST
+parseExpression :: Parser TricuAST
 parseExpression = choice
   [ try parseFunction
   , try parseLambda
@@ -50,7 +50,7 @@ parseExpression = choice
   , parseLiteral
   ]
 
-parseFunction :: Parser SaplingAST
+parseFunction :: Parser TricuAST
 parseFunction = do
   LIdentifier name <- satisfy isIdentifier
   args <- many (satisfy isIdentifier)
@@ -58,20 +58,20 @@ parseFunction = do
   body <- parseExpression
   return (SFunc name (map getIdentifier args) body)
 
-parseAtomicBase :: Parser SaplingAST
+parseAtomicBase :: Parser TricuAST
 parseAtomicBase = choice
     [ try parseVarWithoutAssignment
     , parseTreeLeaf
     , parseGrouped
     ]
-parseVarWithoutAssignment :: Parser SaplingAST
+parseVarWithoutAssignment :: Parser TricuAST
 parseVarWithoutAssignment = do
     LIdentifier name <- satisfy isIdentifier
     if (name == "t" || name == "__result")
     then fail $ "Reserved keyword: " ++ name ++ " cannot be assigned."
     else notFollowedBy (satisfy (== LAssign)) *> return (SVar name)
 
-parseLambda :: Parser SaplingAST
+parseLambda :: Parser TricuAST
 parseLambda = between (satisfy (== LOpenParen)) (satisfy (== LCloseParen)) $ do
   satisfy (== LBackslash)
   param    <- satisfy isIdentifier
@@ -81,13 +81,13 @@ parseLambda = between (satisfy (== LOpenParen)) (satisfy (== LCloseParen)) $ do
   let nestedLambda = foldr (\v acc -> SLambda [v] acc) body (map getIdentifier rest)
   return (SLambda [getIdentifier param] nestedLambda)
 
-parseLambdaExpression :: Parser SaplingAST
+parseLambdaExpression :: Parser TricuAST
 parseLambdaExpression = choice
   [ try parseLambdaApplication
   , parseAtomicLambda
   ]
 
-parseAtomicLambda :: Parser SaplingAST
+parseAtomicLambda :: Parser TricuAST
 parseAtomicLambda = choice
   [ parseVar
   , parseTreeLeaf
@@ -97,32 +97,32 @@ parseAtomicLambda = choice
   , between (satisfy (== LOpenParen)) (satisfy (== LCloseParen)) parseLambdaExpression
   ]
 
-parseApplication :: Parser SaplingAST
+parseApplication :: Parser TricuAST
 parseApplication = do
   func <- parseAtomicBase
   args <- many parseAtomic
   return $ foldl (\acc arg -> SApp acc arg) func args
 
-parseLambdaApplication :: Parser SaplingAST
+parseLambdaApplication :: Parser TricuAST
 parseLambdaApplication = do
   func <- parseAtomicLambda
   args <- many parseAtomicLambda
   return $ foldl (\acc arg -> SApp acc arg) func args
 
-isTreeTerm :: SaplingAST -> Bool
+isTreeTerm :: TricuAST -> Bool
 isTreeTerm TLeaf = True
 isTreeTerm (TStem _) = True
 isTreeTerm (TFork _ _) = True
 isTreeTerm _ = False
 
-parseTreeLeaf :: Parser SaplingAST
+parseTreeLeaf :: Parser TricuAST
 parseTreeLeaf = satisfy isKeywordT *> notFollowedBy (satisfy (== LAssign)) *> pure TLeaf
 
 getIdentifier :: LToken -> String
 getIdentifier (LIdentifier name) = name
 getIdentifier _ = error "Expected identifier"
 
-parseTreeTerm :: Parser SaplingAST
+parseTreeTerm :: Parser TricuAST
 parseTreeTerm = do
   base <- parseTreeLeafOrParenthesized
   rest <- many parseTreeLeafOrParenthesized
@@ -133,18 +133,18 @@ parseTreeTerm = do
       TStem t -> TFork t next
       TFork _ _ -> TFork acc next
 
-parseTreeLeafOrParenthesized :: Parser SaplingAST
+parseTreeLeafOrParenthesized :: Parser TricuAST
 parseTreeLeafOrParenthesized = choice
   [ between (satisfy (== LOpenParen)) (satisfy (== LCloseParen)) parseTreeTerm
   , parseTreeLeaf
   ]
 
-foldTree :: [SaplingAST] -> SaplingAST
+foldTree :: [TricuAST] -> TricuAST
 foldTree [] = TLeaf
 foldTree [x] = x
 foldTree (x:y:rest) = TFork x (foldTree (y:rest))
 
-parseAtomic :: Parser SaplingAST
+parseAtomic :: Parser TricuAST
 parseAtomic = choice
   [ parseVar
   , parseTreeLeaf
@@ -153,44 +153,44 @@ parseAtomic = choice
   , parseLiteral
   ]
 
-parseGrouped :: Parser SaplingAST
+parseGrouped :: Parser TricuAST
 parseGrouped = between (satisfy (== LOpenParen)) (satisfy (== LCloseParen)) parseExpression
 
-parseLiteral :: Parser SaplingAST
+parseLiteral :: Parser TricuAST
 parseLiteral = choice
   [ parseIntLiteral
   , parseStrLiteral
   ]
 
-parens :: Parser SaplingAST -> Parser SaplingAST
+parens :: Parser TricuAST -> Parser TricuAST
 parens p = do
   satisfy (== LOpenParen)
   result <- p
   satisfy (== LCloseParen)
   return result
 
-parseListLiteral :: Parser SaplingAST
+parseListLiteral :: Parser TricuAST
 parseListLiteral = do
   satisfy (== LOpenBracket)
   elements <- many parseListItem
   satisfy (== LCloseBracket)
   return (SList elements)
 
-parseListItem :: Parser SaplingAST
+parseListItem :: Parser TricuAST
 parseListItem = choice
   [ parseGroupedItem
   , parseListLiteral
   , parseSingleItem
   ]
 
-parseGroupedItem :: Parser SaplingAST
+parseGroupedItem :: Parser TricuAST
 parseGroupedItem = do
   satisfy (== LOpenParen)
   inner <- parseExpression
   satisfy (== LCloseParen)
   return inner
 
-parseSingleItem :: Parser SaplingAST
+parseSingleItem :: Parser TricuAST
 parseSingleItem = do
   token <- satisfy isListItem
   case token of
@@ -203,19 +203,19 @@ isListItem (LIdentifier _) = True
 isListItem LKeywordT = True
 isListItem _ = False
 
-parseVar :: Parser SaplingAST
+parseVar :: Parser TricuAST
 parseVar = do
   LIdentifier name <- satisfy isIdentifier
   if (name == "t" || name == "__result")
     then fail $ "Reserved keyword: " ++ name ++ " cannot be assigned."
     else return (SVar name)
 
-parseIntLiteral :: Parser SaplingAST
+parseIntLiteral :: Parser TricuAST
 parseIntLiteral = do
   LIntegerLiteral value <- satisfy isIntegerLiteral
   return (SInt value)
 
-parseStrLiteral :: Parser SaplingAST
+parseStrLiteral :: Parser TricuAST
 parseStrLiteral = do
   LStringLiteral value <- satisfy isStringLiteral
   return (SStr value)