Don't Fear the Monads

Love functional programming for the simplicity that it brings.

But at the same time, I realize that learning functional programming is a challenging process. FP comes with a baggage of unfamiliar vocabulary that can be daunting for somebody coming from an object-oriented language like C#.

Numerous attempts were made to explain monads in simple definitions; and monad tutorials have become a genre of its own. And yet, times and times again, they fail to enlighten the readers, this is my attempt to fix that.

Transcript

1. DON’T FEAR THE MONAD
2. ffrancogiraldez@gmail.com @thanerian @ffrancogiraldez
5. Functional programing is a style of building the structure and elements of programs that threads computation as evaluation of mathematical functions and avoid changing-state and mutable data What is Functional Programming 5 • Higher Order Fuctions • Referencial Transparency • Lazy evaluation • Inmutable data • Abstractions
6. Show me the code 6 namespace Core.Monad { public class Speaker { Talk NextTalk() => /* ... */ } public class Talk { Conference GetConference() => /* ... */ } public class Conference { City GetCity() => /* ... */ } public class City { } }
7. Show me the code - Imperative form 7 static City NextTalkCity(Speaker speaker) { Talk talk = speaker.NextTalk(); Conference conf = talk.GetConference(); City city = conf.GetCity(); return city; }
8. Show me the code - fluent form 8 static City NextTalkCity(Speaker speaker) { return speaker .NextTalk() .GetConference() .GetCity(); }
10. Null Handling 10 namespace Core.Monad { public struct Speaker { public Nullable<Talk> NextTalk() => /* ... */ } public struct Talk { public Nullable<Conference> GetConference() => /* ... */ } public struct Conference { public Nullable<City> GetCity() => /* ... */ } public struct City { }
11. Null Handling – Ugly as hell 11 static Nullable<City> NextTalkCity(Speaker speaker) { Nullable<Talk> talk = speaker.NextTalk(); if (!talk.HasValue) return null; Nullable<Conference> conf = talk.Value.GetConference(); if (!conf.HasValue) return null; Nullable<City> city = conf.Value.GetCity(); return city; }
12. Null Handling – Null Propagation Operator 12 static Nullable<City> NextTalkCity(Speaker speaker) { return speaker .NextTalk() ?.GetConference() ?.GetCity(); }
13. Collections 13 namespace Core.Monad { public class Speaker { public List<Talk> NextTalk() => /* ... */ } public class Talk { public List<Conference> GetConference() => /* ... */ } public class Conference { public List<City> GetCity() => /* ... */ } public class City { } }
14. Collections - foreach version 14 static List<City> NextTalkCity(Speaker speaker) { var cities = new List<City>(); foreach (Talk talk in speaker.NextTalk()) foreach (Conference conference in talk.GetConference()) foreach (City city in conference.GetCity()) cities.Add(city); return cities; }
15. Collections - LINQ version 15 static List<City> NextTalkCity(Speaker speaker) { return speaker .NextTalk() .SelectMany(talk => talk.GetConference()) .SelectMany(conference => conference.GetCity()) .ToList(); }
16. Collections - LINQ version 16 static List<City> NextTalkCity(Speaker speaker) { return speaker .NextTalk() .SelectMany(talk => talk .GetConference() ).SelectMany(conference => conference .GetCity() ).ToList(); }
17. Asynchrony 17 namespace Core.Monad { public struct Speaker { public Task<Talk> NextTalk() => /* ... */ } public struct Talk { public Task<Conference> GetConference() => /* ... */ } public struct Conference { public Task<City> GetCity() => /* ... */ } public struct City { } }
18. Asynchrony - ContinueWith 18 static Task<City> NextTalkCity(Speaker speaker) { return speaker .NextTalk() .ContinueWith(task => task.Result.GetConference()) .Unwrap() .ContinueWith(conference => conference.Result.GetCity()) .Unwrap(); }
19. Asynchrony - ContinueWith 19 static Task<City> NextTalkCity(Speaker speaker) { return speaker .NextTalk() .ContinueWith(task => task.Result .GetConference() ).Unwrap().ContinueWith(x => x.Result .GetCity() ).Unwrap(); }
20. Null Handling – Null Propagation Operator 20 static Nullable<City> NextTalkCity(Speaker speaker) { return speaker .NextTalk() ? .GetConference() ? .GetCity(); }
21. Collections - LINQ version 21 static List<City> NextTalkCity(Speaker speaker) { return speaker .NextTalk() .SelectMany(talk => talk .GetConference() ).SelectMany(x => x .GetCity() ).ToList(); }
22. Chainnable 22 class Chainnable<T> { Chainnable<U> AddStep<U>(Func<T, Chainnable<U>> step); }
23. Chainnable 23
24. Chainnable 24 static Chainable<City> NextTalkCity(Speaker speaker) { return speaker .NextTalk() .AddStep(talk => talk.GetConference()) .AddStep(conference => conference.GetCity()); }
25. Chainnable 25
27. Monads! 27 static Monad<City> NextTalkCity(SpeakerRepository repository) { return repository.loadSpeaker() .FlatMap(speaker => speaker.NextTalk()) .FlatMap(talk => talk.GetConference()) .FlatMap(conference => conference.GetCity()); }
28. Abstractions - Imperative Programing 28 • simple data values • Sentences one after the other • Functions as remove duplication public void HandleData(String data) { data = ""; }
29. Abstractions - Object Oriented Programming 29 • Object • Abstraction and Encapsulation • Generics public class List<T> : ICollection<T>, IEnumerable<T>, IList<T
30. Abstractions – Typed Functional Progamming 30 • Higher Kinded Types • Typeclasses • Polymorphic programs
31. • monads explained in C# -> https://tinyurl.com/y77wmpvv • F# for fun and profit -> https://tinyurl.com/hha9ozu • Functional error handling -> https://tinyurl.com/yaynoq8v • Category Theory for programers -> https://tinyurl.com/y8zehgas References 31
32. Thanks Questions?