function signature declarations

Author: quasarbright

README.md

@@ -11,6 +11,7 @@ For an example displaying the syntax and all the features, see `examples/fma.uni
 * define your own derived units
 * declare a variable's units and use it in expressions
 * define a variable to infer its units, then use it in expressions
+* define function signatures
 * common derived units (i.e. `N = [kg m s^-2]`), variables (i.e. `g :: [m s^-2]`), and functions (i.e. `sin :: ([]) -> []`) are included in prelude
 * has a REPL
 
@@ -55,7 +56,7 @@ Unit mismatch: Expected units of [kg m s^-2], but got units of [kg] at examples/
 ## Syntax
 a UnitChecker program consists of a list of statements.
 A statement can declare the units of a variable, define a variable and infer its units,
-define a derived unit (like Newtons), check the units of an expression,
+define a derived unit (like Newtons), define the signature of a function, check the units of an expression,
 and check the units of both sides of an equation and check that they're equivalent
 
 An expression is an arithmetic expression of variables and numbers with operators `+-*/^`, function calls, and unit annotations
@@ -68,10 +69,13 @@ Here is the context free grammar for a program:
 
 <statement> = 'def' <identifier> '=' <expression>
             | 'var' <identifier> '::' <unit>
+            | 'fun' <identifier> '::' '(' <units>? ')' '->' <unit>
             | 'derived' <identifier> '=' <unit>
             | 'expr' <expr>
             | 'eq' <expr> '=' <expr>
 
+<units> = <unit> | <unit> ',' <units> 
+
 <expr> = <expr> <binop> <expr>
        | '-' <expr>
        | '(' <expr> ')'

examples/fma.unit

@@ -78,6 +78,12 @@ eq exp(2) = e^2
 def Fg = m * (9.8 :: [m s^-2])
 eq F = Fg
 
+
+// defines a function which takes in meters and seconds and outputs meters per second
+fun getVel :: ([m], [s]) -> [m s^-1]
+def v = getVel(10 :: [m], 1 :: [s])
+
+
 /*
 Running a program outputs newly defined variables and derived units with their corresponding types.
 This example program outputs the following:
@@ -94,4 +100,6 @@ f :: [hz]
 t :: [s]
 x :: []
 Fg :: [kg m s^-2]
+getVel :: ([m], [s]) -> [m s^-1]
+v :: [m s^-1]
 */

src/Check.hs

@@ -195,6 +195,7 @@ checkWellFormednessWith wfenv (Program statements) = foldl go ([], wfenv) statem
         ExprStatement e _ -> (errs++checkExprWellFormedness env e, env)
         EqnStatement (Equation left right _) _ -> (errs++checkExprWellFormedness env left++checkExprWellFormedness env right, env)
         VarDefStatement name e _ -> (errs++checkExprWellFormedness env e, (deriveds, name:vars, funs))
+        FunDefStatement name (Signature args ret _) _ -> (errs++concatMap (checkUnit deriveds) (args++[ret]), (deriveds, vars, name:funs))
 
 -- | check the well-formedness of a program using the prelude's defined names as the initial environment
 checkWellFormedness :: Program a -> ([Error a], ([String], [String], [String]))
@@ -230,6 +231,7 @@ checkStatement (DerivedDeclStatement (DerivedDecl name unit _) _) = modify $ add
 checkStatement (VarDefStatement name e _) = do
     unit <- typeSynth e
     modify $ addVar name unit
+checkStatement (FunDefStatement name sig _) = modify $ addFun name sig
 
 {--
 This is the real meat of the type checker. I use a simple bidirectional type system since there is the polymorphism is simple (just binops) and inference is easy.

src/Exprs.hs

@@ -207,6 +207,7 @@ data Statement a = ExprStatement (Expr a) a
                  | VarDeclStatement (VarDecl a) a
                  | DerivedDeclStatement (DerivedDecl a) a
                  | VarDefStatement String (Expr a) a
+                 | FunDefStatement String (Signature a) a
                  deriving(Eq, Ord, Show)
 
 -- | A program to be type-checked

src/ParseProgram.hs

@@ -53,12 +53,13 @@ statement =  varDecl
          <|> eqn
          <|> derivedDecl
          <|> varDef
+         <|> funDef
          <?> "statement"
 
 varDecl :: Parser (Statement SS)
 varDecl = do
     ((name, u), ss) <- wrapSS $ do
-        () <- keyWordTok "var"
+        () <- var
         name <- ident
         () <- annotTok
         u <- unit
@@ -71,7 +72,7 @@ exprStatement = uncurry ExprStatement <$> wrapSS (keyWordTok "expr" *> expr)
 eqn :: Parser (Statement SS)
 eqn = do
     ((left, right), ss) <- wrapSS $ do
-        () <- keyWordTok "eq"
+        () <- eq
         left <- expr
         () <- eqTok
         right <- expr
@@ -81,7 +82,7 @@ eqn = do
 derivedDecl :: Parser (Statement SS)
 derivedDecl = do
     ((name, u), ss) <- wrapSS $ do
-        () <- keyWordTok "derived"
+        () <- derived
         name <- ident
         () <- eqTok
         u <- unit
@@ -91,9 +92,19 @@ derivedDecl = do
 varDef :: Parser (Statement SS)
 varDef = do
     ((name, e), ss) <- wrapSS $ do
-        () <- keyWordTok "def"
+        () <- def
         name <- ident
         () <- eqTok
         e <- expr
         return (name, e)
-    return (VarDefStatement name e ss)
+    return (VarDefStatement name e ss)
+
+funDef :: Parser (Statement SS)
+funDef = do
+    ((name, sig), ss) <- wrapSS $ do
+        fun
+        name <- ident
+        annotTok
+        sig <- signatureP
+        return (name, sig)
+    return (FunDefStatement name sig ss)

src/ParseUnit.hs

@@ -1,4 +1,4 @@
-module ParseUnit(unit, parseUnit) where
+module ParseUnit(unit, parseUnit, signatureP, parseSignature) where
 
 import ParseUtils
 import Exprs
@@ -39,5 +39,18 @@ basePow = do
 unit :: Parser (Unit SS)
 unit = fromBasesList <$> (P.brackets lexer (many basePow) <?> "unit")
 
+
 parseUnit :: String -> Either ParseError (Unit SS)
-parseUnit = parse (P.whiteSpace lexer *> unit <* eof) ""
+parseUnit = parse (P.whiteSpace lexer *> unit <* eof) ""
+
+signatureP :: Parser (Signature SS)
+signatureP = do
+    ((args, ret), ss) <- wrapSS $ do
+        args <- inParens $ sepBy unit commaTok
+        arrowTok
+        ret <- unit
+        return (args, ret)
+    return $ Signature args ret ss
+
+parseSignature :: String -> Either ParseError (Signature SS)
+parseSignature = parse (P.whiteSpace lexer *> signatureP <* eof) ""

src/ParseUtils.hs

@@ -30,7 +30,7 @@ lang = P.LanguageDef{
     P.opStart = oneOf "+-*/^=:,;",
     P.opLetter = oneOf ":",
     P.reservedNames = ["var", "def", "fun", "expr", "eq", "derived"],
-    P.reservedOpNames = ["+", "-", "*", "/", "^", "=", "::", ",", ";"],
+    P.reservedOpNames = ["+", "-", "*", "/", "^", "=", "::", ",", ";", "->"],
     P.caseSensitive = True}
 
 lexer :: P.GenTokenParser String () Data.Functor.Identity.Identity
@@ -83,6 +83,9 @@ minusTok = P.reservedOp lexer "-"
 commaTok :: Parser ()
 commaTok = P.reservedOp lexer ","
 
+arrowTok :: Parser ()
+arrowTok = P.reservedOp lexer "->"
+
 ident :: Parser String
 ident = P.identifier lexer