Mônadas, monoides e functores

Marcelo Camargo

Analista de sistemas, tradutor e especialista em linguagens de programação

marcelocamargo@linuxmail.org

github.com/haskellcamargo

Sobre

Analista de sistemas, tradutor e projetista de linguagens de programação e compiladores

Quack programming language
Capybara programming language
PHP core

1. Computações podem falhar!

var head = function(list) {
  return list[0];
}

head :: [a] -> a
head (x:_) = x

main :: IO ()
main = print $ head []

NULL!?

Cada vez que você retorna null, uma capivara morre

O que pode dar errado?

─ Operações de I/O

─ Padrões não exaustivos

─ Requisições HTTP

2. Conceitos e definições

A MONAD IS JUST A MONOID

IN THE CATEGORY OF THE ENDOFUNCTORS

class Monad m where
  return   :: a -> m a
  (>>=)    :: m a -> (a -> m b) -> m b
  (>>)     :: m a -> m b -> m b
  (m >> n) :: m >>= \_ -> n

Monoide

─ Estrutura algébrica

─ Satisfaz o princípio da identidade (no-op)

0 + 7 == 7 + 0 == 7
[] ++ [1, 2, 3] == [1, 2, 3] ++ [] == [1, 2, 3]
{} union {apple} == {apple} union {} == {apple}

─ Um conjunto de objetos e uma maneira de

combiná-los

Functor

─ Trabalhar com uma estrutura sem tocá-la

─ Implementa fmap

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

-- Should obey
fmap id      = id
fmap (p . q) = (fmap p) . (fmap q)

─ Mapeamento entre categorias

Endofunctor

─ Um functor que mapeia A -> A

─ Implementa fmap

µ :: Monad m => m (m a) -> m a

─ Logo, mônadas são monoides e enquadram- se na categoria dos endofunctores!

Monads?

Monads!

data Maybe = Just a | Nothing

> fmap (+3) (Just 2)
Just 5

instance Functor Maybe where
  fmap func (Just val) = Just (func val)
  fmap func Nothing = Nothing

fmap aplicado de função a função

>>=

Thank you, Aditya Bhargava!

3. Usando mônadas para resolver problemas

module IOExample where

-- Usando binding, aplicando um monad
-- IO String e retornando um monad IO ()
main :: IO ()
main = getLine >>= putStrLn

-- Usando a do-notation para
-- simplificar o trabalho
main' :: IO ()
main' = do
  line <- getLine
  putStrLn line

module MaybeExample where
import Data.Maybe

-- Definição segura de head
head' :: [a] -> Maybe a
head' [] = Nothing
head' (x:_) = Just x

-- Uso seguro de head
main :: IO ()
main = do
  h  <- head' [1] -- head' [1] >>= ...
  h' <- head' []
  print h
  print h'

// findUser :: Integer -> Maybe { name :: String }
var findUser = function(id) { ... }

var handleUser = function(id) {
  findUser(id)
    .bind(user => {
        console.log("Welcome, " + user + "!");
    });
}

// findUser :: Integer -> Maybe { name :: String }
var findUser = function(id) { ... }

var handleUser = function(id) {
  var user = findUser(id).def("Visitante");
  console.log("Bem-vindo, " + user + "!");
}

4. Conclusão

1. Computações podem falhar!

2. Mônadas encapsulam "estados"

3. Acadêmicos complicam o termo

4. Mônadas são amor <3

Obrigado!

Perguntas?