In this course, you'll study the fundamentals and principles of functional programming.

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)** What is the output of the following function call?

```ocaml
List.map ((+) 1) [1; 2; 3]
```

(Select all that apply) What is the output of the following function call?
<pre><code class="language-ocaml">List.map ((+) 1) [1; 2; 3]
</code></pre>

```ocaml
('a -> 'b) -> 'a list -> 'b list -> 'c list
```

```ocaml
('a -> 'b -> 'c) -> 'a list -> 'b list -> 'c list
```

**(Select all that apply)** What is the type of `zipWith`?

(Select all that apply) What is the type of <code>zipWith</code>?

**(Select all that apply)** Given the following list of pairs representing 2D points:

```ocaml
let points = [(0., 0.); (1., 2.); (1.5, 3.5)]
```

What is the value of the following expression?

```ocaml
List.map fst points
```

(Select all that apply) Given the following list of pairs representing 2D points:
<pre><code class="language-ocaml">let points = [(0., 0.); (1., 2.); (1.5, 3.5)]
</code></pre>
What is the value of the following expression?
<pre><code class="language-ocaml">List.map fst points
</code></pre>

It’s a  `filter` function which filters a list based on a given predicate.


**(Select all that apply)** Given the following function formulated using `List.fold_right`:

```ocaml
let f p l = List.fold_right (fun x acc -> if p x then x :: acc else acc) l []
```

What does `f` do?

(Select all that apply) Given the following function formulated using <code>List.fold_right</code>:
<pre><code class="language-ocaml">let f p l = List.fold_right (fun x acc -&gt; if p x then x :: acc else acc) l []
</code></pre>
What does <code>f</code> do?

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


```ocaml
f [] = "0"
f [1] = "(1+0)"
f [1; 2] = "(1+(2+0))"
```


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

```ocaml
let f l = List.fold_right (fun x acc -> "(" ^ (string_of_int x) ^ "+" ^ acc ^ ")") l "0"
```

What are the values of the following expressions?

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


(Select all that apply) Given the following OCaml function:
<pre><code class="language-ocaml">let f l = List.fold_right (fun x acc -&gt; &quot;(&quot; ^ (string_of_int x) ^ &quot;+&quot; ^ acc ^ &quot;)&quot;) l &quot;0&quot;
</code></pre>
What are the values of the following expressions?
<pre><code class="language-ocaml">f [] = ?
f [1] = ?
f [1; 2] = ?
</code></pre>

It returns `true` if all elements of a list are different and `false` otherwise.

It returns `true` if all elements of a list are equals and `false` otherwise.

**(Select all that apply)** Assume we have the following functions:

**`zipWith`**

```ocaml
let rec zipWith f l1 l2 = match l1, l2 with
                          | [], _ -> []
                          | _, [] -> []
                          | x :: xs, y :: ys -> f x y :: zipWith f xs ys
```

**`all`**

```ocaml
let all l = List.fold_right (&&) l true
```

Using these functions, we define the following function:

```ocaml
let f l = match l with
          | [] -> true
          | hd :: tl -> all (zipWith (=) l (List.tl l))
```

What does `f` do?

(Select all that apply) Assume we have the following functions:
<code>zipWith</code>
<pre><code class="language-ocaml">let rec zipWith f l1 l2 = match l1, l2 with
 | [], _ -&gt; []
 | _, [] -&gt; []
 | x :: xs, y :: ys -&gt; f x y :: zipWith f xs ys
</code></pre>
<code>all</code>
<pre><code class="language-ocaml">let all l = List.fold_right (&amp;&amp;) l true
</code></pre>
Using these functions, we define the following function:
<pre><code class="language-ocaml">let f l = match l with
 | [] -&gt; true
 | hd :: tl -&gt; all (zipWith (=) l (List.tl l))
</code></pre>
What does <code>f</code> do?

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


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


The following algebraic datatype defines natural numbers:

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

**(Select all that apply)** The following function implements `fold` on `nat`:

```ocaml
let rec fold_nat f init n = match n with
                            | Zero -> init
                            | Succ m -> f (fold_nat f init m)
```

We use `fold_nat` to define the following function:

```ocaml
let f = fold_nat ((^) "-") ""
```

What are the values of the following expressions?

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



The following algebraic datatype defines natural numbers:
<pre><code class="language-ocaml">type nat = Zero | Succ of nat
</code></pre>
(Select all that apply) The following function implements <code>fold</code> on <code>nat</code>:
<pre><code class="language-ocaml">let rec fold_nat f init n = match n with
 | Zero -&gt; init
 | Succ m -&gt; f (fold_nat f init m)
</code></pre>
We use <code>fold_nat</code> to define the following function:
<pre><code class="language-ocaml">let f = fold_nat ((^) &quot;-&quot;) &quot;&quot;
</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>

It captures the general type of `map` on any container, domain, or context denoted by `f`. 

It captures a binary function denoted by `f`.

**(Select all that apply)** Haskell defines the following _typeclass_ called `Functor`:

```haskell
class Functor f where
 fmap :: (a -> b) -> f a -> f b
 (<$) :: a -> f b -> f a
```

Here `f` represents some _type_. 

The `fmap` function looks quite familiar, doesn’t it? What does `fmap` capture?

(Select all that apply) Haskell defines the following typeclass called <code>Functor</code>:
<pre><code class="language-haskell">class Functor f where
 fmap :: (a -&gt; b) -&gt; f a -&gt; f b
 (&lt;$) :: a -&gt; f b -&gt; f a
</code></pre>
Here <code>f</code> represents some type.
The <code>fmap</code> function looks quite familiar, doesn’t it? What does <code>fmap</code> capture?

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 Common Computation Patterns