**Pagini **

# Workshops

**Parteneri**

**This is an old revision of the document!**

Monads, baby!

Today we look at certain kinds of computations from a truly functional perspective:

- computations that might or might not have a value
- computations that might fail
- computations that will finish at some point

But we won't get into math and category theory for this.

We'll see what a monad is from a programming perspective, directly in the Scala language.

You can find today's contents here.

Let's implement some of our own monads.

- Let's write a monad equivalent with
`Option`

. Let's call this`Maybe`

, as in Haskell.- create a trait
`Maybe[T]`

(remember the`[T]`

is equivalent to Java's`<T>`

syntax for generics) - add some functional primitives as methods to
`Maybe`

:- the monad requirements:
`map`

,`flatMap`

,`filter`

`zipWith`

, which receives a`Maybe[A]`

and returns a`Maybe[(T,A)]`

The signature is just a tiny bit more complex:

def zipWith[A](other: Maybe[A]): Maybe[(T,A)]

`exists`

, which receives a predicate (a function of T to Boolean) and returns true if this instance contains an element which satisfies the predicate

- add some utility methods to the
`Maybe`

trait:`isEmpty`

`toList`

`size`

- create two case classes:
`Just[T]`

and`None`

and implement the methods- what is None, actually? a case class? a case object?
- methods should be quick to write and probably take two lines of code, at most