- //Let Int a = 4;//
-
- //mapP1(xs) {
- // if(isEmpty(xs)) {
- // return [];
- // } else {
- // return (xs.hd + 1) : mapP1(xs.tl);
- // }
- //}
- //main() {
- // [Int] x = [];
- // [Int] y = [];
- // Int z = a();
- // x = mapP1(x);
- // y = mapP1(x);
- // return a() + 5;
- //}
-
- plus(x,y){
- return x+y;
- }
+ //plus(x,y){
+ // return x+y;
+ //}//
map(f, xs) {
if (isEmpty(xs)) {
}
}
+ l2(x) :: Int -> Void {
+ //return print(3);
+ var y = print(3);
+ return;
+ }
+
+ repeat(f, n) {
+ var x = n;
+ while(x > 0) {
+ f();
+ x = x-1;
+ }
+ }
+
main() {
- var f = plus(1);
- var z = map(f, 1:2:[]);
- var x = foldr(plus, 0, 1:2:[]);
- print(x);
+ //var f = \x->print(x);
+ //var z = map(\x->print(3), 1:2:[]);
+ repeat(\->print(0), 5);
+ //var x = foldr(\x y->x+y, 0, 1:2:[]);
+ //print(x);
return;
}
(parseBBraces $ parseSepList CommaToken parseIdent)
(optional (satTok DoubleColonToken *> parseFunType))
(satTok CBraceOpenToken *> many parseVarDecl)
- (many parseStmt <* satTok CBraceCloseToken)
+ (flatten <$> (many parseStmt <* satTok CBraceCloseToken))
-parseStmt :: Parser Token Stmt
-parseStmt = parseIfStmt <|> parseWhileStmt <|>
+parseStmt :: Parser Token [Stmt]
+parseStmt = (parseIfStmt <|> parseWhileStmt <|>
parseSColon parseAssStmt <|> parseSColon parseReturnStmt <|>
(parseSColon parseFunCall
- >>= \(ident, args, fs)->pure $ FunStmt ident args fs)
+ >>= \(ident, args, fs)->pure $ FunStmt ident args fs))
+ >>= \stmt->case stmt of
+ FunStmt "print" args fs = pure $ map (\a->FunStmt "print" [a] []) args
+ s = pure [s]
where
parseSColon :: (Parser Token a) -> Parser Token a
parseSColon p = p <* satTok SColonToken
(parseBBraces parseExpr) <*> (parseBlock <|> parseOneLine))
parseBlock :: Parser Token [Stmt]
- parseBlock = parseBCBraces (many parseStmt)
+ parseBlock = parseBCBraces (flatten <$> many parseStmt)
parseOneLine :: Parser Token [Stmt]
- parseOneLine = pure <$> parseStmt
+ parseOneLine = parseStmt
parseFunType :: Parser Token Type
parseFunType = parseFT >>= \t -> case t of
(IdType <$> parseIdent)
parseExpr :: Parser Token Expr
- parseExpr = //Operators in order of binding strength
+ parseExpr = parseValueExpr <|> parseLambda
+
+ parseValueExpr :: Parser Token Expr
+ parseValueExpr = //Operators in order of binding strength
parseOpR (trans1 ColonToken BiCons) $
parseOpR (trans1 PipesToken BiOr) $
parseOpR (trans1 AmpersandsToken BiAnd) $
pure $ FunExpr pos ident args fs) <|>
(VarExpr pos <$> parseVarDef)
+ parseLambda :: Parser Token Expr
+ parseLambda = LambdaExpr <$> peekPos
+ <*> (satTok BackslashToken *> many parseIdent)
+ <*> (satTok ArrowToken *> parseExpr)
+
makeStrExpr :: Pos [Char] -> Expr
makeStrExpr p [] = EmptyListExpr p
makeStrExpr p [x:xs] = Op2Expr p (CharExpr zero x) BiCons (makeStrExpr p xs)