1. Functional
Programming Ideas
in C#

2. What’s wrong with imperative
code?

3. What’s wrong with imperative
code?

4. What’s wrong with imperative
code?

5. What’s wrong with imperative
code?
• It is repetitive
• It is lengthy
• (higher chances to introduce bugs)
• (harder to read)
• It describes what to do and how
• (mixing low-level and high-level concepts)

6. Let’s try to solve these problems

7. Delegate declaration

8. Invocation

9. Invocation (without noise)

10. Delegates are immutable
You can only change the
delegate variable

11. Delegate knows its target

12. Look, we manipulate code
as if
it was data!
Nothing new though
(we had interfaces for ages)

13. So we can
• Store it in variable
• Store it in a field or property
• Pass it as a method parameter
• Return it as a method result

14. Functions (delegates)
are first class citizens
Both pure and impure

15. Pure vs side-effects
• Pure functions:
– Maht.Sin(X)
– String.Length
– List<T>.IndexOf(T)
• Functions with side effects:
– List<T>.Add(T)
– DateTime.UtcNow
– Console.WriteLine()

16. Questions so far?

17. Consider the problem
• Initiate processing
• When some condition occurs, we want to
execute some code

18. Pass delegates

19. Call event

20. Event syntax

21. Nothing really complicated so far
Let’s go deeper

23. Separate method -- not needed

24. Lambda expressions
(lambda functions)

25. Return value from delegate

26. Let’s recall generics!

27. Questions so far?

28. How to make it more flexible?

29. This is called closure
(lexical closure)
The function captures variables from
the scope

30. Prefix

31. Pitfall

32. Function can even capture itself

33. Function factory

34. Generate IDs

35. We’ve looked at examples of
higher-order functions
They
take one or more functions as an input
or return a function

36. Be comfortable with creating and passing
lambdas
Understand closures
This is very powerful and widely used idiom

37. Let’s improve imperative code

38. Find element

39. Find element

40. Filter

41. Filter

42. Currying
Transform
f: (X * Y) -> Z Haskell Curry
into
f: X -> (Y -> Z)
Input: Function with N parameters
Output: chain of N functions with 1
parameter each

43. Currying

44. How to compute Fibonacci(N)
What’s
wrong with
this?
It is exponential
(slow)
link

45. Memoization

46. Memoization

47. Main ideas
• Functions as first class citizens
• Compose complex functions from simple
• Create specific functions out of generic ones
• More generic and reusable code with higher
order functions
• For less code and less bugs

48. Questions?