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

# Function with multiple arguments

One significant insight from lambda calculus is currying—we can formulate a function accepting multiple arguments as a nested chain of single-valued functions. Most functional programming languages, including OCaml, incorporate this technique into the language.

To illustrate, let’s look at OCaml’s built-in binary operator, `+`, to add two integers. Internally, OCaml implements `+` as a normal function. Although we normally use `+` in the infix notation like `1 + 2`, OCaml allows us to use `+` in the prefix notation by placing it in parentheses `(+)`. This means we can write `(+) 1 2`.




(** Using + in the prefix notation *)
let _ = print_int ((+) 1 2)

Except for its odd name, `(+)` is a normal function like any other function. It’s a binary function that accepts two integers and returns their sum. Its type is `int -> int -> int`.

> **Note:** The `->` operator is right-associative and so the type is equivalent to `int -> (int -> int)`. Ocaml defines the addition operator `+` as a function that takes one integer argument and returns a function of type `int -> int`.

OCaml and most functional programming languages only implement built-in support for single-valued functions and rely on the currying technique to represent multi-argument functions.
However, for the sake of convenience, those languages typically provide syntactic sugar to declare multi-argument  functions.
In particular, the `fun` keyword in OCaml also allows us to declare an anonymous function that accepts multiple arguments separated by spaces. For example: 

```ocaml
fun x y -> x * x + y * y
```

This is just a syntactic sugar for  `fun x -> fun y -> x * x + y * y`.

Similarly, the `let` binding allows us to define a named function of multiple arguments using a familiar syntax. For example:

```ocaml
let rectangle_area w h = w *. h
```

This definition is a syntactic sugar for `let rectangle_area = fun w -> fun h -> w *. h`. 


# Partial application

Currying allows us to apply a function to fewer actual arguments than the number of the function's formal arguments, a process known as **partial application**.

To illustrate, we previously defined a function to calculate a rectangle’s area with a given width and height:

```ocaml
let rectangle_area w h = w *. h
```
Due to currying, however, `rectangle_area` is actually a unary function that accepts a width `w` and returns another unary function. As a result, we can partially apply `rectangle_area` to just one argument.

```ocaml
rectangle_area 2.
```

Here, we obtain a unary function of the `float -> float` type that calculates the area of a rectangle whose width is fixed at `2.0`, and whose height is provided as an input. In fact, we can even give this new function a name and use it like any other function.

The following code illustrates currying in action:


Learn how we can use currying to chain functions to formulate multi-argument functions and how it enables partial application.


Use Currying for Function Chaining

Learn how we can use currying to chain functions to formulate multi-argument functions and how it enables partial application.

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

Use Currying for Function Chaining

Function with multiple arguments