Background Functions (1C) Young Won Lim 5/26/18

Transcription

1 Background Functions (1C)

2 Copright (c) Young W. Lim. Permission is granted to cop, distribute and/or modif this document under the terms of the GNU Free Documentation License, Version 1.2 or an later version published b the Free Softare Foundation; ith no Invariant Sections, no Front-Cover Tets, and no Back-Cover Tets. A cop of the license is included in the section entitled "GNU Free Documentation License". Please send corrections (or suggestions) to ounglim@hotmail.com. This document as produced b using LibreOffice.

3 Based on Haskell in 5 steps Functions 3

4 Function Definition Function Definition I. square = * - function tpe is inferred not efficient Tpe Inference Function Definition II. square :: Double -> Double square = * function tpe declaration function definition function tpe declaration function definition Functions 4

5 Tpe Declaration Tpe Declaration the declaration of an identifier's tpe identifier name :: tpe name... identifier names (including function identifiers) must alas begin ith a loer-case letter tpe names in Haskell alas begin ith a capital letter Functions 5

6 Function Tpes and Tpe Classes Function Definition I. square = * function definition = Function Definition II. square :: Double -> Double square = * function definition function tpe declaration = tpe class a set of tpes function tpe 1 function tpe 2 function tpe n Requirements Subclasses Functions 6

7 Curr & Uncurr f :: a -> b -> c the curried form ofg :: (a, b) -> c f = curr g g = uncurr f f = g (,) the curried form is usuall more convenient because it allos partial application. the curried form f :: a -> b -> c curring uncurring g :: (a, b) -> c all functions are considered curried f g (, ) all functions take just one argument Functions 7

8 Functions : First-class Data Tpes functions are first-class data tpes Haskell treats functions as regular data, just like integers, or floating-point values, or other tpes. a function can take other functions as parameters a function takes a parameter and produces another function (curried function) f f :: a -> b -> c a f (b->c) f :: a -> b -> c (f ) f :: a -> (b -> c) f returns a function of tpe b -> c b g c g g :: b -> c Functions 8

9 Curring Eamples f f f Functions 9

10 Polmorphic Functions specific tpes vs. arbitrar tpes a polmorphic functions an abstract tpe each tpe variable is generall a loer-case letter. Eample) A translate function takes a function f and a distance d returns a ne function g that is f "translated" d units to the right Functions 10

11 Polmorphic Function Eamples translate :: (Double -> Double) -> Double -> (Double -> Double) Double f Double translate f d = g here g = f ( d) Double d translate translate :: (Double -> a) -> Double -> (Double -> a) Double g Double Double d f Double Functions 11

12 Curring Curring recursivel transforms a function that takes multiple arguments into a function that takes just a single argument and returns another function if an arguments are still needed. f :: a -> b -> c f :: a -> b -> c f f :: a -> b -> c a f (b->c) (f ) f :: a -> (b -> c) g g :: b -> c b g c Functions 12

13 Partiall Applied Functions f, (f ) f f :: a -> b -> c -> d -> e f = (f ) f g1 :: b -> c -> d -> e g1 = Functions 13

14 Partiall Applied Functions (f ), (f ) (f ) f g2 :: c -> d -> e g2 = (f ) f g3 :: d -> e g3 = Functions 14

15 Partiall Applied Functions g1, g2, g3 (f ) = g1 f g1 (f ) = g2 f g2 (f ) = g3 f g3 Functions 15

16 Returning Functions f returns g1 function f f f g1 g1 returns g2 function g1 g1 g1 g2 g2 returns g3 function g2 g2 g2 g3 Functions 16

17 Curring Eamples f :: a -> b -> c -> d -> e f :: a -> (b -> (c -> (d -> e))) a (b -> (c -> (d -> e))) ((((f ) ) ) ) f b g1 (c -> (d -> e)) c (d -> e) g2 d g3 e Functions 17

18 Curring Eamples f :: a -> b -> c -> d -> e f :: a -> (b -> (c -> (d -> e))) a (b -> (c -> (d -> e))) ((((f ) ) ) ) f b g1 (c -> (d -> e)) c g1 (d -> e) g2 d g3 e Functions 18

19 Curring Eamples f :: a -> b -> c -> d -> e f :: a -> (b -> (c -> (d -> e))) a (b -> (c -> (d -> e))) ((((f ) ) ) ) f b g1 (c -> (d -> e)) c (d -> e) g2 d g2 g3 e Functions 19

20 Curring Eamples f :: a -> b -> c -> d -> e f :: a -> (b -> (c -> (d -> e))) a (b -> (c -> (d -> e))) ((((f ) ) ) ) f b g1 (c -> (d -> e)) c (d -> e) g2 d g3 e Functions 20

21 Curring Eamples mult :: Int -> Int -> Int -> Int (((mult ) ) ) f :: a -> (b -> (c -> d)) (((f ) ) ) Int Int Int f Int Functions 21

22 Partial Applications mult :: Int -> Int -> Int -> Int f :: Int -> (Int -> (Int -> Int)) mult mult a 1 = g1 mult a 1 a 2 = g2 f :: Int -> (Int -> (Int -> Int)) f f :: Int -> (Int -> Int) g1 :: Int -> (Int -> Int) g1 f :: Int -> Int g2 :: Int -> Int g2 mult a 1 a 2 a 3 constants Functions 22

23 Returning Functions mult :: Int -> Int -> Int -> Int mult Int f (Int -> (Int -> Int)) mult a 1 Int g1 (Int -> Int) mult a 1 a 2 Int g2 Int mult a 1 a 2 a 3 Functions 23

24 Curring Eamples mult :: Int -> Int -> Int -> Int f mult f mult a 1 f mult a 1 a 2 mult a 1 a 2 a 3 Functions 24

