From: Matthijs Kooijman
Date: Tue, 1 Dec 2009 19:53:35 +0000 (+0100)
Subject: Rename example function app2 to twice.
X-Git-Tag: final-thesis~124
X-Git-Url: https://git.stderr.nl/gitweb?p=matthijs%2Fmaster-project%2Freport.git;a=commitdiff_plain;h=bff5a598be513f497ad61d29b7c7584f94d2b993;hp=feee31da167a3c0505d2683d3e81e2597743f1a6
Rename example function app2 to twice.
app2 would get the 2 in subscript, which might be confusing.
---
diff --git a/Chapters/Normalization.tex b/Chapters/Normalization.tex
index e2f3a96..fbad0ea 100644
--- a/Chapters/Normalization.tex
+++ b/Chapters/Normalization.tex
@@ -1788,17 +1788,17 @@
expression shows an example:
\startlambda
- app2 :: (Word -> Word) -> Word -> Word
- app2 = Î»f.Î»a.f (f a)
+ twice :: (Word -> Word) -> Word -> Word
+ twice = Î»f.Î»a.f (f a)
main = Î»a.app (Î»x. x + x) a
\stoplambda
- This example shows a function \lam{app2} that takes a function as a
+ This example shows a function \lam{twice} that takes a function as a
first argument and applies that function twice to the second argument.
Again, we've made the function monomorphic for clarity, even though
this function would be a lot more useful if it was polymorphic. The
- function \lam{main} uses \lam{app2} to apply a lambda epression twice.
+ function \lam{main} uses \lam{twice} to apply a lambda epression twice.
When faced with a user defined function, a body is available for that
function. This means we could create a specialized version of the
@@ -1808,23 +1808,23 @@
Applying this transformation to the example gives:
\startlambda
- app2' :: Word -> Word
- app2' = Î»b.(Î»f.Î»a.f (f a)) (Î»x. x + x) b
+ twice' :: Word -> Word
+ twice' = Î»b.(Î»f.Î»a.f (f a)) (Î»x. x + x) b
main = Î»a.app' a
\stoplambda
The \lam{main} function is now in normal form, since the only higher
order value there is the top level lambda expression. The new
- \lam{app2'} function is a bit complex, but the entire original body of
- the original \lam{app2} function is wrapped in a lambda abstraction
+ \lam{twice'} function is a bit complex, but the entire original body of
+ the original \lam{twice} function is wrapped in a lambda abstraction
and applied to the argument we've specialized for (\lam{Î»x. x + x})
and the other arguments. This complex expression can fortunately be
effectively reduced by repeatedly applying Î²-reduction:
\startlambda
- app2' :: Word -> Word
- app2' = Î»b.(b + b) + (b + b)
+ twice' :: Word -> Word
+ twice' = Î»b.(b + b) + (b + b)
\stoplambda
This example also shows that the resulting normal form might not be as