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

We should favor big programs that contain as many features as possible. This way, less time is wasted on developing many programs.

We should favor small, independent programs that do one thing and do it well. 

Programs should use plain text for input and output.

Programs should use binary format for input and output.

**(Select all that apply)** What are the key ideas of Unix philosophy’s rule of composition?

(Select all that apply) What are the key ideas of Unix philosophy’s rule of composition?

Functions have no side effects in the functional paradigm. 

We can draw boxes and lines in a functional paradigm.

Various functions can be connected to each other by relying on a shared interface like lists or streams.

**(Select all that apply)** Why can we build dataflow programs with functions in the functional paradigm?


(Select all that apply) Why can we build dataflow programs with functions in the functional paradigm?

Given the square function: 

```ocaml
let square x = x * x
```

**(Select all that apply)** What is the result of the following OCaml expression?

```ocaml
2 |> square
```


Given the square function:
<pre><code class="language-ocaml">let square x = x * x
</code></pre>
(Select all that apply) What is the result of the following OCaml expression?
<pre><code class="language-ocaml">2 |&gt; square
</code></pre>

**(Select all that apply)** What is the value of the following OCaml code that implements a dataflow program?

```ocaml
[0; 1; 2] |> List.map (fun x -> x > 0) |> List.fold_left (&&) true
```

(Select all that apply) What is the value of the following OCaml code that implements a dataflow program?
<pre><code class="language-ocaml">[0; 1; 2] |&gt; List.map (fun x -&gt; x &gt; 0) |&gt; List.fold_left (&amp;&amp;) true
</code></pre>

Streams make it easy to represent a finite sequence of data.

Streams allow us to model infinite sequences of data. 

Streams allow us to benefit from incremental computation since data is calculated on demand.

**(Select all that apply)** What are some of the key benefits of using streams?

(Select all that apply) What are some of the key benefits of using streams?

**(Select all that apply)** What is the result of the following OCaml expression?

```ocaml
[1; 2; 3; 4] |> List.filter ((<=) 3) |> List.map (( * ) 2) |> List.fold_left (+) 0
```

(Select all that apply) What is the result of the following OCaml expression?
<pre><code class="language-ocaml">[1; 2; 3; 4] |&gt; List.filter ((&lt;=) 3) |&gt; List.map (( * ) 2) |&gt; List.fold_left (+) 0
</code></pre>

It throws a `Division by zero` exception.


It is a delayed evaluation of type `lazy_t`.

**(Select all that apply)** What is the value of the following OCaml expression?

```ocaml
lazy (1/0)
```

(Select all that apply) What is the value of the following OCaml expression?
<pre><code class="language-ocaml">lazy (1/0)
</code></pre>

It throws a `Division by zero` exception.

Given the following OCaml expression

```
let expr = lazy (1/0)
```

**(Select all that apply)** What is the value of the following OCaml expression?

```ocaml
Lazy.force expr
```

Given the following OCaml expression
<pre><code>let expr = lazy (1/0)
</code></pre>
(Select all that apply) What is the value of the following OCaml expression?
<pre><code class="language-ocaml">Lazy.force expr
</code></pre>

Dataflow programming with function

Dataflow programming with function

Let’s test your understanding of dataflow programming with functions.

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 Dataflow Programming with Functions