HaskellBook

More documents

Recommendations

Info

10 CHAPTER 2. STARTING OUT Pretty cool, huh? Yeah, I know it’s not but bear with me. A little pitfall to watch out for here is negating numbers. If we want to have a negative number, it’s always best to surround it with parentheses. Doing 5 * -3 will make GHCI yell at you but doing 5 * (-3) will work just fine. Boolean algebra is also pretty straightforward. As you probably know, && means a boolean and, || means a boolean or. not negates a True or a False. ghci > True && False False ghci > True && True True ghci > False || True True ghci > not False True ghci > not ( True && True ) False Testing for equality is done like so. ghci > 5 == 5 True ghci > 1 == 0 False ghci > 5 /= 5 False ghci > 5 /= 4 True ghci > " hello " == " hello " True What about doing 5 + "llama" or 5 == True? Well, if we try the first snippet, we get a big scary error message! No instance for ( Num [ Char ]) arising from a use of ‘+’ at < interactive >:1:0 -9 Possible fix : add an instance declaration for ( Num [ Char ]) In the expression : 5 + " llama " In the definition of ‘it ’: it = 5 + " llama " Yikes! What GHCI is telling us here is that "llama" is not a number and so it doesn’t know how to add it to 5. Even if it wasn’t "llama" but "four" or "4", Haskell still wouldn’t consider it to be a number. + expects its left and right side to be numbers. If we tried to do True == 5, GHCI would tell us that the types don’t match. Whereas + works only on things that are considered numbers, == works on any two things that can be compared. But the catch is that they both have to be the same type of thing. You can’t compare apples and oranges. We’ll take a closer look at types a bit later. Note: you can do 5 + 4.0 because 5 is sneaky and can act like an integer or a floating-point number. 4.0 can’t act like an integer, so 5 is the one that has to adapt. You may not have known it but we’ve been using functions now all along. For instance, * is a function that takes two numbers and multiplies them. As you’ve seen, we call it by sandwiching it between them. This is what we call an infix function. Most functions that aren’t used with numbers are prefix functions. Let’s take a look at them.
2.1. READY, SET, GO! 11 Functions are usually prefix so from now on we won’t explicitly state that a function is of the prefix form, we’ll just assume it. In most imperative languages functions are called by writing the function name and then writing its parameters in parentheses, usually separated by commas. In Haskell, functions are called by writing the function name, a space and then the parameters, separated by spaces. For a start, we’ll try calling one of the most boring functions in Haskell. ghci > succ 8 9 The succ function takes anything that has a defined successor and returns that successor. As you can see, we just separate the function name from the parameter with a space. Calling a function with several parameters is also simple. The functions min and max take two things that can be put in an order (like numbers!) and return the one that’s greater. ghci > min 9 10 9 ghci > min 3.4 3.2 3.2 ghci > max 100 101 101 Function application (calling a function by putting a space after it and then typing out the parameters) has the highest precedence of them all. What that means for us is that these two statements are equivalent. ghci > succ 9 + max 5 4 + 1 16 ghci > ( succ 9) + ( max 5 4) + 1 16 However, if we wanted to get the successor of the product of numbers 9 and 10, we couldn’t write succ 9 * 10 because that would get the successor of 9, which would then be multiplied by 10. So 100. We’d have to write succ (9 * 10) to get 91. If a function takes two parameters, we can also call it as an infix function by surrounding it with backticks. For instance, the div function takes two integers and does integral division between them. Doing div 92 10 results in a 9. But when we call it like that, there may be some confusion as to which number is doing the division and which one is being divided. So we can call it as an infix function by doing 92 ‘div‘ 10 and suddenly it’s much clearer. Lots of people who come from imperative languages tend to stick to the notion that parentheses should denote function application. For example, in C, you use parentheses to call functions like foo(), bar(1) or baz(3, "haha"). Like we said, spaces are used for function application in Haskell. So those functions in Haskell would be foo, bar 1 and baz 3 "haha". So if you see something like bar (bar 3), it doesn’t mean that bar is called with bar and 3 as parameters. It means that we first call the function bar with 3 as the parameter to get some number and then we call bar again with that number. In C, that would be something like bar(bar(3)).
Page 1 and 2: Learn You a Haskell for Great Good!
Page 3 and 4: Contents 1 Introduction 5 1.1 About
Page 5 and 6: Chapter 1 Introduction 1.1 About th
Page 7 and 8: 1.3. WHAT YOU NEED TO DIVE IN 7 sys
Page 9: Chapter 2 Starting Out 2.1 Ready, s
Page 13 and 14: 2.3. AN INTRO TO LISTS 13 Now we’
Page 15 and 16: 2.3. AN INTRO TO LISTS 15 If you wa
Page 17 and 18: 2.4. TEXAS RANGES 17 maximum takes
Page 19 and 20: 2.5. I’M A LIST COMPREHENSION 19
Page 21 and 22: 2.6. TUPLES 21 2.6 Tuples In some w
Page 23 and 24: 2.6. TUPLES 23 add a condition that
Page 25 and 26: Chapter 3 Types and Typeclasses 3.1
Page 27 and 28: 3.2. TYPE VARIABLES 27 factorial ::
Page 29 and 30: 3.3. TYPECLASSES 101 29 ghci > 5 /=
Page 31 and 32: 3.3. TYPECLASSES 101 31 ghci > maxB
Page 33 and 34: Chapter 4 Syntax in Functions 4.1 P
Page 35 and 36: 4.1. PATTERN MATCHING 35 Well, that
Page 37 and 38: 4.2. GUARDS, GUARDS! 37 There’s a
Page 39 and 40: 4.3. WHERE!? 39 Ugh! Not very reada
Page 41 and 42: 4.4. LET IT BE 41 cylinder :: ( Rea
Page 43 and 44: 4.5. CASE EXPRESSIONS 43 case expre
Page 45 and 46: Chapter 5 Recursion 5.1 Hello recur
Page 47 and 48: 5.3. A FEW MORE RECURSIVE FUNCTIONS
Page 49 and 50: 5.4. QUICK, SORT! 49 elem ’ :: (E
Page 51 and 52: Chapter 6 Higher order functions Ha
Page 53 and 54: 6.2. SOME HIGHER-ORDERISM IS IN ORD
Page 55 and 56: 6.2. SOME HIGHER-ORDERISM IS IN ORD
Page 57 and 58: 6.3. MAPS AND FILTERS 57 " GAYBALLS
Page 59 and 60: 6.4. LAMBDAS 59 ghci > chain 30 [30
Page 61 and 62:
6.5. ONLY FOLDS AND HORSES 61 6.5 O
Page 63 and 64:
6.5. ONLY FOLDS AND HORSES 63 The s
Page 65 and 66:
6.7. FUNCTION COMPOSITION 65 ($) ::
Page 67 and 68:
6.7. FUNCTION COMPOSITION 67 fn x =
Page 69 and 70:
Chapter 7 Modules 7.1 Loading modul
Page 71 and 72:
7.2. DATA.LIST 71 To search for fun
Page 73 and 74:
7.2. DATA.LIST 73 splitAt takes a n
Page 75 and 76:
7.2. DATA.LIST 75 False ghci > " ca
Page 77 and 78:
7.2. DATA.LIST 77 lines is a useful
Page 79 and 80:
7.3. DATA.CHAR 79 From this, we cle
Page 81 and 82:
7.3. DATA.CHAR 81 All these predica
Page 83 and 84:
7.4. DATA.MAP 83 decode :: Int -> S
Page 85 and 86:
7.4. DATA.MAP 85 It says that it ta
Page 87 and 88:
7.5. DATA.SET 87 7.5 Data.Set The D
Page 89 and 90:
7.6. MAKING OUR OWN MODULES 89 and
Page 91 and 92:
7.6. MAKING OUR OWN MODULES 91 , ar
Page 93 and 94:
Chapter 8 Making Our Own Types and
Page 95 and 96:
8.1. ALGEBRAIC DATA TYPES INTRO 95
Page 97 and 98:
8.2. RECORD SYNTAX 97 O-kay. The fi
Page 99 and 100:
8.3. TYPE PARAMETERS 99 have an [In
Page 101 and 102:
8.4. DERIVED INSTANCES 101 had a ty
Page 103 and 104:
8.4. DERIVED INSTANCES 103 ghci > m
Page 105 and 106:
8.5. TYPE SYNONYMS 105 ghci > Wedne
Page 107 and 108:
8.5. TYPE SYNONYMS 107 Fonzie says:
Page 109 and 110:
8.6. RECURSIVE DATA STRUCTURES 109
Page 111 and 112:
8.6. RECURSIVE DATA STRUCTURES 111
Page 113 and 114:
8.7. TYPECLASSES 102 113 | x > a =
Page 115 and 116:
8.7. TYPECLASSES 102 115 We did it
Page 117 and 118:
8.8. A YES-NO TYPECLASS 117 instanc
Page 119 and 120:
8.9. THE FUNCTOR TYPECLASS 119 inst
Page 121 and 122:
8.9. THE FUNCTOR TYPECLASS 121 In a
Page 123 and 124:
8.10. KINDS AND SOME TYPE-FOO 123 8
Page 125 and 126:
8.10. KINDS AND SOME TYPE-FOO 125 a
Page 127 and 128:
Chapter 9 Input and Output We’ve
Page 129 and 130:
9.1. HELLO, WORLD! 129 So, when wil
Page 131 and 132:
9.1. HELLO, WORLD! 131 name. Rememb
Page 133 and 134:
9.1. HELLO, WORLD! 133 skipped this
Page 135 and 136:
9.1. HELLO, WORLD! 135 $ runhaskell
Page 137 and 138:
9.1. HELLO, WORLD! 137 introduced.
Page 139 and 140:
9.2. FILES AND STREAMS 139 I’m a
Page 141 and 142:
9.2. FILES AND STREAMS 141 i’m sh
Page 143 and 144:
9.2. FILES AND STREAMS 143 what we
Page 145 and 146:
9.2. FILES AND STREAMS 145 contents
Page 147 and 148:
9.2. FILES AND STREAMS 147 main = d
Page 149 and 150:
9.2. FILES AND STREAMS 149 thing li
Page 151 and 152:
9.3. COMMAND LINE ARGUMENTS 151 sec
Page 153 and 154:
9.3. COMMAND LINE ARGUMENTS 153 han
Page 155 and 156:
9.4. RANDOMNESS 155 ber, Haskell is
Page 157 and 158:
9.4. RANDOMNESS 157 with the same g
Page 159 and 160:
9.4. RANDOMNESS 159 characters and
Page 161 and 162:
9.5. BYTESTRINGS 161 9.5 Bytestring
Page 163 and 164:
9.5. BYTESTRINGS 163 chunk even if
Page 165 and 166:
Chapter 10 Functionally Solving Pro
Page 167 and 168:
10.1. REVERSE POLISH NOTATION CALCU
Page 169 and 170:
10.2. HEATHROW TO LONDON 169 natura
Page 171 and 172:
10.2. HEATHROW TO LONDON 171 Now we
Page 173 and 174:
10.2. HEATHROW TO LONDON 173 use Se
Page 175 and 176:
10.2. HEATHROW TO LONDON 175 the ne
show all

HaskellBook

Create successful ePaper yourself

Delete template?

Save as template?