Gain insights into functional programming with OCaml and Haskell, explore lambda calculus, abstractions, and dataflows, and learn to apply these concepts to real-world scenarios, contrasting with Java.

ocaml_utop_haskell.tar.gz

OCaml

Functional programming is a paradigm that builds complete applications by breaking down programs into constituent functions that empowers developers to build fast, bug-resistant applications.

You’ll be introduced to functional programming with illustrative examples contrasting the more widely used imperative programming paradigm. You’ll review lambda calculus as an introduction to expressions, the building blocks of functional programs. You’ll continue with abstractions and complex data types before exploring common computation patterns. Next, you’ll learn how dataflows create whole programs out of existing functions. Finally, you’ll finish by applying your functional programming knowledge to various real-world scenarios. At each step, you’ll learn OCaml and Haskell, while contrasting imperative programming with Java.

By the end of this course, you’ll be prepared to use functional programming in your daily work and have the framework to know when to use either imperative or functional paradigms.

Mastering Functional Programming with OCaml and Haskell

**(Select all that apply)** How many elements of the tripe (3-tuple) type, `string * int * bool`, can we have?

(Select all that apply) How many elements of the tripe (3-tuple) type, <code>string * int * bool</code>, can we have?

**(Select all that apply)** How many elements of the following algebraic datatype can we have?

```ocaml
type mytype = BoolVal of bool | Constant;;
```



(Select all that apply) How many elements of the following algebraic datatype can we have?
<pre><code class="language-ocaml">type mytype = BoolVal of bool | Constant;;
</code></pre>

If the list is not empty, it returns the head of the list wrapped inside `Some`. If the list is empty, it returns `None`.


If the list is not empty, it returns the head of the list. If the list is empty, it throws an exception.


**(Select all that apply)** What does the following function do?

```ocaml
let safe_hd l = match l with
                | [] -> None
                | hd :: tl -> Some hd
```

(Select all that apply) What does the following function do?
<pre><code class="language-ocaml">let safe_hd l = match l with
 | [] -&gt; None
 | hd :: tl -&gt; Some hd
</code></pre>

It updates the first element of `l` to `"John"` resulting in the list `["John"; "Adam"; "Anna"]`.

**(Select all that apply)** Given the following list in OCaml:

```ocaml
let l = ["Joe"; "Adam"; "Anna"]
```

What does the following expression do?

```ocaml
l[0] = "John"
```



(Select all that apply) Given the following list in OCaml:
<pre><code class="language-ocaml">let l = [&quot;Joe&quot;; &quot;Adam&quot;; &quot;Anna&quot;]
</code></pre>
What does the following expression do?
<pre><code class="language-ocaml">l[0] = &quot;John&quot;
</code></pre>

Our code is error-prone because we forgot to match the pattern `ComplexShape`.

**(Select all that apply)** The following algebraic data type represents geometric shapes:

```ocaml
type shape = Circle of float
 | Rectangle of float * float
 | ComplexShape of shape list
```

We decide to write the following OCaml function called `shape_to_string` which returns the string representation of a shape:

```ocaml
let rec shape_to_string s = match s with
 | Circle r -> "circle"
 | Rectangle _ -> "rectangle"
```

But the OCaml compiler gives the following warning message:

```ocaml
Lines 1-3, characters 28-63:
Warning 8: this pattern-matching is not exhaustive.
Here is an example of a case that is not matched:
ComplexShape _
val shape_to_string : shape -> string = <fun>

```

What is the OCaml compiler trying to tell us?

(Select all that apply) The following algebraic data type represents geometric shapes:
<pre><code class="language-ocaml">type shape = Circle of float
 | Rectangle of float * float
 | ComplexShape of shape list
</code></pre>
We decide to write the following OCaml function called <code>shape_to_string</code> which returns the string representation of a shape:
<pre><code class="language-ocaml">let rec shape_to_string s = match s with
 | Circle r -&gt; &quot;circle&quot;
 | Rectangle _ -&gt; &quot;rectangle&quot;
</code></pre>
But the OCaml compiler gives the following warning message:
<pre><code class="language-ocaml">Lines 1-3, characters 28-63:
Warning 8: this pattern-matching is not exhaustive.
Here is an example of a case that is not matched:
ComplexShape _
val shape_to_string : shape -&gt; string = &lt;fun&gt;

</code></pre>
What is the OCaml compiler trying to tell us?

```ocaml
f [] = ""
f [1] = "1"
f [1; 2] = "1; 2"
```

```ocaml
f [] = "[]"
f [1] = "[1]"
f [1; 2] = "[1; 2]"
```

```ocaml
f [] = ""
f [1] = "[1]"
f [1; 2] = "[1;2]"
```

