X-Git-Url: https://git.stderr.nl/gitweb?p=matthijs%2Fmaster-project%2Freport.git;a=blobdiff_plain;f=Core2Core.tex;h=66612e12aac7933f782bf0e219266b6ed90821d7;hp=bc385a68324b210e435dbe1f42cbfed975099f8a;hb=7dad1bb3af2b675be75987956f248ceceda60a3e;hpb=95b1a682e51c47d635d5bafe75bd7096e8d4ec18

diff --git a/Core2Core.tex b/Core2Core.tex
index bc385a6..66612e1 100644
--- a/Core2Core.tex
+++ b/Core2Core.tex
@@ -39,6 +39,33 @@
 % Install the lambda calculus pretty-printer, as defined in pret-lam.lua.
 \installprettytype [LAM] [LAM]
 
+% An (invisible) frame to hold a lambda expression
+\define[1]\lamframe{
+        % Put a frame around lambda expressions, so they can have multiple
+        % lines and still appear inline.
+        % The align=right option really does left-alignment, but without the
+        % program will end up on a single line. The strut=no option prevents a
+        % bunch of empty space at the start of the frame.
+        \framed[offset=0mm,location=middle,strut=no,align=right,frame=off]{#1}
+}
+
+\define[2]\trans{
+        % Make \typebuffer uses the LAM pretty printer and a sans-serif font
+        % Also prevent any extra spacing above and below caused by the default
+        % before=\blank and after=\blank.
+        \setuptyping[option=LAM,style=sans,before=,after=]
+        % Prevent the arrow from ending up below the first frame (a \framed
+        % at the start of a line defaults to using vmode).
+        \dontleavehmode
+        % Put the elements in frames, so they can have multiple lines and be
+        % middle-aligned
+        \lamframe{\typebuffer[#1]}
+        \lamframe{\Rightarrow}
+        \lamframe{\typebuffer[#2]}
+        % Reset the typing settings to their defaults
+        \setuptyping[option=none,style=\tttf]
+}
+
 % A helper to print a single example in the half the page width. The example
 % text should be in a buffer whose name is given in an argument.
 %
@@ -436,4 +463,249 @@ non-polymorph functions can be a lot faster than generic ones).
 \item More builtin expressions should be added and these should be evaluated
 by the compiler. For example, map, fold, +.
 \stopitemize
+
+Initial example
+
+\starttyping
+  \x -> 
+    let s = foo x
+    in
+      case s of
+        (a, b) ->
+          case a of
+            High -> add
+            Low -> let
+              op' = case b of
+                High -> sub
+                Low  -> \c d -> c
+              in
+                \c d -> op' d c
+\stoptyping
+
+After top-level η-abstraction:
+
+\starttyping
+  \x c d -> 
+    (let s = foo x
+    in
+      case s of
+        (a, b) ->
+          case a of
+            High -> add
+            Low -> let
+              op' = case b of
+                High -> sub
+                Low  -> \c d -> c
+              in
+                \c d -> op' d c
+    ) c d
+\stoptyping
+
+After (extended) β-reduction:
+
+\starttyping
+  \x c d -> 
+    let s = foo x
+    in
+      case s of
+        (a, b) ->
+          case a of
+            High -> add c d
+            Low -> let
+              op' = case b of
+                High -> sub
+                Low  -> \c d -> c
+              in
+                op' d c
+\stoptyping
+
+After return value extraction:
+
+\starttyping
+  \x c d -> 
+    let s = foo x
+        r = case s of
+              (a, b) ->
+                case a of
+                  High -> add c d
+                  Low -> let
+                    op' = case b of
+                      High -> sub
+                      Low  -> \c d -> c
+                    in
+                      op' d c
+    in
+      r
+\stoptyping
+
+Scrutinee simplification does not apply.
+
+After case binder wildening:
+
+\starttyping
+  \x c d -> 
+    let s = foo x
+        a = case s of (a, _) -> a
+        b = case s of (_, b) -> b
+        r = case s of
+              (_, _) ->
+                case a of
+                  High -> add c d
+                  Low -> let
+                    op' = case b of
+                      High -> sub
+                      Low  -> \c d -> c
+                    in
+                      op' d c
+    in
+      r
+\stoptyping
+
+After case value simplification
+
+\starttyping
+  \x c d -> 
+    let s = foo x
+        a = case s of (a, _) -> a
+        b = case s of (_, b) -> b
+        r = case s of
+              (_, _) -> r'
+        rh = add c d
+        rl = let
+               rll = \c d -> c
+               op' = case b of
+                 High -> sub
+                 Low  -> rll
+               in
+                 op' d c
+        r' = case a of
+               High -> rh
+               Low -> rl
+    in
+      r
+\stoptyping
+
+After let flattening:
+
+\starttyping
+  \x c d -> 
+    let s = foo x
+        a = case s of (a, _) -> a
+        b = case s of (_, b) -> b
+        r = case s of
+              (_, _) -> r'
+        rh = add c d
+        rl = op' d c
+        rll = \c d -> c
+        op' = case b of
+          High -> sub
+          Low  -> rll
+        r' = case a of
+               High -> rh
+               Low -> rl
+    in
+      r
+\stoptyping
+
+After function inlining:
+
+\starttyping
+  \x c d -> 
+    let s = foo x
+        a = case s of (a, _) -> a
+        b = case s of (_, b) -> b
+        r = case s of
+              (_, _) -> r'
+        rh = add c d
+        rl = (case b of
+          High -> sub
+          Low  -> \c d -> c) d c
+        r' = case a of
+               High -> rh
+               Low -> rl
+    in
+      r
+\stoptyping
+
+After (extended) β-reduction again:
+
+\starttyping
+  \x c d -> 
+    let s = foo x
+        a = case s of (a, _) -> a
+        b = case s of (_, b) -> b
+        r = case s of
+              (_, _) -> r'
+        rh = add c d
+        rl = case b of
+          High -> sub d c
+          Low  -> d
+        r' = case a of
+               High -> rh
+               Low -> rl
+    in
+      r
+\stoptyping
+
+After case value simplification again:
+
+\starttyping
+  \x c d -> 
+    let s = foo x
+        a = case s of (a, _) -> a
+        b = case s of (_, b) -> b
+        r = case s of
+              (_, _) -> r'
+        rh = add c d
+        rlh = sub d c
+        rl = case b of
+          High -> rlh
+          Low  -> d
+        r' = case a of
+               High -> rh
+               Low -> rl
+    in
+      r
+\stoptyping
+
+After case removal:
+
+\starttyping
+  \x c d -> 
+    let s = foo x
+        a = case s of (a, _) -> a
+        b = case s of (_, b) -> b
+        r = r'
+        rh = add c d
+        rlh = sub d c
+        rl = case b of
+          High -> rlh
+          Low  -> d
+        r' = case a of
+               High -> rh
+               Low -> rl
+    in
+      r
+\stoptyping
+
+After let bind removal:
+
+\starttyping
+  \x c d -> 
+    let s = foo x
+        a = case s of (a, _) -> a
+        b = case s of (_, b) -> b
+        rh = add c d
+        rlh = sub d c
+        rl = case b of
+          High -> rlh
+          Low  -> d
+        r' = case a of
+               High -> rh
+               Low -> rl
+    in
+      r'
+\stoptyping
+
+Application simplification is not applicable.
 \stoptext