1.
struktury
algebraiczne
w js

2.
marek
● JS Developer @ BH for 4+ years
● FP, JS, react, elixir, haskell
● intercaetera.com

3.
po co?

4.
jest z tym problem

5.
← to jest trudne

6.
problem → → rozwiązanie

7.
problem → → rozwiązanie

8.
struktury algebraiczne
- rozwiązują ogólne problemy*
- odkryte racjonalnie**
- bardzo rygorystyczne***

9.
intuicja
- do budowania systemów
- do naprawiania istniejących aplikacji
- do refaktoryzacji
- do rozwiązywania bugów

10.
← potrzebna tu

11.
co to?

12.
- zbiór
- operacja na nim
- zasady które spełnia
- typ
- funkcja na nim
- zasady które spełnia
</>

13.
(

14.
notacja typów
- Int, String — typy
- n :: Type — n należy do typu Type
- Constr a — konstruktor/generyk (jak T<a>)
- a -> b — funkcja
- a -> b -> c — funkcje są curry’owane
f = (a, b) => a+b ~= g = a => b => a + b
f(2, 3) => 5 ~= g(2)(3) => 5
currying

15.
ściąga na przyszłość
https://github.com/fantasyland/fantasy-land
https://github.com/fantasyland/static-land

16.
)

17.
funktory <$>

18.
Int -> Bool
() -> Int
Identity Int
Dict String Int
List Int
Maybe Int

19.
Int -> Bool
() -> Int
Identity Int
Dict String Int
List Int
Maybe Int

20.
a -> Bool
() -> a
Identity a
Dict String a
List a
Maybe a

21.
monady funktory są
jak burrito 🌯

22.
zróbmy nasz własny

23.
Effect a
() -> a

24.
1 :: Number
() => 1 :: Effect Number
() => 2 :: Effect Number
() => ‘alpha’ :: Effect String
() => [1, 2, 3] :: Effect List Number

25.
funktor = typ + fmap

26.
fmap f :: (a -> b) -> f a -> f b

27.
Array.prototype.map

28.
fmap Array :: (a -> b) -> Array a -> Array b
[1, 2, 3].map(x => x*2) => [2, 4, 6]

29.
fmap Effect :: (a -> b) -> Effect a -> Effect b

30.
różne funktory
- kowariantne
- kontrawariantne
- bifunktory i profunktory
- transformacje naturalne
- aplikatywy
- funktory monoidalne
- …monady?

31.
monoid <>

32.
monoidy nie są funktorami

33.
monoid = typ + concat + empty

34.
typ: Int
concat: +
empty: 0

35.
typ: Int
concat: *
empty: 1

36.
monoidy mogą być funktorami

37.
typ: Array
concat: Array.prototype.concat
empty: []

38.
monoidy mogą być funkcjami

39.
typ: a -> a
concat: _.flow
empty: x => x
← czyli po prostu składanie
funkcji

40.
ale przede wszystkim
monoidy są redukowalne

41.
array.reduce(reducer, initial)

42.
[type].reduce(concat, empty)

43.
jak zredukować Effect?

44.
concat f :: f -> f -> f
zwykle

45.
concat Effect :: Effect -> Effect -> Effect

46.
można tak, ale to niezbyt
praktyczne

47.
w programowaniu funkcyjnym
chodzi o składanie funkcji

48.
jak mamy takie same typy
to nie ma problemu
(a → a) ° (a → a) ⇒ (a → a)
(Int → Int) ° (Int → Int) ⇒ (Int → Int)

49.
ale jak nie, to funkcje muszą się
zgadzać w typach
(a → b) ° (b → c) ⇒ (a → c)
(Int → String) ° (String → Bool) ⇒ (Int → Bool)

50.
ale co jeśli chcielibyśmy złożyć
2 × a -> Effect a

51.
compose :: (a -> b) -> (b -> c) -> (a -> c)

52.
concat (a -> Effect c) ::
(a -> Effect b) -> (b -> Effect c) -> (a -> Effect c)

53.
ale co my teraz zrobiliśmy?

54.
monoid w
endofunktorze

55.
“All told, a monad is just a
monoid in the category of
endofunctors.”

56.
monada =<<

57.
monada = funktor + chain

58.
chain f :: (a -> f b) -> f a -> f b

59.
Array.prototype.flatMap

60.
chain Effect :: (a -> Effect b) -> Effect a -> Effect b

61.
funkcje = kompozycja

62.
monady = ✨kompozycja✨

63.
“Once you understand monads, you
lose the ability to explain them to
others.”

64.
mam nadzieję że poszło mi w
miarę ok