Functional Programming Concepts for Data Processing

Transcription

1 Functional Programming Concepts for Data Processing Chris Lindholm UCAR SEA / 70

2 About Me I work at CU LASP I work primarily with Scala I teach Haskell at work Goal: leverage FP to improve scientific software 2 / 70

3 The Plan Convince you Functional Programming is worth learning about Introduce Functional Programming Refactor some code to be more Functional 3 / 70

4 Why Functional Programming? 4 / 70

5 Why Functional Programming? FP helps us write good software 5 / 70

6 Side E ects 6 / 70

7 Side E ects Side effects are difficult to reason about 7 / 70

8 Side E ects Side effects are difficult to reason about Side effects are difficult to test 8 / 70

9 Side E ects Side effects are difficult to reason about Side effects are difficult to test Side effects are difficult to scale 9 / 70

10 Side E ects Side effects are difficult to reason about Side effects are difficult to test Side effects are difficult to scale Side effects are unnecessary 10 / 70

11 Why Functional Programming? FP helps us write good software FP is naturally suited for expressing data-oriented workflows 11 / 70

12 Data Processing is Function-y Functions are math's way of processing data. 12 / 70

13 Data Processing is Function-y Functions are math's way of processing data. We can build pipelines with function composition and application. 13 / 70

14 Data Processing is Function-y Functions are math's way of processing data. We can build pipelines with function composition and application. a :: A d :: D -- D -- \ f :: A -> B g :: B -> C E / h :: C -> D -> E -- A -> B -> C 14 / 70

15 Data Processing is Function-y Functions are math's way of processing data. We can build pipelines with function composition and application. a :: A d :: D -- D -- \ f :: A -> B g :: B -> C E / h :: C -> D -> E -- A -> B -> C (g. f) :: A -> C -- (.) :: (b -> c) -> (a -> b) -> (a -> c) (h. g. f) :: A -> D -> E (h. g. f) a d :: E 15 / 70

16 Why Functional Programming? FP helps us write good software FP is naturally suited for expressing data-oriented workflows Learning FP makes you a better programmer 16 / 70

17 Introduction to Functional Programming 17 / 70

18 Imperative Programming Express computations using statements that perform side effects. 18 / 70

19 Imperative Programming Express computations using statements that perform side effects. // Declare a variable to mutate later. int var; // Change control flow depending on p. if (p) { var = 0; // If p is true, execute a statement that mutates var. } else { var = 1; // If p is false, execute a statement that mutates var. } 19 / 70

20 Imperative Programming Express computations using statements that perform side effects. // Declare a variable to mutate later. int var; // Change control flow depending on p. if (p) { var = 0; // If p is true, execute a statement that mutates var. } else { var = 1; // If p is false, execute a statement that mutates var. } Functional Programming Express computations using expressions that evaluate to values. 20 / 70

21 Imperative Programming Express computations using statements that perform side effects. // Declare a variable to mutate later. int var; // Change control flow depending on p. if (p) { var = 0; // If p is true, execute a statement that mutates var. } else { var = 1; // If p is false, execute a statement that mutates var. } Functional Programming Express computations using expressions that evaluate to values. -- Declare var to be 0 if p is true, 1 otherwise. var = if p then 0 else 1 21 / 70

22 Lambda Calculus The theory of computation underlying functional programming. 22 / 70

23 Lambda Calculus The theory of computation underlying functional programming. Lambda calculus has only Variables Functions Expressions but can express anything that is computable. 23 / 70

24 (λpq. pqp) (λxy. x) (λab. b) AND TRUE FALSE T RUE F ALSE = F ALSE (λpq. pqp)(λxy. x)(λab. b) β λab. b 24 / 70

25 (λpq. pqp)(λxy. x)(λab. b) β (λ[p := (λxy. x)]q. pqp)(λab. b) β (λq. (λxy. x)q(λxy. x))(λab. b) β λ[q := (λab. b)]. (λxy. x)q(λxy. x) β (λxy. x)(λab. b)(λxy. x) β (λ[x := (λab. b)]y. x)(λxy. x) β (λy. (λab. b))(λxy. x) β (λ[y := (λxy. x)]. (λab. b)) β λab. b 25 / 70

26 Pure Functions Pure functions take inputs, produce outputs using only those inputs, and do nothing else. 26 / 70

27 Pure Functions Pure functions take inputs, produce outputs using only those inputs, and do nothing else. def pure(x): return x / 70

28 Pure Functions Pure functions take inputs, produce outputs using only those inputs, and do nothing else. def pure(x): return x + 1 def maybe_pure(x): return f(x) / 70

29 First-class Functions First-class functions are values rather than syntactic constructs. 29 / 70

