refactor keywords wip

src/Juvix/Compiler/Asm/Keywords.hs

@@ -0,0 +1,43 @@
+module Juvix.Compiler.Asm.Keywords
+  ( module Juvix.Compiler.Asm.Keywords,
+    module Juvix.Data.Keyword,
+    module Juvix.Data.Keyword.All,
+  )
+where
+
+import Juvix.Data.Keyword
+import Juvix.Data.Keyword.All
+  ( kwArg,
+    kwColon,
+    -- are these different?
+
+    kwDollar,
+    kwFalse,
+    kwFun,
+    kwInductive,
+    kwRightArrow,
+    kwSemicolon,
+    kwStar,
+    kwTmp,
+    kwTrue,
+    kwUnit,
+    kwVoid,
+  )
+import Juvix.Prelude
+
+allKeywordStrings :: HashSet Text
+allKeywordStrings = keywordsStrings allKeywords
+
+allKeywords :: [Keyword]
+allKeywords =
+  [ kwFun,
+    kwInductive,
+    kwColon,
+    kwSemicolon,
+    kwStar,
+    kwRightArrow,
+    kwTrue,
+    kwFalse,
+    kwArg,
+    kwTmp
+  ]

src/Juvix/Compiler/Asm/Translation/FromSource.hs

@@ -95,7 +95,7 @@ statementFunction ::
   Members '[Reader ParserParams, InfoTableBuilder] r =>
   ParsecS r ()
 statementFunction = do
-  kwFun
+  kw kwFun
   off <- P.getOffset
   (txt, i) <- identifierL
   idt <- lift $ getIdent txt
@@ -119,7 +119,7 @@ statementFunction = do
             _functionType = mkTypeFun argtys (fromMaybe TyDynamic mrty)
           }
   lift $ registerFunction fi0
-  mcode <- (kwSemicolon $> Nothing) <|> optional (braces parseCode)
+  mcode <- (kw kwSemicolon $> Nothing) <|> optional (braces parseCode)
   let fi = fi0 {_functionCode = fromMaybe [] mcode}
   case idt of
     Just (IdentFwd _) -> do
@@ -141,7 +141,7 @@ statementInductive ::
   Members '[Reader ParserParams, InfoTableBuilder] r =>
   ParsecS r ()
 statementInductive = do
-  kwInductive
+  kw kwInductive
   off <- P.getOffset
   (txt, i) <- identifierL
   idt <- lift $ getIdent txt
@@ -157,7 +157,7 @@ statementInductive = do
             _inductiveConstructors = []
           }
   lift $ registerInductive ii
-  ctrs <- braces $ P.sepEndBy (constrDecl sym) kwSemicolon
+  ctrs <- braces $ P.sepEndBy (constrDecl sym) (kw kwSemicolon)
   lift $ registerInductive ii {_inductiveConstructors = ctrs}
 
 functionArguments ::
@@ -199,7 +199,7 @@ typeAnnotation ::
   Members '[Reader ParserParams, InfoTableBuilder] r =>
   ParsecS r Type
 typeAnnotation = do
-  kwColon
+  kw kwColon
   parseType
 
 parseType ::
@@ -219,7 +219,7 @@ typeFun' ::
   NonEmpty Type ->
   ParsecS r Type
 typeFun' tyargs = do
-  kwArrow
+  kw kwRightArrow
   TyFun . TypeFun tyargs <$> parseType
 
 typeArguments ::
@@ -230,8 +230,8 @@ typeArguments = do
     <|> (typeDynamic <&> NonEmpty.singleton)
     <|> (typeNamed <&> NonEmpty.singleton)
 
-typeDynamic :: ParsecS r Type
-typeDynamic = kwStar $> TyDynamic
+typeDynamic :: Members '[Reader ParserParams] r => ParsecS r Type
+typeDynamic = kw kwStar $> TyDynamic
 
 typeNamed ::
   Members '[Reader ParserParams, InfoTableBuilder] r =>
@@ -253,7 +253,7 @@ typeNamed = do
 parseCode ::
   Members '[Reader ParserParams, InfoTableBuilder] r =>
   ParsecS r Code
-parseCode = P.sepEndBy command kwSemicolon
+parseCode = P.sepEndBy command (kw kwSemicolon)
 
 command ::
   Members '[Reader ParserParams, InfoTableBuilder] r =>
