Mjahaja

3/3.org

@@ -12,19 +12,21 @@ This time you can make use of a [[http://bnfc.digitalgrammars.com/][BNFC]] speci
 
 If you want to use Haskell then there is also a wrapper module ([[https://chalmers.instructure.com/courses/36941/file_contents/course%20files/chi/Chi.cf][~Chi.cf~]]) that exports the generated abstract syntax and some definitions that may be useful for testing your code ([[https://chalmers.instructure.com/courses/36941/file_contents/course%20files/chi/Chi.html][documentation]]). The wrapper module comes with a Cabal file ([[https://chalmers.instructure.com/courses/36941/file_contents/course%20files/chi/chi.cabal][~chi.cabal~]]) and a [[https://chalmers.instructure.com/courses/36941/file_contents/course%20files/chi/cabal.project][~cabal.project~]] file that might make installation a little easier. Here is one way to (hopefully) get started:
 
-- Install all dependencies properly, including suitable versions of GHC and cabal-install ([[https://www.haskell.org/downloads/][installation instructions]]), as well as [[http://bnfc.digitalgrammars.com/][BNFC]].
-- Put [[https://chalmers.instructure.com/courses/36941/file_contents/course%20files/chi/Chi.cf][~Chi.cf~]], [[https://chalmers.instructure.com/courses/36941/file_contents/course%20files/chi/Chi.hs][~Chi.hs~]], [[https://chalmers.instructure.com/courses/36941/file_contents/course%20files/chi/chi.cabal][~chi.cabal~]] and [[https://chalmers.instructure.com/courses/36941/file_contents/course%20files/chi/cabal.project][~cabal.project~]] in an otherwise empty directory.
-- Run ~bnfc --haskell Chi.cf~ in that directory.
-    - Now it is hopefully possible to use standard ~cabal~ commands. You could for instance try the following (still in the same directory):
-    - First use cabal repl to start GHCi.
-    - Then issue the following commands at the GHCi command prompt:
++ Install all dependencies properly, including suitable versions of GHC and cabal-install ([[https://www.haskell.org/downloads/][installation instructions]]), as well as [[http://bnfc.digitalgrammars.com/][BNFC]].
++ Put [[https://chalmers.instructure.com/courses/36941/file_contents/course%20files/chi/Chi.cf][~Chi.cf~]], [[https://chalmers.instructure.com/courses/36941/file_contents/course%20files/chi/Chi.hs][~Chi.hs~]], [[https://chalmers.instructure.com/courses/36941/file_contents/course%20files/chi/chi.cabal][~chi.cabal~]] and [[https://chalmers.instructure.com/courses/36941/file_contents/course%20files/chi/cabal.project][~cabal.project~]] in an otherwise empty directory.
++ Run ~bnfc --haskell Chi.cf~ in that directory.
+  + Now it is hopefully possible to use standard ~cabal~ commands. You could for instance try the following (still in the same directory):
+  + First use cabal repl to start GHCi.
+  + Then issue the following commands at the GHCi command prompt:
     #+begin_src haskell
     import Chi
     import Prelude
-    pretty <$> (runDecode (decode =<<
-                        asDecoder (code =<< code (parse "\\x. x"))))
+    pretty <$>
+      (runDecode (decode =<< asDecoder
+                 (code =<< code (parse "\\x. x"))))
     #+end_src
 
+\newpage
 * Exercises
 In order to pass this assignment you have to get at least four points.
 
@@ -49,7 +51,7 @@ rec foo = \m. \n. case m of
 Give a high-level explanation of the mathematical function in $\mathbb{N} \rightarrow \mathbb{N} \rightarrow \text{Bool}$ that is implemented by this code.
 
 *** Answer
-The function will check for equality of the two natural numbers. If they are both $Zero()$, then it returns true, and if both are the successor of a some values, it checks if they are equal. In the other cases, it returns false.
+The function will check for equality of the two natural numbers. If they are both $\text{Zero}()$, then it returns true, and if both are the successor of a some values, it checks if they are equal. In the other cases, it returns false.
 
 ** (2p)
 Consider the $\chi$ term /t/ with concrete syntax $C (\lambda z.z)$:
@@ -78,13 +80,13 @@ If you use the BNFC specification above and Haskell, then the substitution funct
 #+end_src
 Test your implementation. Here are some test cases that must work:
 | Variable | Substituted term | Term                                        | Result                                               |
-|----------+------------------+---------------------------------------------+---------------------------------------------|
-| ~x~        | ~Z()~              | ~rec x = x~                                   | ~rec x = x~                                   |
+|----------+------------------+---------------------------------------------+------------------------------------------------------|
+| ~x~        | $Z()$            | $\text{rec}\ x = x$                         | $\text{rec}\ x = x$                                  |
 | ~y~        | $\lambda x.x$          | $\lambda x. (x y)$                                | $\lambda x . (x (\lambda x . x))$                                |
 | ~z~        | $C(\lambda z . z)$     | $\text{case}\ z\ \text{of}\ \{ C(z) \rightarrow z \}$ | $\text{case}\ C(\lambda z. z) \ \text{of}\ \{ C(z) \rightarrow z \}$ |
 
 *** Answer
-See Assignment.hs
+See =Main.hs=.
 
 ** (1p)
 Implement multiplication of natural numbers in $\chi$, using the representation of natural numbers given in the $\chi$ specification.
@@ -97,13 +99,10 @@ Hint: If you want to make use of addition in the implementation of multiplicatio
   { Zero() -> Zero()
   ; Succ(n) -> add m (mult n)
   } 
-#+end_src
-where we substitute ~add~ for the following:
-#+begin_src chi
-\m. rec add = \n. case n of
+[ add <- \m. rec add = \n. case n of
                 { Zero() -> m
                 ; Succ(n) -> Suc(add n)
-  } 
+                }]
 #+end_src
 
 ** (2p) [BN]
@@ -117,13 +116,13 @@ If you use the BNFC specification above and Haskell, then the interpreter should
 Test your implementation, for instance by testing that addition (defined in the [[https://chalmers.instructure.com/courses/36941/file_contents/course%20files/chi/Chi.hs][wrapper module]]) works for some inputs. If addition doesn’t work when your code is tested, then your solution will not be accepted. Also make sure that the following examples are implemented correctly:
 
 - The following programs should fail to terminate:
-    + $C() C()$
-    + $case \lambda x.x of {}$
-    + $case C() of { C(x) \rightarrow C() }$
-    + $case C(C()) of { C() \rightarrow C() }$
-    + $case C(C()) of { C() \rightarrow C(); C(x) \rightarrow x }$
-    + $case C() of { D() \rightarrow D() }$
-    + $(\lambda x.\lambda y.x) (rec x = x)$
+    + $\text{C}()\ \text{C}()$
+    + $\text{case}\ \lambda x.x\ \text{of}\ {}$
+    + $\text{case}\ \text{C}()\ \text{of}\ { \text{C}(x) \rightarrow \text{C}() }$
+    + $\text{case}\ \text{C}(\text{C}())\ \text{of}\ { \text{C}() \rightarrow \text{C}() }$
+    + $\text{case}\ \text{C}(\text{C}())\ \text{of}\ { \text{C}() \rightarrow \text{C}(); \text{C}(x) \rightarrow x }$
+    + $\text{case} \text{C}()\ \text{of}\ { \text{D}() \rightarrow \text{D}() }$
+    + $(\lambda x.\lambda y.x) (\text{rec}\ x = x)$
 - The following programs should terminate with specific results:
     + The program $case C(D(),E()) of { C(x, x) \rightarrow x }$ should terminate with the value $E()$.
     + The program $case C(\lambda x.x, Zero()) of { C(f, x) \rightarrow f x }$ should terminate with the value $Zero()$.
@@ -133,3 +132,4 @@ Test your implementation, for instance by testing that addition (defined in the
 Note that implementing a call-by-value semantics properly in a language like Haskell, which is by default non-strict, can be tricky. However, you will not fail if the only problem with your implementation is that some programs that should fail to terminate instead terminate with a “reasonable” result.
 
 *** Answer
+See =Main.hs=.

3/Assignment.hs

@@ -1,25 +0,0 @@
-{-# Language LambdaCase #-}
-module Assignment where
-
-import Chi
-
-subst :: Variable -> Exp -> Exp -> Exp
-subst var e = \case
-  Apply e1 e2 -> Apply (subst var e e1) (subst var e e2)
-  Lambda x e' -> Lambda x $ if var /= x then (subst var e e') else e'
-  Var x -> if var == x then e else Var x
-  Const c es -> Const c $ map (subst var e) es
-  Rec x e' -> Rec x $ if var /= x then (subst var e e') else e' 
-  Case e' branches -> Case (subst var e e') $ map substBr branches
-    where
-      substBr :: Br -> Br
-      substBr (Branch c vs e') = Branch c vs $ if var `notElem` vs then (subst var e e') else e'
-
-eval' :: Exp -> Reader (Map Variable Exp) Exp
-eval' = undefined
-
-eval :: Exp -> Exp
-eval = undefined
-
-main :: IO ()
-main = getLine >>= print . eval . parse

3/chi.cabal

@@ -12,12 +12,12 @@ library
     hashable >= 1.4.7.0 && < 1.6,
     mtl >= 2.2.2 && < 2.4,
     pretty ^>= 1.1.3.6,
-    QuickCheck ^>= 2.15.0.0,
+    QuickCheck >= 2.16.0.0,
     transformers >= 0.5.6.2 && < 0.7,
     unordered-containers ^>= 0.2.20
   build-tool-depends:
-    alex:alex ^>= 3.5.2.0,
-    happy:happy ^>= 2.1.5
+    alex:alex ^>= 3.5.4.0,
+    happy:happy ^>= 2.1.7
   exposed-modules:
     AbsChi
     Chi
@@ -28,6 +28,9 @@ library
     .
 
 executable interpreter
-    main-is: Assignment.hs
+    main-is: Main.hs
+    hs-source-dirs:
+        interpreter
     build-depends: base
                  , chi
+                 , mtl

3/flake.nix

@@ -10,7 +10,7 @@
 
   outputs = { self, nixpkgs, flake-utils }:
     let
-      ghcVer = "ghc910";
+      ghcVer = "ghc912";
       makeHaskellOverlay = overlay: final: prev: {
         haskell = prev.haskell // {
           packages = prev.haskell.packages // {
@@ -53,9 +53,6 @@
               withHoogle = true;
               buildInputs =
                 (with pkgs; [
-                  gnumake
-                  jasmin
-                  jre_minimal
                 ]) ++
                 (with haskellPackages; [
                   haskell-language-server

3/interpreter/Main.hs

@@ -0,0 +1,49 @@
+{-# Language LambdaCase, Strict #-}
+module Main where
+
+import Chi
+import Data.Functor           ( (<&>) )
+import Control.Monad.Identity ( Identity( runIdentity ) )
+
+-- Task 3
+subst :: Variable -> Exp -> Exp -> Exp
+subst var e = \case
+  Apply e1 e2 -> Apply (subst var e e1) (subst var e e2)
+  Lambda x e' -> Lambda x $ if var /= x then subst var e e' else e'
+  Var x -> if var == x then e else Var x
+  Const c es -> Const c $ map (subst var e) es
+  Rec x e' -> Rec x $ if var /= x then subst var e e' else e'
+  Case e' bs -> Case (subst var e e') $ map substBr bs
+    where
+      substBr :: Br -> Br
+      substBr (Branch c vs e') = Branch c vs $ if var `notElem` vs then subst var e e' else e'
+
+-- Task 5
+eval :: Exp -> Exp
+eval = runIdentity . eval'
+  where
+    eval' :: Exp -> Identity Exp
+    eval' = \case
+      e@(Apply e1 e2) -> eval' e1 >>= \case
+        Lambda x e' -> eval' e2 >>= eval' . flip (subst x) e'
+        _ -> error $ "Function was not function in evaluation: " <> show e
+      Const c es -> mapM eval' es <&> Const c
+      Rec x e -> eval' $ subst x (Rec x e) e
+      Case e bs -> eval' e >>= \case
+        Const c vs -> lookupBranch c bs >>= \case
+          (xs,e') ->
+            if length vs /= length xs then error "Not the same amount of arguments in case" else
+            eval' $ foldr (uncurry subst) e' (zip xs vs)
+        e -> error $ "Non const in case: " <> show e
+      x -> pure x
+    
+    lookupBranch :: Constructor -> [Br] -> Identity ([Variable], Exp)
+    lookupBranch c [] = error "No matching branch"
+    lookupBranch c ((Branch c' bs e):brs) =
+      if c == c'
+      then pure (bs,e)
+      else lookupBranch c brs
+
+
+main :: IO ()
+main = getLine >>= print . eval . parse