30 First-class Functions First-class functions are values rather than syntactic constructs. f = lambda x: x / 70

31 First-class Functions First-class functions are values rather than syntactic constructs. f = lambda x: x + 1 (+) :: Int -> Int -> Int addone :: Int -> Int addone = (+) 1 31 / 70

32 Higher-order Functions Higher-order functions operate on other functions. 32 / 70

33 Higher-order Functions Higher-order functions operate on other functions. (.) :: (b -> c) -> (a -> b) -> (a -> c) 33 / 70

34 Referential Transparency A referentially transparent expression is one that can be replaced with the result of its evaluation and not change the meaning of the program. 34 / 70

35 Referential Transparency A referentially transparent expression is one that can be replaced with the result of its evaluation and not change the meaning of the program. Expressions that are not referentially transparent have side effects. 35 / 70

36 Are these the same? def program1(): # expr is the expression we're testing expr = 1 return (expr, expr) def program2(): return (1, 1) 36 / 70

37 Are these the same? def program1(): # expr is the expression we're testing expr = 1 return (expr, expr) def program2(): return (1, 1) >>> program1() (1,1) >>> program2() (1,1) 37 / 70

38 Are these the same? def program1(): expr = datetime.now() return (expr, expr) def program2(): return (datetime.now(), datetime.now()) 38 / 70

39 Are these the same? def program1(): expr = datetime.now() return (expr, expr) def program2(): return (datetime.now(), datetime.now()) >>> program1() (datetime.datetime(2018, 4, 1, 17, 16, 17, ), datetime.datetime(2018, 4, 1, 17, 16, 17, )) >>> program2() (datetime.datetime(2018, 4, 1, 17, 16, 19, ), datetime.datetime(2018, 4, 1, 17, 16, 19, )) 39 / 70

40 Are these the same? def my_length(x): res = 0 for i in range(0, len(x)): res += 1 return res def program1(): expr = my_length([1,2,3]) return (expr, expr) def program2(): return (my_length([1,2,3]), my_length([1,2,3])) 40 / 70

41 Are these the same? def my_length(x): res = 0 for i in range(0, len(x)): res += 1 return res def program1(): expr = my_length([1,2,3]) return (expr, expr) def program2(): return (my_length([1,2,3]), my_length([1,2,3])) >>> program1() (3, 3) >>> program2() (3, 3) 41 / 70

42 Equational Reasoning Reasoning about code through substitution rather than execution. 42 / 70

43 Equational Reasoning Reasoning about code through substitution rather than execution. -- Apply a function to every element of a list. map :: (a -> b) -> [a] -> [b] map _ [] = [] map f x:xs = f x : map f xs 43 / 70

44 Equational Reasoning Reasoning about code through substitution rather than execution. -- Apply a function to every element of a list. map :: (a -> b) -> [a] -> [b] map _ [] = [] map f x:xs = f x : map f xs map (+ 1) [1, 2, 3] 44 / 70

45 Equational Reasoning Reasoning about code through substitution rather than execution. -- Apply a function to every element of a list. map :: (a -> b) -> [a] -> [b] map _ [] = [] map f x:xs = f x : map f xs map (+ 1) [1, 2, 3] map (+ 1) [1, 2, 3] = (1 + 1) : map (+ 1) [2, 3] = (1 + 1) : (2 + 1) : map (+ 1) [3] = (1 + 1) : (2 + 1) : (3 + 1) : map (+ 1) [] = (1 + 1) : (2 + 1) : (3 + 1) : [] = 2 : 3 : 4 : [] = [2, 3, 4] 45 / 70

46 Recap 46 / 70

47 Recap Functional programs are expressions. 47 / 70

48 Recap Functional programs are expressions. We run them by evaluating the expressions. 48 / 70

49 Recap Functional programs are expressions. We run them by evaluating the expressions. We try to keep functions and expressions free from side effects. 49 / 70

50 Recap Functional programs are expressions. We run them by evaluating the expressions. We try to keep functions and expressions free from side effects. We manipulate functions like any other values. 50 / 70

51 Recap Functional programs are expressions. We run them by evaluating the expressions. We try to keep functions and expressions free from side effects. We manipulate functions like any other values. These things enable us to apply mathematical reasoning to our programs. 51 / 70

52 Recap Functional programs are expressions. We run them by evaluating the expressions. We try to keep functions and expressions free from side effects. We manipulate functions like any other values. These things enable us to apply mathematical reasoning to our programs. There's a lot more to functional programming. 52 / 70

53 Refactoring to be More Functional 53 / 70

54 Refactoring to be More Functional def process(): # Read input data. data = read_data("input") # Run our processing algorithm. data = [f(x) for x in data] data = [g(x) for x in data] # Write our output. write_data(data, "output") 54 / 70