@@ -337,10 +337,10 @@ integerValue = do
   (i, _) <- integer
   return $ ConstInt i
 
-boolValue :: ParsecS r Value
+boolValue :: Members '[Reader ParserParams] r => ParsecS r Value
 boolValue =
-  (kwTrue $> ConstBool True)
-    <|> (kwFalse $> ConstBool False)
+  (kw kwTrue $> ConstBool True)
+    <|> (kw kwFalse $> ConstBool False)
 
 stringValue ::
   Members '[Reader ParserParams, InfoTableBuilder] r =>
@@ -349,11 +349,11 @@ stringValue = do
   (s, _) <- string
   return $ ConstString s
 
-unitValue :: ParsecS r Value
-unitValue = kwUnit $> ConstUnit
+unitValue :: Members '[Reader ParserParams] r => ParsecS r Value
+unitValue = kw kwUnit $> ConstUnit
 
-voidValue :: ParsecS r Value
-voidValue = kwVoid $> ConstVoid
+voidValue :: Members '[Reader ParserParams] r => ParsecS r Value
+voidValue = kw kwVoid $> ConstVoid
 
 memValue ::
   Members '[Reader ParserParams, InfoTableBuilder] r =>
@@ -367,22 +367,22 @@ directRef ::
   ParsecS r DirectRef
 directRef = stackRef <|> argRef <|> tempRef
 
-stackRef :: ParsecS r DirectRef
-stackRef = kwDollar $> StackRef
+stackRef :: Members '[Reader ParserParams] r => ParsecS r DirectRef
+stackRef = kw kwDollar $> StackRef
 
 argRef ::
   Members '[Reader ParserParams, InfoTableBuilder] r =>
   ParsecS r DirectRef
 argRef = do
-  kwArg
+  kw kwArg
   (off, _) <- brackets integer
   return $ ArgRef (fromInteger off)
 
 tempRef ::
   Members '[Reader ParserParams, InfoTableBuilder] r =>
   ParsecS r DirectRef
 tempRef = do
-  kwTmp
+  kw kwTmp
   (off, _) <- brackets integer
   return $ TempRef (fromInteger off)
 
@@ -462,7 +462,7 @@ instrCall = do
 parseCallType ::
   Members '[Reader ParserParams, InfoTableBuilder] r =>
   ParsecS r CallType
-parseCallType = (kwDollar $> CallClosure) <|> (CallFun <$> funSymbol)
+parseCallType = (kw kwDollar $> CallClosure) <|> (CallFun <$> funSymbol)
 
 instrCallClosures ::
   Members '[Reader ParserParams, InfoTableBuilder] r =>
@@ -495,7 +495,7 @@ caseBranch ::
   ParsecS r CaseBranch
 caseBranch = do
   tag <- P.try constrTag
-  kwColon
+  kw kwColon
   CaseBranch tag <$> branchCode
 
 defaultBranch ::

src/Juvix/Compiler/Asm/Translation/FromSource/Lexer.hs

@@ -1,10 +1,11 @@
 module Juvix.Compiler.Asm.Translation.FromSource.Lexer
   ( module Juvix.Compiler.Asm.Translation.FromSource.Lexer,
     module Juvix.Parser.Lexer,
+    module Juvix.Compiler.Asm.Keywords,
   )
 where
 
-import Juvix.Extra.Strings qualified as Str
+import Juvix.Compiler.Asm.Keywords
 import Juvix.Parser.Lexer
 import Juvix.Prelude
 import Text.Megaparsec as P hiding (sepBy1, sepEndBy1, some)
@@ -37,6 +38,9 @@ string = lexemeInterval string'
 keyword :: Text -> ParsecS r ()
 keyword = keyword' space
 
+kw :: Members '[Reader ParserParams] r => Keyword -> ParsecS r ()
+kw k = void $ lexeme $ kw' k
+
 keywordSymbol :: Text -> ParsecS r ()
 keywordSymbol = keywordSymbol' space
 
@@ -47,25 +51,11 @@ identifierL :: Member (Reader ParserParams) r => ParsecS r (Text, Interval)
 identifierL = lexemeInterval bareIdentifier
 
 bareIdentifier :: ParsecS r Text
