There are many articles explaining the things I’m about to log about. This is just my personal take and understanding on the subject.

I think this is how Haskell Typeclasses are transposed in Ocaml.

```
class Functor f where
fmap :: (a -> b) -> f a -> f b
```

```
module type FUNCTOR = sig
type _ f
val fmap : ('a -> 'b) -> 'a f -> 'b f
end
```

The most common data types I can think of is the `Maybe`

data type from Haskell or the `option`

in Ocaml. These data types are how these languages the possibility of `null`

. These data types are going to prevent us from encoutering `NullReferenceException`

like in other languages.

```
data Maybe a
= Nothing
| Just a
```

```
type 'a option
None
= Some of 'a |
```

Maybe and Option instance of the `Functor`

typeclass.

```
instance Functor Maybe where
fmap f Nothing = None
fmap f (Just a) = Just (f a)
```

```
module OptionF : (FUNCTOR with type 'a f = 'a option) = struct
type 'a f = 'a option
let fmap f = function
None -> None
| Some a -> Some (f a)
| end
```

### In Action

```
capitalize :: Maybe Text -> Maybe Text
= fmap toUpper name capitalize name
```

In ghci

```
gchi> capitalize (Just "John")
ghci> Just "JOHN"
```

The main difference here is I have to specify which `fmap`

I have to use because Ocaml’s typesystem is not as powerful as Haskell’s where it will immediately determine which `fmap`

to use just based on the type.

```
let capitalize (name : string option) =
String.toUpperCase name
OptionF.fmap Js.
let _ = Js.log @@ capitalize (Some "John")
```

Bucklescript will represent `Some`

as an array.

`> ["JOHN"]`