**(Select all that apply)** Given the following function `f` in OCaml:

```ocaml
let f l = 
   let rec aux l = match l with
              | [] -> ""
              | hd :: [] -> string_of_int hd
              | hd :: tl -> (string_of_int hd) ^ "; " ^ (aux tl)
   in "[" ^ (aux l) ^ "]" 
```

What are the values of the following function applications?

```ocaml
f [] = ?
f [1] = ?
f [1; 2] = ?
```

(Select all that apply) Given the following function <code>f</code> in OCaml:
<pre><code class="language-ocaml">let f l = 
 let rec aux l = match l with
 | [] -&gt; &quot;&quot;
 | hd :: [] -&gt; string_of_int hd
 | hd :: tl -&gt; (string_of_int hd) ^ &quot;; &quot; ^ (aux tl)
 in &quot;[&quot; ^ (aux l) ^ &quot;]&quot; 
</code></pre>
What are the values of the following function applications?
<pre><code class="language-ocaml">f [] = ?
f [1] = ?
f [1; 2] = ?
</code></pre>

```ocaml
f 0 [] = None
f 0 ["Hello"] = Some 5 
f 1 ["Hello"; "Bye"] = Some 3
```


```ocaml
f 0 [] = 0
f 0 ["Hello"] = 5 
f 1 ["Hello"; "Bye"] = 3
```



**(Select all that apply)** Given the following OCaml function:

```ocaml
let f n l = Option.map String.length (List.nth_opt l n)
```

Where,
* `Option.map: ('a -> 'b) -> 'a option -> 'b option` maps an `option` to a new `option` using a function. 
* `List.nth_opt: 'a list -> int -> 'a option` returns the `n-`th element of a list if exists and `None` otherwise. The head of the list is at position 0.
* `String.length: string -> int` returns the length of a string.

What are the values of the following expressions?

```ocaml
f 0 [] = ?
f 0 ["Hello"] = ? 
f 1 ["Hello"; "Bye"] = ? 
```


(Select all that apply) Given the following OCaml function:
<pre><code class="language-ocaml">let f n l = Option.map String.length (List.nth_opt l n)
</code></pre>
Where,
<ul>
<li><code>Option.map: ('a -&gt; 'b) -&gt; 'a option -&gt; 'b option</code> maps an <code>option</code> to a new <code>option</code> using a function.</li>
<li><code>List.nth_opt: 'a list -&gt; int -&gt; 'a option</code> returns the <code>n-</code>th element of a list if exists and <code>None</code> otherwise. The head of the list is at position 0.</li>
<li><code>String.length: string -&gt; int</code> returns the length of a string.</li>
</ul>
What are the values of the following expressions?
<pre><code class="language-ocaml">f 0 [] = ?
f 0 [&quot;Hello&quot;] = ? 
f 1 [&quot;Hello&quot;; &quot;Bye&quot;] = ? 
</code></pre>

```ocaml
f Zero = 0
f (Succ Zero) = 1
f (Succ (Succ Zero)) = 2
```

```ocaml
f Zero = ""
f (Succ Zero) = "/"
f (Succ (Succ Zero)) = "//"
```

```ocaml
f Zero = ""
f (Succ Zero) = "/"
f (Succ (Succ Zero)) = "/ /"
```

**(Select all that apply)** The following algebraic datatype defines natural numbers:

```ocaml
type nat = Zero | Succ of nat
```

We define a the following function `f` on `nat`:

```ocaml
let rec f n = match n with
             | Zero -> ""
             | Succ Zero -> "/"
             | Succ n -> "/ " ^ (f n)
```

What are the values of the following expressions?

```ocaml
f Zero = ?
f (Succ Zero) = ?
f (Succ (Succ Zero)) = ?
```



(Select all that apply) The following algebraic datatype defines natural numbers:
<pre><code class="language-ocaml">type nat = Zero | Succ of nat
</code></pre>
We define a the following function <code>f</code> on <code>nat</code>:
<pre><code class="language-ocaml">let rec f n = match n with
 | Zero -&gt; &quot;&quot;
 | Succ Zero -&gt; &quot;/&quot;
 | Succ n -&gt; &quot;/ &quot; ^ (f n)
</code></pre>
What are the values of the following expressions?
<pre><code class="language-ocaml">f Zero = ?
f (Succ Zero) = ?
f (Succ (Succ Zero)) = ?
</code></pre>

Compound data types

Compound data types

Let’s test your understanding of compound datatypes.

Introduction

Expressions: Building Blocks of Functional Programs

Building Abstractions with Functions

Compound Data Types

Common Computation Patterns

Dataflow Programming with Functions

Applying Functional Programming to Various Domains

Conclusion

Appendix

Quiz on Compound Datatypes