25 Anonmous Function \ -> + 1 (\ -> + 1) 4 5 :: Integer (\ -> + ) :: Integer addone = \ -> + 1 Lambda Epression Functions 25

26 let in clinder :: (RealFloat a) => a -> a -> a clinder r h = let sidearea = 2 * pi * r * h toparea = pi * r ^2 in sidearea + 2 * toparea The form is let <bindings> in <epression>. The names that ou define in the let part are accessible to the epression after the in part. Notice that the names are also aligned in a single column. For no it just seems that let puts the bindings first and the epression that uses them later hereas here is the other a around. Functions 26

27 $ Function Application ($) :: (a -> b) -> a -> b f $ = f (a -> b) : left function a : right value b : result Function application ith a space f - high precedence - left-associative f a b c = ((f a) b) c) Function application ith $ f $ - the loest precedence - right associative f $ a $ b $ c = f (a (b c)) Functions 27

28 $ a single argument $ a convenience function that eliminates man parentheses. When a $ is encountered, the epression on its right is applied as the parameter to the function on its left. func $ value a single argument $ a single argument riting an opening parentheses ( and then riting a closing one ) on the far right side of the epression. ( a single argument ) far right side Functions 28

29 $ Function Application Eamples sum (map sqrt [1..130]) due to a lo precedence sum $ map sqrt [1..130] sqrt ((sqrt 3) + (4 + 9)) sqrt ( ) sqrt $ Functions 29

30 $ Right Associative Eamples because $ is right-associative f (g ( )) f $ g $ sum (filter (> 10) (map (*2) [2..10])) sum $ filter (> 10) $ map (*2) [2..10] Functions 30

31 $ Map Function Application Eamples But apart from getting rid of parentheses, $ means that function application can be treated just like another function. map function application over a list of functions. map ($ 3) [(4+), (10*), (^2), sqrt] [(4+ $ 3), (10* $ 3), (^2 $ 3), sqrt $ 3] [7.0, 30.0, 9.0, ] Functions 31

32 const function const _ = Prelude> const Prelude> const useful for passing to higher-order functions hen ou don't need all their fleibilit. For eample, the monadic sequence operator >> can be defined in terms of the monadic bind operator as >> = >>= const (>>) = (. const). (>>=) Functions 32

33 read function Prelude> let = read "True" Prelude> :t :: Read a => a doesn't have a concrete tpe. is sort of an epression that can provide a value of a concrete tpe, hen e ask for it. Input: read "12"::Int Output: 12 Input: read "12"::Double Output: 12.0 Input: read "1.22"::Double Output: 1.22 ask to be an Int or a Bool or anthing Prelude> :: Bool True Functions 33

34 replicate, take, repeat, ccle, iterate replicate Int -> a -> [a] creates a list of length given b the first argument and the items having value of the second argument take Int -> [a] -> [a] creates a list, the first argument determines, ho man items should be taken from the list passed as the second argument repeat a -> [a] it creates an infinite list here all items are the first argument ccle [a] -> [a] it creates a circular list from a finite one Iterate (a -> a) -> a -> [a] creates an infinite list here the first item is calculated b appling the function on the second argument, the second item b appling the function on the previous result and so on. Functions 34

35 replicate, take, repeat, ccle, iterate eamples Input: replicate 3 5 Output: [5,5,5] Input: replicate 4 "aa" Output: ["aa","aa","aa","aa"] Input: replicate 5 'a' Output: "aaaaa" Input: take 5 [1,2,3,4,5,6,7] Output: [1,2,3,4,5] Input: take 5 [1,2] Output: [1,2] Input: take 0 [1,2,3,4,5,6,7] Output: [] Input: take 5 (repeat 3) Output: [3,3,3,3,3] Input: take 7 (iterate (2*) 1) Output: [1,2,4,8,16,32,64] Input: take 10 (ccle [1,2,3]) Output: [1,2,3,1,2,3,1,2,3,1] Input: take 4 (repeat 3) Output: [3,3,3,3] Input: take 6 (repeat 'A') Output: "AAAAAA" Input: take 5 (repeat "A") Output: ["A","A","A","A","A"] Input: take 10 (ccle [1,2,3]) Output: [1,2,3,1,2,3,1,2,3,1] Input: take 10 (ccle "ABC") Output: "ABCABCABCA" Functions 35

36 flip flip flip f = f :: (a -> b -> c) -> b -> a -> c flip f takes its (first) to arguments in the reverse order of f. Haskell Overvie 36

37 flip flip :: (a -> b -> c) -> b -> a -> c flip f = f flip :: (a -> b -> c) -> b -> a -> c flip f = g here g = f flip :: (a -> b -> c) -> b -> a -> c flip f = g here g a b = f b a flip :: (a -> b -> c) -> b -> a -> c flip f = g here g a b = f b a flip :: (a -> b -> c) -> b -> a -> c flip f = g here g = f flip f = g flip f = g flip f = g Haskell Overvie 37

38 flip flip flip f = f :: (a -> b -> c) -> b -> a -> c flip f takes its (first) to arguments in the reverse order of f. Applicatives Sequencing (3C) 38

39 flip flip :: (a -> b -> c) -> b -> a -> c flip f = f flip :: (a -> b -> c) -> b -> a -> c flip f = g here g = f flip :: (a -> b -> c) -> b -> a -> c flip f = g here g a b = f b a flip :: (a -> b -> c) -> b -> a -> c flip f = g here g a b = f b a flip :: (a -> b -> c) -> b -> a -> c flip f = g here g = f flip f = g flip f = g flip f = g Applicatives Sequencing (3C) 39

40 References [1] ftp://ftp.geoinfo.tuien.ac.at/navratil/haskelltutorial.pdf [2]