Added records and if

Author: JustusAdam

script/source/compiler.rst

@@ -55,12 +55,12 @@ In this course we will use optional extensions of the Haskell language which not
 I therefore highly recommend using the GHC as your Haskell compiler.
 
 For more information about the various parts of the GHC see the `compiler reference pages <https://downloads.haskell.org/~ghc/latest/docs/html/users_guide/>`__.
-There you will find information on `compiler flags <https://downloads.haskell.org/~ghc/latest/docs/html/users_guide/flags.html>`__, the `interactive prompt GHCi <ghci reference pages>`_, including the `debugger <https://downloads.haskell.org/~ghc/latest/docs/html/users_guide/ghci.html#the-ghci-debugger>`__, `profiling <https://downloads.haskell.org/~ghc/latest/docs/html/users_guide/profiling.html>`__, and the `GHC Haskell extensions <https://downloads.haskell.org/~ghc/latest/docs/html/users_guide/glasgow_exts.html#syntactic-extensions>`__.
+There you will find information on `compiler flags <https://downloads.haskell.org/~ghc/latest/docs/html/users_guide/flags.html>`__, the `interactive prompt GHCi <ghci-reference-pages>`_, including the `debugger <https://downloads.haskell.org/~ghc/latest/docs/html/users_guide/ghci.html#the-ghci-debugger>`__, `profiling <https://downloads.haskell.org/~ghc/latest/docs/html/users_guide/profiling.html>`__, and the `GHC Haskell extensions <https://downloads.haskell.org/~ghc/latest/docs/html/users_guide/glasgow_exts.html#syntactic-extensions>`__.
 We will discuss all these topics in the future.
 
 We will rarely interact directly with the compiler, as there are very nice :ref:`build tools` out there which we will make use of instead.
 
-.. _ghci reference pages: https://downloads.haskell.org/~ghc/latest/docs/html/users_guide/ghci.html
+.. _ghci-reference-pages: https://downloads.haskell.org/~ghc/latest/docs/html/users_guide/ghci.html
 
 .. _GHCi:
 
@@ -70,7 +70,7 @@ The interactive Interpreter (GHCi)
 The GHC also supports the interpreted execution of code.
 For one this allows you to directly run a Haskell source file with the ``runghc`` or ``runhaskell`` program.
 Furthermore any standard installation of GHC includes a program in which you can interactively type Haskell code, inspect it and run it.
-The program is called GHCi (``ghci`` is the executable name) which stands for "GHC interpreter". (`ghci reference pages`_)
+The program is called GHCi (``ghci`` is the executable name) which stands for "GHC interpreter". (`ghci reference pages <ghci-reference-pages>`_)
 GHCi is very simlar to programs like the python or ruby interpreter with the notable difference that the code you type is type checked, like normal Haskell programs, before it is executed.
 The GHCi also includes a debugger for Haskell code (similar to `gdb <https://www.sourceware.org/gdb/>`__) which we will :ref:`study in a later chapter <ghci-debugger>`.
 

script/source/functions.rst

@@ -39,7 +39,7 @@ Ergo ``Int -> Bool`` applied to ``Int`` gives a ``Bool``.
 Similarly ``a -> a`` applied to ``Int`` gives an ``Int`` again.
 An ``a -> a`` applied to a ``Bool`` gives a ``Bool``.
 
-To apply a function we ise the simplest synta of all, juxtaposition.
+To apply a function we use the simplest syntax of all, juxtaposition.
 Also called *postfix notation* or "the function followed by the arguments, all space separated".
 
 ::
@@ -155,5 +155,5 @@ Instead we may write
     myFunction (Constr2 v2) = ...
 
 .. note:: 
-    Here we must use parentheses around the match clauses to distinguish the clauses for several arguments.
+    Here we must use parentheses around the match clauses to distinguish the clauses for the different arguments.
 

script/source/syntax.rst

@@ -91,7 +91,7 @@ Tuples
 
     More on the tuple type in the next section.
 
-Note that there are not *special* literals for booleans in Haskell as they are just a regular :ref:`data structure <user defined datatypes>`.
+Note that there are not *special* literals for booleans in Haskell as they are just a regular :ref:`data structure <user defined types>`.
 The literals for ``Bool`` are ``True`` and ``False``.
 
 .. _bindings:
@@ -128,6 +128,24 @@ Note that the second occurrence of ``myInt`` must be properly indented.
 We will explore the indentation rules in more detail later.
 
 
+.. _if:
+
+``if`` expressions
+------------------
+
+In Haskell ``if`` is not a statement, but in expression, meaning that it returns a value.
+Therefore ``if`` always has a type, and also always has an ``else`` case, which must return a value of the same type.
+For instance we can assign the result of ``if`` to a binding.
+
+::
+
+    let aBool = False
+
+    let anInt = if aBool then 8 else 9
+
+Parentheses are not required and one may write any expression on the branches and for the condition of an ``if``.
+
+
 
 .. rubric:: footnotes
 

script/source/types.rst

@@ -1,3 +1,4 @@
+.. _types:
 
 Types
 =====
@@ -132,7 +133,7 @@ if we used a ``type`` alias the user could simply pass a ``String`` to the ``sen
 The ``case`` construct
 ----------------------
 
-The ``case`` construct together with function application basically comprise everything which you can do with Haskell at runtime.
+The ``case`` construct together with function application basically comprises everything which you can do in Haskell.
 The ``case`` construct is used to deconstruct a type and gain access to the data contained withtin.
 
 
@@ -296,5 +297,68 @@ Some examples for concrete instances of special types:
 Record syntax
 -------------
 
+For convenience reasons there is some extra syntax for defining data types which also automatically creates some field accessor functions.
+
+We can write the following:
+
+::
+
+    data TyType = 
+        Constructor { field1 :: Int
+                    , field2 :: String
+                    }
+
+This defines the type the same way as the other ``data`` construct.
+Meaning we can pattern match as usual on the constructor.
+
+
+::
+
+    data MyType = Constructor Int String
+
+    let theData = Constructor 9 "hello" :: MyType
+    let theInt = case theData of
+                    Constructor i _ -> i
+    
+    theInt == 9
+
+But additionally it also defines two functions ``field1`` and ``field2`` for accessing the fields.
+
+Aka it generates code similar to the following:
+
+::
+
+    data MyType = Constructor Int String
+
+    field1 :: MyType -> Int
+    field1 (Constructor i _) = i
+
+    field2 :: MyType -> String
+    field2 (Constructor _ s) = s
+
+Also the two accessor functions ``field1`` and ``field2`` may be used in a special *record update syntax* to create a new record from an old one with altered field contents.
+Additionally the record may be created with a special record creation syntax.
+
+::
+
+    data TyType = 
+        Constructor { field1 :: Int
+                    , field2 :: String
+                    }
+
+    let v1 = Constructor 9 "Hello" :: MyType
+    
+    -- record creation syntax
+    let v2 = Constructor { field2 = "World", field1 = 4 } :: MyType
+
+    -- update syntax
+    let v3 = v2 { field1 = 9 }
+    -- updating multiple fields at once
+    let v4 = v2 { field1 = 9, field2 "Hello" }
+
+    v1 == v4
+
+    -- old records are unchanged
+    v2 /= v3 /= v4