-bareIdentifier = rawIdentifier' (`elem` specialSymbols) allKeywords
+bareIdentifier = rawIdentifier' (`elem` specialSymbols) allKeywordStrings
 
 specialSymbols :: [Char]
 specialSymbols = ":"
 
-allKeywords :: [ParsecS r ()]
-allKeywords =
-  [ kwFun,
-    kwInductive,
-    kwColon,
-    kwSemicolon,
-    kwStar,
-    kwArrow,
-    kwTrue,
-    kwFalse,
-    kwArg,
-    kwTmp
-  ]
-
 dot :: ParsecS r ()
 dot = symbol "."
 
@@ -98,42 +88,3 @@ braces = between (symbol "{") (symbol "}")
 
 brackets :: ParsecS r a -> ParsecS r a
 brackets = between (symbol "[") (symbol "]")
-
-kwFun :: ParsecS r ()
-kwFun = keyword Str.fun_
-
-kwInductive :: ParsecS r ()
-kwInductive = keyword Str.inductive
-
-kwColon :: ParsecS r ()
-kwColon = keyword Str.colon
-
-kwSemicolon :: ParsecS r ()
-kwSemicolon = keyword Str.semicolon
-
-kwStar :: ParsecS r ()
-kwStar = keyword Str.mul
-
-kwDollar :: ParsecS r ()
-kwDollar = keyword Str.dollar
-
-kwArrow :: ParsecS r ()
-kwArrow = keyword Str.toAscii <|> keyword Str.toUnicode
-
-kwTrue :: ParsecS r ()
-kwTrue = keyword Str.true_
-
-kwFalse :: ParsecS r ()
-kwFalse = keyword Str.false_
-
-kwUnit :: ParsecS r ()
-kwUnit = keyword Str.unit
-
-kwVoid :: ParsecS r ()
-kwVoid = keyword Str.void
-
-kwArg :: ParsecS r ()
-kwArg = keyword Str.arg_
-
-kwTmp :: ParsecS r ()
-kwTmp = keyword Str.tmp_

src/Juvix/Compiler/Concrete/Keywords.hs

@@ -0,0 +1,85 @@
+module Juvix.Compiler.Concrete.Keywords
+  ( module Juvix.Compiler.Concrete.Keywords,
+    module Juvix.Data.Keyword,
+    module Juvix.Data.Keyword.All,
+  )
+where
+
+import Juvix.Data.Keyword
+import Juvix.Data.Keyword.All
+  ( -- reserved
+
+    -- extra
+    cBackend,
+    ghc,
+    kwAssign,
+    kwAxiom,
+    kwBuiltin,
+    kwColon,
+    kwColonOmega,
+    kwColonOne,
+    kwColonZero,
+    kwCompile,
+    kwEnd,
+    kwForeign,
+    kwHiding,
+    kwHole,
+    kwImport,
+    kwIn,
+    kwInductive,
+    kwInfix,
+    kwInfixl,
+    kwInfixr,
+    kwLambda,
+    kwLet,
+    kwMapsTo,
+    kwModule,
+    kwOpen,
+    kwPositive,
+    kwPostfix,
+    kwPublic,
+    kwRightArrow,
+    kwSemicolon,
+    kwTerminating,
+    kwType,
+    kwUsing,
+    kwWhere,
+    kwWildcard,
+  )
+import Juvix.Prelude
+
+allKeywordStrings :: HashSet Text
+allKeywordStrings = keywordsStrings allKeywords
+
+allKeywords :: [Keyword]
+allKeywords =
+  [ kwAssign,
+    kwAxiom,
+    kwColon,
+    kwColonOmega,
+    kwColonOne,
+    kwColonZero,
+    kwCompile,
+    kwEnd,
+    kwForeign,
+    kwHiding,
+    kwHole,
+    kwImport,
+    kwIn,
+    kwInductive,
+    kwInfix,
+    kwInfixl,
+    kwInfixr,
+    kwLambda,
+    kwLet,
+    kwModule,
+    kwOpen,
+    kwPostfix,
+    kwPublic,
+    kwRightArrow,
+    kwSemicolon,
+    kwType,
+    kwUsing,
+    kwWhere,
+    kwWildcard
+  ]