O documento discute como a programação funcional pode ser uma ferramenta útil para controlar a complexidade de programas. Apresenta abstrações funcionais como monóides e mônadas que permitem expressar programas de forma mais concisa e abstrata, facilitando a composição e raciocínio sobre corretude.

1. OU COMO
PROGRAMAÇÃO FUNCIONAL É UMA ÓTIMA FERRAMENTA PARA CONTROLE
DE COMPLEXIDADE.
PROGRAMAS E FUNÇÕES
SOBRE
PENSANDO EM CORRETUDE,

2. Pessoas cometem erros
Programadores são pessoas
∴ Programadores cometem erros

3. Ferramentas e linguagens importam;

4. Ajudam a expressar, abstrair e construir.

5. Arthur Xavier
Estudante de Ciência da Computação;
Apaixonado por programação funcional;
Membro ativo da comunidade FP;
Desenvolvendo com Phil Freeman uma formalização
de interfaces de usuário declarativas com Comonads;

6. OU COMO
PROGRAMAÇÃO FUNCIONAL É UMA ÓTIMA FERRAMENTA PARA CONTROLE
DE COMPLEXIDADE.
PROGRAMAS E FUNÇÕES
SOBRE
PENSANDO EM ABSTRAÇÃO,

7. Outline
Por que programação funcional;
Abstrações funcionais;
Complexidade sem dificuldade:
1. Monóides;
2. Mônadas.

8. Corretude & Abstração

9. Corretude?

10. comando1();
comando2(); // mudança de estado
variável = comando3(); // estado privado
if (variável.atributo)
exceção!
envia_email(); // mudança de estado
lança_míssil();
return variável;

11. Como garantir corretude dessa forma?

13. Linguagens convencionais
Semântica sequencial de transições de estado;
Divisão entre mundo das expressões vs. comandos;
Dificuldade de combinar programas;
Ausência de propriedades matemáticas.

14. Máquina de Turing vs. Cálculo-λ

15. Abstração?

16. Valores; (imutáveis)
Funções; (puras)

17. Composição.

18. Funções de ordem superior!

19. Funções de ordem superior
Versatilidade;
Expressividade;
Poder de abstração;

20. // users = usernames.map(getAccount)
users.map(numberOfPosts).reduce(maximum, 0)
=
users.reduce(maximum ∘ numberOfPosts)

21. // users = map(usernames, getAccount)
reduce(maximum, 0, map(numberOfPosts, users))
=
reduce(maximum ∘ numberOfPosts, 0, users)

22. HASKELL
-- users = map usernames getAccount
reduce maximum 0 (map numberOfPosts users)
=
reduce (maximum . numberOfPosts) 0 users

23. Transparência referencial ⇒ raciocínio equacional.

24. Separação entre dados e comportamento.

25. Composição de funções ⇒ composição de programas.

26. Corretude ⟺ Abstração

27. Corretude por construção.

28. ~ Abstração ~

29. Matemática!

30. Álgebra abstrata & Teoria de categorias

31. MONÓIDES

32. Conjunto S com uma operação binária •, tal que
1. ∀a,b ∈ S : a•b ∈ S. (fechamento)
2. ∀a,b,c ∈ S : (a•b)•c = a•(b•c). (associatividade)
3. ∃e ∈ S : ∀a ∈ S : e•a = a•e = a. (identidade)

33. Acumulador com “elemento neutro”;

34. (a + b) + c = a + (b + c).
a + 0 = 0 + a = a.

35. (a × b) × c = a × (b × c).
a × 1 = 1 × a = a.

36. max(max(a, b), c) = max(a, max(b, c)).
max(a, 0) = max(0, a) = a. (a > 0)

37. Monóides são ubíquos.

38. Yorgey, B. A. (2012). Monoids: theme and variations (functional pearl).

39. connectionBuilder
.withHost("myhost.com")
.withRemote("remote.com")
.withAuth(PASSWORD)
.build()

40. recipe =
withHost("myhost.com")
+ withRemote("remote.com")
+ withAuth(PASSWORD)
build(recipe)

41. Mas e daí?
O que isso traz? O que isso abstrai?

42. Dividir para conquistar.

43. Paralelismo & Incrementalidade

44. (a•b)•c
=
((a1
•a2
•a3
)•(b1
•b2
))•(c1
•c2
)
=
(((a11
•a12
)•a2
•(a31
•a32
• …))•(b1
•b2
))•(c1
•(c11
•c12
• …))

45. HASKELL
class Monoid s where
(<>) :: s -> s -> s
mempty :: s

46. Mas e as leis?

47. HASKELL
(a <> b) <> c ≡ a <> (b <> c)
mempty <> a ≡ a
a <> mempty ≡ a

48. Não tem como garantir.
¯_(ツ)_/¯