55 Refactoring to be More Functional def process(): # Read input data. data = read_data("input") # Run our processing algorithm. data = [f(x) for x in data] data = [g(x) for x in data] # Write our output. write_data(data, "output") Testing this is hard. 55 / 70

56 Refactoring to be More Functional def process(input_file, output_file): # Read input data. data = read_data(input_file) # Run our processing algorithm. data = [f(x) for x in data] data = [g(x) for x in data] # Write our output. write_data(data, output_file) Make testing easier by taking arguments. 56 / 70

57 Refactoring to be More Functional def process(input_file, output_file): # Read input data. data = read_data(input_file) # Run our processing algorithm. data = [g(x) for x in data] data = [f(x) for x in data] # Write our output. write_data(data, output_file) 57 / 70

58 Refactoring to be More Functional def process(input_file, output_file): # Read input data. data = read_data(input_file) # Run our processing algorithm. output_f = [f(x) for x in data] output_g = [g(x) for x in output_f] # Write our output. write_data(output_g, output_file) Keep data immutable. 58 / 70

59 Refactoring to be More Functional def process(input_file, output_file): # Read input data. data = read_data(input_file) # Run our processing algorithm. output_f = process_f(data) output_g = process_g(output_f) # Write our output. write_data(output_g, output_file) def process_f(data): return [f(x) for x in data] def process_g(data): return [g(x) for x in data] Separate pure algorithms from side-effecting infrastructure. 59 / 70

60 def process(): # Read input data. data = read_data("input") # Run our processing algorithm. data = [f(x) for x in data] data = [g(x) for x in data] # Write our output. write_data(data, "output") def process(input_file, output_file): # Read input data. data = read_data(input_file) # Run our processing algorithm. output_f = process_f(data) output_g = process_g(output_f) # Write our output. write_data(output_g, output_file) def process_f(data): return [f(x) for x in data] def process_g(data): return [g(x) for x in data] 60 / 70

61 def process(): # Read input data. data = read_data("input") # Run our processing algorithm. data = [f(x) for x in data] data = [g(x) for x in data] # Write our output. write_data(data, "output") def process(input_file, output_file): # Read input data. data = read_data(input_file) # Run our processing algorithm. output_f = process_f(data) output_g = process_g(output_f) # Write our output. write_data(output_g, output_file) def process_f(data): return [f(x) for x in data] def process_g(data): return [g(x) for x in data] 61 / 70

62 def process(): # Read input data. data = read_data("input") # Run our processing algorithm. data = [f(x) for x in data] data = [g(x) for x in data] # Write our output. write_data(data, "output") def process(input_file, output_file): # Read input data. data = read_data(input_file) # Run our processing algorithm. output_f = process_f(data) output_g = process_g(output_f) # Write our output. write_data(output_g, output_file) def process_f(data): return [f(x) for x in data] def process_g(data): return [g(x) for x in data] 62 / 70

63 Refactoring to be More Functional def process(input_file, output_file): # Read input data. data = read_data(input_file) # Run our processing algorithm. output_f = map(f, data) output_g = map(g, output_f) # Write our output. write_data(output_g, output_file) #def process_f(data): # return [f(x) for x in data] #def process_g(data): # return [g(x) for x in data] Build larger programs from smaller ones. 63 / 70

64 Refactoring to be More Functional def process(input_file, output_file): # Read input data. data = read_data(input_file) # Run our processing algorithm. output = map(compose(g, f), data) # Write our output. write_data(output, output_file) def compose(g, f): return lambda x: g(f(x)) Steal from math. -- Functor composition law map g. map f = map (g. f) 64 / 70

65 Refactoring Example in Haskell main :: IO () main = let inputfile = "input" outputfile = "output" in pipeline inputfile outputfile pipeline :: FilePath -> FilePath -> IO () pipeline inputfile outputfile = readdata inputfile <&> map (g. f) >>= writedata outputfile -- (<&>) :: Functor f => f a -> (a -> b) -> f b -- (>>=) :: Monad m => m a -> (a -> m b) -> m b 65 / 70

66 Guidelines for Writing Functional Code 66 / 70

67 Guidelines for Writing Functional Code Write functions that take inputs and return outputs 67 / 70

68 Guidelines for Writing Functional Code Write functions that take inputs and return outputs Keep data immutable 68 / 70

69 Guidelines for Writing Functional Code Write functions that take inputs and return outputs Keep data immutable Reach for side effects last 69 / 70

70 Guidelines for Writing Functional Code Write functions that take inputs and return outputs Keep data immutable Reach for side effects last Limit side effects to the outer layers of your program 70 / 70