Function therory
Download as PPTX, PDF1 like377 views
This document discusses functional programming concepts in F#, including function theory, type inference, function composition, monads, and combinators. It provides examples of defining and inferring types for various functions in F#, and explains concepts like partial function application, function composition using the >> operator, and common combinators like S, K, and I. It also briefly introduces monads and compares them to constructs like the list and nullable types in other languages.
Function therory
- 3. //Brackets aren't mandatory:let f(x,y) = x+ylet f x y = x+y
- 4. //Function type:let I x = x// x: 'a// I: 'a -> 'a
- 5. //Example 2:let K x y = x// x: 'a// y: 'b// K: 'a -> 'b -> 'a
- 6. //Partial applicationlet constHi = K "Hello"let hi = constHi 123val constHi : (int -> string)//hi : string ="Hello"
- 7. //Example 3:let S x y z = x(z)(y(z))// x: f(a b)// x: a -> b -> c// z: a// y: a -> bS x y z: (a -> b -> c) -> (a -> b) -> a -> c
- 8. //Exercise: What are these functions?val it : (('a -> 'b) -> 'a list -> 'b list)val it : (('a -> 'b -> 'a) -> 'a -> 'b list -> 'a)val it : ('a * 'b -> 'a)
- 10. //function compositionlet combine f g x = g(f(x)) Let combine f g x = (f>>g)x// f: 'a -> 'b// g: 'b -> 'c// x: 'acombine f g x: (a -> b) -> (b -> c) -> a -> c
- 11. //You can remove the parameter from the last one!let combine f g= (f>>g)// combine: ('a -> 'b) -> ('b -> 'c) -> ('a -> 'c)
- 12. result: generic abstraction whitout re- ference to concrete typeslet handle = (save >> validate >> send)
- 13. F#monads
- 14. thought behind LINQ“list monad”IEnumerable<T>“maybe monad”Nullable<T>…
- 15. three types of operations1.3.'a -> M<’a>M<'a> -> 'b2.M<'a> -> M<'b>
- 16. typical example2.M<'a> -> ('a -> M<'b>) -> M<'b>3.M<'a> -> 'b -> ('b -> 'a -> 'b) -> 'b
- 17. F#combinators
- 18. S- K- I- combinatorsLike we started:I x = xK x y = xS x y z = x z (y z)
- 19. y-combinatorf(x) when x=f?f(f) = f and f=f(f)f(g) = g(f(g))Y = S (K (S I I)) (S (S (K S) K) (K (S I I)))
Editor's Notes
- #9: When functions don’t have side effects we can actually define what they do (and correctness) purely by looking the types.
- #10: “function composition”: To combine two functions into a new one.“For X, first apply g, then f.”, Or “f of g of x”
- #13: No stiffness of object-oriented programming Possibility to make top-down design
- #14: Often we want to combine things that are not so directly linked to each other… Monad term is from Haskell where it is actually the only way to make side effects
- #15: Actually Nullable<T> is just a list with zero or one items.
- #16: Add things to thedomainModify: Handle the domainGet items from the domain
- #17: 2: (a -> M<b>) is a transformation function (formap/select/…)3: (b -> a -> b) function is a collector/selector function and b is kind of an accumulator to collect the output result.
- #19: By chaining these we can create anything (without named parameters) I is unnecessary as I 5 = S (K) (K) (5) One ”Church-man" e.g. proved that we can make numbers and boolean logic just with functions. There is even a programming language based only combining these functions.
- #20: What if f(x) function would get input itself, I mean the f? Will become an recursion and infinite loop… The loop and the ending-condition-function can be separated to different functions Y can of course be made just with SKI-calculus