49. HASKELL
data Add = Add Int
instance Monoid Add where
Add a <> Add b = Add (a + b)
mempty = Add 0
…
data Mult = Mult Int
instance Monoid Mult where
Mult a <> Mult b = Mult (a * b)
mempty = Mult 1

50. HASKELL
data Add a = Add a
instance Num a => Monoid (Add a) where
Add a <> Add b = Add (a + b)
mempty = Add 0
…
data Mult a = Mult a
instance Num a => Monoid (Mult a) where
Mult a <> Mult b = Mult (a * b)
mempty = Mult 1

51. HASKELL
instance (Monoid a, Monoid b) => Monoid (a, b) where
(a1, b1) <> (a2, b2) = (a1 <> a2, b1 <> b2)
mempty = (mempty, mempty)

52. HASKELL
data Max a = Max a
instance Ord a => Monoid (Max a) where
Max a <> Max b = Max (if a < b then a else b)
mempty = Max ??

53. HASKELL
data Max a = Max a
instance (Ord a, Bounded a) => Monoid (Max a) where
Max a <> Max b = Max (if a < b then a else b)
mempty = Max minBound

54. HASKELL
foldMap :: Monoid m => (a -> m) -> [a] -> m
foldMap f [] = mempty
foldMap f (a:as) = f a <> foldMap f as

55. HASKELL
foldr maximum 0 (map numberOfPosts users)
=
foldr (maximum . numberOfPosts) 0 users
≅
foldMap (Max . numberOfPosts) users

56. HASKELL
> foldMap (Max . numberOfPosts) [user1, user2, …]
Max 10
> foldMap (Max . numberOfPosts) []
Max (-9223372036854775808)

57. HASKELL
data Maybe a = Nothing | Just a
instance Monoid a => Monoid (Maybe a) where …
…
> foldMap (Just . Max . numberOfPosts) []
Nothing

58. Exemplo: builder

59. HASKELL
data Builder a = Builder (a -> a)
instance Monoid (Builder a) where
Builder f <> Builder g = Builder (f . g)
mempty = Builder id
build :: a -> Builder a -> a
build def (Builder builder) = builder def

60. HASKELL
data Connection = Connection
{ host :: String
, auth :: Authentication
, …
}
withHost :: String -> Builder Connection
withHost host = Builder (conn -> conn { host = host })
…
buildConnection :: Builder Connection -> Connection
buildConnection = build defaultConnection
where
defaultConnection = Connection { … }

61. HASKELL
conn :: Connection
conn = buildConnection recipe
where
recipe =
withHost "myhost.com"
<> withRemote "remote.com"
<> withAuth Password

62. Disjunção de predicados;
Conjunção de predicados;
Conjuntos com união;
Composição de opções;
Combinação de regras;
Interseção de formas bidimensionais;
Funções que retornam monóides;
Combinação de máquinas de estado;

63. MÔNADAS

64. Pra quê?

65. Exemplo: logging

66. HASKELL
add1 :: Int -> (Int, String)
add1 x = (x + 1, "+1")
mul3 :: Int -> (Int, String)
mul3 x = (x * 3, "*3")
-- deseja-se
add1 30 ?? mul3 ?? add1 = (94, "+1*3+1")
-- mas o que é (??)

67. HASKELL
add1 :: Int -> (Int, String)
add1 x = (x + 1, "+1")
mul3 :: Int -> (Int, String)
mul3 x = (x * 3, "*3")
-- ou ainda
do
x <- add1 30
y <- mul3 x
add1 y

68. HASKELL
add1 :: Int -> (Int, String)
add1 x = (x + 1, "+1")
mul3 :: Int -> (Int, String)
mul3 x = (x * 3, "*3")
-- deseja-se
add1 30 ?? mul3 ?? add1 = (94, "+1*3+1")
-- mas o que é (??)

69. HASKELL
(??) :: (Int, String) -> (Int -> (Int, String)) -> (Int, String)

70. Produção de contexto na saída;

71. Impureza na saída;

72. Sequencialidade.

73. Tipo m com duas operações pure e bind
pure :: a -> m a
bind :: a -> (a -> m b) -> m b
(>>=) = bind

74. HASKELL
(m >>= f) >>= g ≡ m >>= (x -> f x >>= g)
pure x >>= f ≡ f x
m >>= return ≡ m

75. HASKELL
class Monad m where
(>>=) :: m a -> (a -> m b) -> m b
pure :: a -> m a

76. HASKELL
(>=>) :: (a -> m b) -> (b -> m c) -> (a -> m c)
f >=> g = (f x) >>= g

77. HASKELL
(f >=> g) >=> h ≡ f >=> (g >=> h)
pure >=> f ≡ f
f >=> pure ≡ f

78. HASKELL
(a <> b) <> c ≡ a <> (b <> c)
mempty <> a ≡ a
a <> mempty ≡ a

