Este documento apresenta uma palestra sobre programação funcional em F#. Apresenta conceitos como composição, imutabilidade, funções de alta ordem, monads e como o LINQ pode ser entendido como uma aplicação desses conceitos funcionais. O palestrante é Rodrigo Vidal, especialista em F# e computação científica.

1. 2016 is coming....

2. Monadic Design
Functional Programming

3. Quem sou eu?
• Rodrigo Vidal
• MVP de F#
• Rio de Janeiro
• Computação Científica / Engenharia

4. Agenda
Composição

6. Linguagens

7. 12
C#, VB,
10
Java LINQ F# Nirvana
8
Usefulness 6 C#
Nirvana
Haskell
4
LINQ
2
Haskell
0
0 2 4 6 8 10 12
Safety

8. Programação Funcional
• Imutabilidade
• First-class Functions
• Lazy
• Pattern Matching
• Composição

9. Transparência Referencial
void Multiplicar(Matriz m1, Matriz m2)
{
....
}

10. Efeitos Colaterais
String Nome(Person p)
{
C.WriteLine(“Isto é um efeito colateral!”);
return p.Nome;
}

11. Aplicação Parcial
• Aplicação parcial envolve passar menos
argumentos para uma função que recebe
múltiplos argumentos
add :: Int -> Int -> Int
add x y = x + y
addOne = add 1

12. Currying
Currying é o processo de transformar uma função
que recebe multiplos argumentos para uma função
que recebe somente um argumento e retorna uma
outra função se algum paramêtro ainda for
necessário.
f :: a -> b -> c
É a forma ”curried” de
g :: (a, b) -> c

13. Funções de Alta Ordem
• Filter • First
• Map • Last
• Length • Zip
• All • Take
• Any • TakeWhile
• Max
• Min

14. Composição de Funções
f(g(x)) g(x)
g >> f
f.g f(x)

15. A Essência do LINQ

16. O tipo Option

17. Destilando o LINQ
• IEnumerator<T> == Func<Option<T>>
• () –> Option<T>
• IEnumerable<T> == Func<Func<Option<T>>>
• () –> (() –> Option<T>)

18. Empty<T>()

19. Return<T>()
static Func<Func<Option<T>>> Return<T> (T value)
{
return () => {
int i = 0;
return () =>
i++ == 0
? (Option<T>)new Option<T>.Some(value)
: (Option<T>)new Option<T>.None();
};
}

21. Select<T>

22. Where<T>

23. SelectMany<T>
IE<R> SelectMany<T, R>(this IE<T> source,
Func<T, IE<R>> f)
{
foreach (var item in source)
foreach (var result in f(item))
yield return result;
}

24. LINQ somente em IEnumerable?

25. Functors
class Functor f where
fmap :: (a -> b) -> f a -> f b
instance Functor Maybe where
fmap f (Just x) = Just (f x)
fmap f (Nothing ) = Nothing
fmap (*2) [1..3]
> [2,4,6]
fmap (*2) Just 5
> Just 10

26. Funções como Functors
fmap :: (a -> b) -> ((->) r a) -> ((->) r b)
fmap :: (a -> b) -> (r -> a) -> (r -> b)

27. Applicative Functors
class (Functor f) => Applicative f where
pure :: a -> f a
(<*>) :: f (a -> b) -> f a -> f b
let a = fmap (*) [1,2,3,4]
a :: [Integer -> Integer]

28. Maybe Applicative Functor
instance Applicative Maybe Where
pure = Just
Nothing <*> _ = Nothing
(Just f) <*> something = fmap f something
pure (+) <*> Just 3 <*> Just 5
> Just 8

29. Monoids
class Monoid m where
mempty :: m
mappend :: m -> m -> m
mconcat :: [m] -> m
mconcat = foldr mappend mempty

30. Monoids Pattern
• 1+1
• 2*2
• [1,2,3] ++ [4,5,6]

31. instance Monoid Any where
mempty = Any False
Any x `mappend` Any y = Any (x || y)
getAny $ Any True `mappend` Any False
> True
getAny $ Any True `mappend` mempty
> True

32. instance Monoid All where
mempty = All True
All x `mappend` All y = All (x && y)
getAll $ mempty `mappend` All True
> True
getAll $ mempty `mappend` All False
> True

33. Monads

34. Monads
class Monad m where
return :: a -> M a
bind :: M a -> ( a -> M b) -> M b

35. List Monad

36. Maybe Monad

37. IO Monad

38. Async Monad

39. LINQ – Dualidade - Rx

40. Reactive Extensions
• IObserver<T> == Action<Option<T>>
• Option<T> -> ()
• IObservable<T> == Action<Action<T>>
• (Option<T> -> ()) -> ()
• IEnumerator<T> == Func<Option<T>>
• () –> Option<T>
• IEnumerable<T> == Func<Func<Option<T>>>
• () –> (() –> Option<T>)

41. Notas Finais
• Aprenda Matemática
• Aprenda Algoritmos
• Aprenda uma Linguagem Funcional (F# :P)
• .NET Architects Rio de Janeiro
• DojoRio
• Hora Extra
• @rodrigovidal
• rodrigovidal777@gmail.com
• www.rodrigovidal.net