A talk I did at DDD8, January 20th 2010.

1. Mixing functional and object oriented approaches to programming in C# Mark Needham

2. A bit of context

3. ThoughtWorks delivery projects

4. Web applications with somewhat complicated domains

5. 5-15 developers on a team

6. Projects running for 6-12 months

7. All this means that we want to write code which is…

8. Easy to understand

9. Easy to change

10. Which leads us to what this talk is all about…

12. How might functional programming help us with that?

13. First class functions

15. Immutability

16. Lazy evaluation

17. Recursion

18. Pattern matching

19. This is all very cool but…

20. Object Oriented design still has its place

21. Encapsulation

22. Abstraction

23. So how do these two paradigms work together?

25. In the large… “a high level that affects as well as crosscuts multiple classes and functions”

26. In the medium… “a single API or group of related APIs in such things as classes, interfaces, modules”

27. In the small… “individual function/method bodies”

28. Large Medium Small

29. Large Medium Small

30. LINQ

32. “powerful abstractions over collections”

33. “ the use of high-order functions is extremely useful for separating the collection's concerns from the user of the collection”

34. for loop becomes less useful

35. Don’t just use ForEach!

36. Code becomes more declarative

38. Requires a mental shift from imperative thinking

40. Current Input ??? ??? ??? Desired Output

41. Going from one collection to another

42. var words = new List<string> { “hello”, “world” }; var upperCaseWords = new List<string>(); foreach (var word in words) { upperCaseWords.Add(word.ToUpper()); }

43. a.k.a. map

44. “ hello”, “world” ???? “HELLO”, “WORLD”

45. “hello”, “world” Select “HELLO”, “WORLD”

46. var words = new List<string> { “hello”, “world” }; var upperCaseWords = words.Select(w => w.ToUpper());

47. Remove values we don’t want

48. var words = new List<string> {“hello”, “world”}; var wordsWithH = new List<string>(); foreach (var word in words) { if(word.Contains(“h”) wordsWithH.Add(word); }

49. a.k.a. filter

50. “ hello”, “world” ???? “hello”

51. “ hello”, “world” Where “hello”

52. var words = new List<string> {“hello”, “world”} ; var wordsWithH = words.Where(w => w.Contains(“h”));

53. Summing some values

54. var values = new List<int> { 1,2,3 }; var total = 0; foreach (var value in values) { total += value; }

55. a.k.a. reduce

56. 1, 2, 3 ??? 6

57. 1, 2, 3 Sum 6

58. var values = new List<int> { 1,2,3 }; var total = val ues.Sum(v => v);

59. Some examples from projects

60. Getting the first value that matches a criteria

61. Foo(“mark”, true), Foo(“dave”, false), Foo(“mike”, true) ???? Foo(“mark”, true)

62. Foo(“mark”, true), Foo(“dave”, false), Foo(“mike”, true) Where Foo(“mark”, true), Foo(“mike”, true) ??? Foo(“mark”, true)

63. Foo(“mark”, true), Foo(“dave”, false), Foo(“mike”, true) Where Foo(“mark”, true), Foo(“mike”, true) First Foo(“mark”, true)

64. var foos = new List<Foo> { new Foo(“mark”, true), new Foo(“dave”, false), new Foo(“mike”, true) }; var firstSpecialFoo = foos. Where(f => f.HasSpecialFlag()). First());

65. var foos = new List<Foo> { new Foo(“mark”, true), new Foo(“dave”, false), new Foo(“mike”, true) }; var firstSpecialFoo = foos.First(f => f.HasSpecialFlag());

66. Removing some columns from a dataset

67. a,b,c,d,e,f ???? “a,d,e,f”

68. a,b,c,d,e,f Where IEnumerable of a, d, e, f ??? “a,d,e,f”

69. a,b,c,d,e,f Where IEnumerable of a, d, e, f ??? String.Join on [a, d, e, f] “a,d,e,f”

70. a,b,c,d,e,f Where IEnumerable of a, d, e, f ToArray() String.Join on [a, d, e, f] “a,d,e,f”

71. var aRow = “a, b, c, d, e, f”; var newRow = String.Join(“,”, aRow .Split(‘,’) .Where((_, idx) => !(idx == 1 || idx == 2)) .ToArray());

72. var aRow = “a, b, c, d, e, f”; var rowWithColumnsRemoved = aRow .Split(‘,’) .Where((_, idx) => !(idx == 1 || idx == 2)) .ToArray()); var newRow = String.Join(“,”, rowWithColumnsRemoved);

73. Checking if any parameters are null

74. public class SomeObject { public SomeObject(string p1, string p2, string p3) { if (p1 == null ) throw new Exception(...); if (p2 == null ) throw new Exception(...); if (p3 == null ) throw new Exception(...); // rest of constructor logic } }

75. public class SomeObject { public SomeObject(string p1, string p2, string p3) { var params = new List<string> {p1, p2, p3}; if (params.Any(p => p == null) throw new Exception(...); // rest of constructor logic } }

76. Some lessons from the wild

77. Dealing with the null collection

81. LINQ and the forgotten abstraction

82. Avoid passing lists around

84. Later on in the view…

86. Objects as the mechanism for encapsulation

88. LINQ is duplication too!

91. Don’t forget “extract method”

94. Naming lambda variables

95. Putting functions in maps

96. public void SomeMethodParsing( string input) { if (input == “input1”) { someMethod(input); } else if (input == “input2”) { someOtherMethod(input); } // and so on }

97. Dictionary< string , Action< string >> inputs = new Dictionary< string , Action< string >> { { “input1” , someMethod }, { “input2” , someOtherMethod } }; public void SomeMethodParsing( string input) { var method = inputs[input]; method(input); }

98. Large Medium Small

99. Using functions to simplify some GOF patterns

100. Action

101. Func

105. Need to ensure we don’t lose readability/understandability

107. Common beginning and end. Only the middle differs

110. Other ideas I’m intrigued about

111. The option type

112. The nested closure

113. File.open(“someFile.txt”, ‘w’) do |out| out << “add something to file” end

114. public class MyFile { public static void Open(string filePath, Action<StreamWriter> block) { using(var writer = new StreamWriter()) { block(writer ); } } }

115. MyFile.Open(“c:mark.txt”, f => f.WriteLine(“some random text”));

116. Writing extension methods to create functional abstractions

117. Learning more

119. 3 things to take away

120. The transformational mindset

121. Objects are still the mechanism for encapsulation

122. Simplify GOF design patterns by using functions