Scala: Welcome To The Wonderful World Of Functional Programming

Screencasts are here: https://vimeo.com/album/5111827

Transcript

1. Scala welcome to the world of functional programming
2. Why Functional Programming?
3. Why Functional Programming? • use side-effect-free functions as a basic building block in the language • order of execution is not important (useful for concurrency) • easy to translate mathematical functions into functional languages
4. Why Scala?
5. Why Scala? •Functional AND Object Oriented •Concise •Works with Java
6. Let’s get started!
7. The Easy Way: scastie.scala-lang.org
8. (do this at home later) https://docs.scala-lang.org/ getting-started.html The Hard Way:
9. Let’s go back to Scastie
10. Basic Expression (Almost) everything in Scala is an expression
11. Values and Variables
12. Values cannot be changed (immutable)
13. Variables can be changed (mutable)
14. Functions
15. Functions need a type signature for any parameters
16. However, functions do not need a return type
17. But if you miss the param type, you get an error
18. If a function has no arguments, you can leave off the parentheses
19. You can have multi-line functions using curly braces
20. QUESTION Create a function that allows you to take in two strings and append them together
21. More on functions later…
22. MOAR DATA TYPES!
23. Array • Preserve order • Can contain duplicates • Mutable
24. List • Preserve order • Can contain duplicates • Immutable
25. Set • Do not preserve order • Can’t contain duplicates • Immutable
26. Tuple • Logical collection of items • Accessors are position based and start at 1
27. Tuple SPECIAL SAUCE You can also make a tuple of two values like this:
28. Map • Holds basic datatypes • Key-value pairs • Can contain Maps or other functions as values • Immutable
29. Option Scala doesn’t like using null. Instead, we use None. If there’s a chance of a value being None, then use Option Basic interface:
30. Option (Example)
31. Option (Example) But we can make it even sleeker
32. QUESTION Take this function and, instead of nulls, use Option
33. Either Similar to Option, but it has two sub- types: Left and Right. It’s regularly used in error handling with Left being the error and Right being the success
34. Functional Combinators (stick with me, not as scary as they sound)
35. Map Evaluates a function over each element in the list, returning a list with the same number of elements. or pass a function!
36. Foreach Similar to map, but returns nothing. Intended for side-effects only.
37. Filter removes any elements where the function you pass in evaluates to false
38. Zip aggregates the contents of two lists into a single list of pairs
39. Find returns the first element of a collection that matches a predicate function
40. And more!
41. Classes
42. Basic Class
43. Classes can also have constructor arguments
44. And don’t forget about comments!
45. A class can inherit from another class
46. You can also overload methods
47. And add traits to classes
48. Let's talk about case classes!
49. ... what the heck is a case class?
50. • is just like a regular class (with a few key differences) • is good for modeling immutable data • requires the keywords case class, an identifier, and a parameter list (which may be empty) A case class:
51. Case Class Example When you create a case class with parameters, the parameters are public vals
52. Case Class Comparison Case classes are compared by structure and not by reference
53. Pattern Matching Checks a value against a pattern and a successful match can also deconstruct a value into its constituent parts
54. Pattern Matching... with Case Classes!
55. Now let's match case classes based on type only
56. QUESTION • Create case classes of animals (I used Dogs, Cats, and Snakes) and a function called 'speak'. • 'speak' should return the first two animals' speaking function. • For example, if you have Dog, there should be a function 'bark' that 'speak' returns. • For any other type, return "???"
57. More Fun With Functions
58. Anonymous Functions
59. Function Composition
60. Partial Function only defined for certain values of the defined type
61. Partially Applied Function Name sounds the same, but it's very different! This allows you to create one function out of another using _ as a wildcard
62. Currying functions to let people apply some arguments to your function now and others later
63. Variable Length Arguments special syntax for methods that can take parameters of a repeated type
64. Let’s switch over to some functional programming patterns…
65. Here’s an example of a for loop in javascript
66. Let's do it the same way in Scala...
67. Let’s do that same loop in a more functional way
69. Now let's add up a list of numbers in a more OO way
70. Not too bad! But we can make it better
71. Let's go functional!
72. So what's the benefit? More efficient!
73. Content inspired and sometimes taken from: Scala School: https://twitter.github.io/scala_school Tour of Scala: http://docs.scala-lang.org/tour
74. Also yay for scastie.scala-lang.org