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

Any powerful programming language has to provide the means for assigning names to computations.
Consider, for example, the following OCaml expression.

```ocaml
3.14 *. 2.5 *. 2.5
```

Without further context, it is not obvious what this expression tries to achieve.
Now compare that with a new version where we associate those numbers with names.

let pi = 3.14
let radius = 2.
let circle_area = pi *. radius *. radius

(** Printing the value of 'circle_area' to the console. *)
let _ = print_float circle_area

This code is much clearer.
Anyone can recognize immediately that we are calculating the area of a circle with a radius, `2.0`.
Here, the `let` statement binds `pi` to `3.14` and `radius` to `2.0`.
These two names are used to calculate the circle area, which is then assigned to the new name, `circle_area`.

You might wonder “what’s the difference between a name declared by `let` binding in a functional programming language and a variable in an imperative programming language?” Despite their similar appearance, they differ fundamentally from each other. In the following lesson, we’ll look deeper into this difference.

# Names as labels to memory cells

The imperative programming paradigm is centered around variables and variable assignments, or statements for updating variables. Consider, for example, the following Java code snippet to sum the squares of first `n` natural numbers.

Learn how we can assign names to expressions to create abstractions.

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

Assign Names to Expressions

Names as labels to memory cells