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

Functional programming is an excellent fit for processing hierarchical data structures, such as formal languages or data formats. In this lesson, we’ll use OCaml to represent and manipulate [JSON](https://en.wikipedia.org/wiki/JSON)—a text-based data exchange format widely used to exchange data across the network, such as in web services. Handling JSON provides us with an excellent opportunity to apply many of the techniques we’ve learned, including algebraic datatypes, functions, and higher-order functions.

The following example shows a possible JSON representation describing the classic movie “The Godfather.” For the sake of simplicity, we’ll list only three actors in this example:



```json
{
  "title": "Godfather",
  "genre": [
    "crime",
    "drama"
  ],
  "year": 1972,
  "actors": [
    {
      "actor": "Marlon Brando",
      "character": "Vito Corleone",
      "is_major_character": true
    },
    {
      "actor": "Al Pacino",
      "character": "Michael Corleone",
      "is_major_character": true
    },
    {
      "actor": "Lenny Montana",
      "character": "Luca Brasi",
      "is_major_character": false
    }
  ],
  "is_on_netflix": true
}
```


A JSON structure like the one above may be used by a desktop application to store movie data. It might also come from a web service, like REST API, which provides movie information.



# Represent JSON as an algebraic data type

To figure out how to represent the JSON structure in OCaml, we have to think about the different ways to define a valid JSON. The simplest valid JSON can be one of the following primitive values:


+ A null value
+ A string such as `"Hello"`
+ An integer such as `123`
+ A float value such as `12.34`
+ A boolean value such as `true` or `false`

There’re two ways to build a more complex JSON, as shown below:


* A JSON array of values, such as `["crime", "drama"]`. Notice that the array elements can be any JSON. Furthermore, the elements might have different types, for example, `["Hello", 42, true]`. 

* A JSON object, which begins with a left brace `{` and ends with a right brace `}`. Inside the braces is a collection of key-value pairs delimited by commas `,` where the key is a string and the value is any JSON. For example:

```json
{
   "title": "Godfather",
   "genre": [
      "crime",
      "drama"
   ],
   "year": 1972
}

```


The JSON structure is hierarchical and characterized by various cases. As a result, it can be represented naturally by an algebraic data type, as shown below:

```haskell
type json = Null
          | String of string
          | Int of int
          | Float of float
          | Bool of bool
          | Array of json list
          | Object of (string * json) list
```

> Note: We use a list to represent a JSON array. Moreover, we represent a JSON object as a list of pairs of type `(string * json)`, where the key is a string and the value is a JSON.

Apply functional programming practices to define a library to handle JSON.

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

Handling JSON