almost finished challenge 4

cw/src/Challenges.hs

@@ -278,10 +278,11 @@ prettyPrint (LamDef ms e) = exprBrackets e
 
 --applies brackets to expr if needed
 exprBrackets :: LamExpr -> String
-exprBrackets e | fst (head (parse expr str)) == e = str                                                                 --omit brackets
-               | otherwise                        = "(" ++ str ++ ")"                                                    --include brackets
+exprBrackets e | foldl1 (||) $ map (e==) parsed   = str                                                         --omit brackets
+               | otherwise                        = "(" ++ str ++ ")"                                           --include brackets
     where
       str = exprToStr e
+      parsed = map fst (parse expr str)                                                                         --possible parsings of str
 
 
 --converts expr to string
@@ -317,11 +318,25 @@ ex3'4 = LamDef [ ("F", LamAbs 1 (LamVar 1) ) ] (LamAbs 2 (LamApp (LamAbs 1 (LamV
 --Digit ::= “0” | “1” | “2” | “3” | “4” | “5” | “6” | “7” | “8” | “9”
 
 
+--MacroExpr ::= "def" MacroName "=" Expr "in" MacroExpr | Expr
+--Expr ::=  Var | MacroName | Applicative | Function | Expression
+--MacroName ::= UChar | UChar MacroName
+--UChar ::= "A" | "B" | ... | "Z"
+--Var ::= “x” Digits
+--Digits ::= Digit | Digit Digits
+--Digit ::= “0” | “1” | “2” | “3” | “4” | “5” | “6” | “7” | “8” | “9”
+
+--Applicative ::= Expr Expr
+--Function ::= “\” Var “->” Expr
+--Expression ::= “(“ Expr “)”
+
+
 parseLamMacro :: String -> Maybe LamMacroExpr
 parseLamMacro str | parsed == [] = Nothing
-                  | otherwise    = Just parsed
+                  | otherwise    = Just $ fstHead parsed
     where
-      parsed = fst (head (parse (macroExpr []) str))                                                      --HEAD WILL NOT WORK
+      parsed = parse (macroExpr []) str
+      fstHead = fst . head
 
 
 macroExpr :: [ (String,LamExpr) ] -> Parser LamMacroExpr
@@ -337,36 +352,16 @@ macroExpr ms = do string "def"
                   return $ LamDef ms e
 
 
-
--- macroExpr :: Parse LamMacroExpr
--- macroExpr = do string "def"
---                name  <- token macroName
---                symbol "="
---                e     <- token expr
---                token $ string "in"
---                macros <- macroLoop
---                return $ LamDef macros
---     where
---       macroLoop :: Parse [(String,LamExpr)]
---       macroLoop = do string "def"
---                      name  <- token macroName
---                      symbol "="
---                      e     <- token expr
---                      token $ string "in"
---                      ms <- many macroExpr
---                      return ((name,e):ms)            <|>
---                   do {e <- token expr;return []}
-
-
 expr :: Parser LamExpr
-expr = do {x    <- var;      return $ LamVar x}
+expr = do terms <- some (token term)
+          return $ foldl1 LamApp terms
 
-   <|> do {name <- macroName;return $ LamMacro name}
 
-   <|> do e1    <- expr
-          space
-          e2    <- expr
-          return $ LamApp e1 e2
+term :: Parser LamExpr
+term = do char '('
+          e     <- token expr
+          char ')'
+          return e
 
    <|> do char '\\'
           x     <- var
@@ -374,10 +369,30 @@ expr = do {x    <- var;      return $ LamVar x}
           e     <- expr
           return $ LamAbs x e
 
-   <|> do char '('
-          e     <- token expr
-          char ')'
-          return e
+   <|> do {x    <- var;      return $ LamVar x}
+
+   <|> do {name <- macroName;return $ LamMacro name}
+
+-- expr :: Parser LamExpr
+-- expr = do e1    <- expr
+--           space
+--           e2    <- expr
+--           return $ LamApp e1 e2
+
+--    <|> do {x    <- var;      return $ LamVar x}
+
+--    <|> do {name <- macroName;return $ LamMacro name}
+
+--    <|> do char '\\'
+--           x     <- var
+--           symbol "->"
+--           e     <- expr
+--           return $ LamAbs x e
+
+--    <|> do char '('
+--           e     <- token expr
+--           char ')'
+--           return e
 
 
 macroName :: Parser String