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

# OCaml compiler

The recommended way to install the OCaml compiler on a local machine is to use the package manager [OPAM](https://opam.ocaml.org/doc/Install.html).

First, let’s use the following script to install OPAM:


```shell
$ sh <(curl -sL https://raw.githubusercontent.com/ocaml/opam/master/shell/install.sh)
```

The script checks the architecture of the computer and downloads and installs the suitable pre-compiled binary to `/usr/local/bin` by default.

Verify that OPAM has been installed successfully by typing in the terminal:

```shell
$ which opam
/usr/local/bin/opam
```

Next, follow the [instruction for installing OCaml via OPAM](https://ocaml.org/docs/install.html to install the latest OCaml compiler version. At the time of this writing, the latest OCaml compiler version is 4.12.0.

```shell
$ opam init
$ eval `opam env`
$ opam switch create 4.12.0
$ eval `opam env`
```

After this, install the following tools:

+ `ocamlc`: The OCaml bytecode compiler that compiles OCaml source files to bytecode files.
+ `ocamlopt`: The OCaml native compiler that compiles OCaml source files to native code object files and links them to produce standalone executables.
+ `ocamlrun`: The bytecode interpreter that executes bytecode files produced by `ocamlc`.

> Note: Verify that the OCaml bytecode compiler has been installed successfully before continuing.

```shell
$ which ocamlc
/Users/quang/.opam/4.12.0/bin/ocamlc
```

# REPL `utop`

A great way to learn functional programming with OCaml on a local machine is using the read–eval–print loop (REPL) `utop`. Use the package manager `OPAM` mentioned previously to install `utop`.

```shell
$ opam install utop
```

You can start `utop` by entering it in the shell.

```shell
$ utop
```
You should see something like the following screenshot:


Learn how to install the OCaml compiler and the REPL utop on your local machine as well as OCaml's compilation process.

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

Install OCaml Compiler

OCaml compiler