79. “A monad is just a monoid in the category of endofunctors,
what’s the problem?”

80. Writer: logging
a -> (b, m)

81. Writer: logging
a -> (b, m)Monoid m =>

82. HASKELL
data Writer a = Writer (a, String)
instance Monad Writer where
pure a = Writer (a, "")
Writer (a, s) >>= f = Writer (b, s ++ s2)
where
Writer (b, s2) = f a

83. HASKELL
data Writer s a = Writer (a, s)
instance Monoid s => Monad (Writer s) where
pure a = Writer (a, mempty)
Writer (a, s) >>= f = Writer (b, s <> s2)
where
Writer (b, s2) = f a

84. HASKELL
add1 :: Int -> Writer String Int
add1 x = Writer (x + 1, "+1")
mul3 :: Int -> Writer String Int
mul3 x = Writer (x * 3, "*3")
add1 30 >>= mul3 >>= add1 = (94, "+1*3+1")

85. HASKELL
add1 :: Int -> Writer String Int
add1 x = Writer (x + 1, "+1")
mul3 :: Int -> Writer String Int
mul3 x = Writer (x * 3, "*3")
do
x <- add1 30
y <- mul3 x
add1 y

86. HASKELL
tell :: Monoid s => s -> Writer s ()
tell s = Writer ((), s)
add1 x = do { tell "+1"; pure (x + 1) }
mul3 x = do { tell "*3"; pure (x * 3) }
do
x <- add1 30
y <- mul3 x
add1 y

87. State: estado
a -> (s -> (b, s))
≅
(a, s) -> (b, s)

88. HASKELL
data State s a = State (s -> (a, s))
instance Monad (State s) where …
put :: s -> State s ()
put s = _ -> ((), s)
get :: State s s
get = s -> (s, s)
modify :: (s -> s) -> State s ()
modify f = s -> ((), f s)

89. HASKELL
put :: s -> State s ()
get :: State s s
modify :: (s -> s) -> State s ()
…
add1 x = do
modify (log -> log <> "+1")
pure (x + 1)
mul3 x = do
modify (log -> log <> "*3")
pure (x * 3)

90. HASKELL
do
x <- add1 30
y <- mul3 x
add1 y
do
x <- add1 30
y <- mul3 x
log <- get
add1 y

91. Maybe: falha
a -> Maybe b

92. HASKELL
data Maybe a = Nothing | Just a
instance Monad Maybe where …
head :: [a] -> Maybe a
…
tryGetLastPhoto username = do
user <- tryGetUser username
photos <- tryGetPhotos user
head photos

93. List: não-determinismo
a -> [b]

94. Reader: ambiente global
a -> (r -> b)
≅
(a, r) -> b

95. Cont: continuações
a -> ((b -> r) -> r)
≅
(b -> r) -> (a -> r)

96. Dist: cálculo de probabilidades
a -> [(b, Float)]

97. IO: efeitos colaterais
a -> (RealWorld -> (b, RealWorld))
≅
(a, RealWorld) -> (b, RealWorld)

98. EDSLs

99. Parser: parsing…
a -> (String -> [(b, String)])
≅
(a, String) -> [(b, String)]

100. HASKELL
data Parser a = Parser (String -> [(a, String)])
instance Monad Parser where …
char :: Parser Char
char = Parser f
where
f [] = []
f (c:cs) = [(c, cs)]
zero :: Parser a
zero = Parser (_ -> [])

101. Combinadores.

102. HASKELL
satisfy :: (Char -> Bool) -> Parser Char
satisfy pred = do
c <- char
if pred c then pure c else zero
alt :: Parser a -> Parser a -> Parser a
alt (Parser p) (Parser q) = Parser $ s ->
case p s of
[] -> q s
res -> res
some :: Parser a -> Parser [a]
some parser = -- one or many

103. HASKELL
digit :: Parser Char
digit = satisfy isDigit
number :: Parser Int
number = do
cs <- some digit
pure (read cs)

104. HASKELL
add :: Parser Int
add = do
a <- number
satisfy (== '+')
b <- number
pure (a + b)
sub :: Parser Int
sub = do
a <- number
satisfy (== '-')
b <- number
pure (a - b)

105. HASKELL
expression :: Parser Int
expression = alt add sub
parse (Parser f) = f
parse expression "10+4" = 14
parse expression "10-4" = 6

106. Computações & Algoritmos

107. Sequencialidade;

108. Do ponto de vista interno,
permitem efeitos colaterais;

109. Sequência de operações são efetuadas
e têm seus resultados combinados no final;

110. Mônadas abstraem programas!

111. Mais?

112. Funtores aplicativos;
Free monad;
Monad transformers;
Comônadas;
Lentes;
Categorias;
Contêineres indexados;
Derivadas;

113. λ
@arthurxavierx @arthur-xavier