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

## Challenge 1: `map` on `either` type

The following algebraic datatype defines the `either` type:

```ocaml
type ('a, 'b) either = Left of 'a | Right of 'b
```

As a convention, `Right of 'b` holds the correct value while `Left of 'a` represents an error value. 

Write a mapping function for `either` called `map_either : ('a -> 'b) -> ('c, 'a) either -> ('c, 'b) either`.

Examples:

```ocaml
map_either (fun x -> x * x) (Right 2)= Right 4
map_either (fun x -> x * x) (Left "Error case") = Left "Error case"
```

(** [square x] returns the square of an input integer. *)
let square x = x * x

type ('a, 'b) either = Left of 'a | Right of 'b

(** [map_either f e] applies a function [f] to an either [e]. *)
let map_either f e = Left "TODO" (* TODO: Replace the hard-coded value with your code here *)

let map_either f e = match e with
                     | Left x -> Left x
                     | Right y -> Right (f y)

## Challenge 2: `fold_left`

The function, `List.fold_right: ('a -> 'b -> 'b) -> 'a list -> 'b -> 'b`, folds a list from right to left. For example, `List.fold_right (-) [1; 2; 3] 0` calculates the expression `(1 - (2 - (3 - 0))) = -2`. Here, the initial value 0 is combined with the last element 3 of the list. We combine the result with the second to last element, which is 2, and so on.

If we fold a list from left to right, the expression would be `(((0 - 1) - 2) - 3) = -6`. The initial value 0 is combined with the first element 1. We combine the result with the second element and so on. Write an OCaml function, `fold_left: ('a -> 'b -> 'a) -> 'a -> 'b list -> 'a`, to fold the list from left to right. This function accepts a binary function `f`, an accumulator `acc`, and a list. 

Examples:

```ocaml
fold_left (-) 0 [1] = -1
fold_left (-) 0 [1; 2; 3] = -6
```

Beware that the `fold_left` function has a different order of parameters than the `fold_right` function.


# Challenge 1: `map` on `either` type

The following algebraic datatype defines the `either` type:

```ocaml
type ('a, 'b) either = Left of 'a | Right of 'b
```

As a convention, `Right of 'b` holds the correct value while `Left of 'a` represents an error value. 

Write a mapping function for `either` called `map_either : ('a -> 'b) -> ('c, 'a) either -> ('c, 'b) either`.

Examples:

```ocaml
map_either (fun x -> x * x) (Right 2)= Right 4
map_either (fun x -> x * x) (Left "Error case") = Left "Error case"
```

# Challenge 2: `fold_left`

The function, `List.fold_right: ('a -> 'b -> 'b) -> 'a list -> 'b -> 'b`, folds a list from right to left. For example, `List.fold_right (-) [1; 2; 3] 0` calculates the expression `(1 - (2 - (3 - 0))) = -2`. Here, the initial value 0 is combined with the last element 3 of the list. We combine the result with the second to last element, which is 2, and so on.

If we fold a list from left to right, the expression would be `(((0 - 1) - 2) - 3) = -6`. The initial value 0 is combined with the first element 1. We combine the result with the second element and so on. Write an OCaml function, `fold_left: ('a -> 'b -> 'a) -> 'a -> 'b list -> 'a`, to fold the list from left to right. This function accepts a binary function `f`, an accumulator `acc`, and a list. 

Examples:

```ocaml
fold_left (-) 0 [1] = -1
fold_left (-) 0 [1; 2; 3] = -6
```

Beware that the `fold_left` function has a different order of parameters than the `fold_right` function.


Let's solve coding challenges to practice common computation patterns.

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

Programming Challenges

Challenge 1: `map` on `either` type

Challenge 2: `fold_left`

Programming Challenges

Challenge 1: map on either type

Challenge 2: fold_left

Challenge 1: `map` on `either` type

Challenge 2: `fold_left`