Cookbook/Lists and strings
< Cookbook
Jump to navigation
Jump to search
Lists
In Haskell, lists are what Arrays are in most other languages. Haskell has all of the general list manipulation functions, see also Data.List
.
head [1,2,3] --> 1
tail [1,2,3] --> [2,3]
length [1,2,3] --> 3
init [1,2,3] --> [1,2]
last [1,2,3] --> 3
Furthermore, Haskell supports some neat concepts.
Creating lists
Problem | Solution | Examples |
---|---|---|
creating a list piecewise | - | 3 : 12 : 42 : [] --> [3,12,42]
|
creating a list | - | [1..10] --> [1,2,3,4,5,6,7,8,9,10]
|
creating an infinite constant list | - | [1..] --> [1,1,1,1,1,...
|
creating an infinite list | - | [1,2..] --> [1,2,3,4,5,...
|
List comprehensions
The list of all squares can also be written in a more comprehensive way, using list comprehensions:
squares = [x*x | x <- [1..]]
List comprehensions allow for constraints as well:
-- multiples of 3 or 5
mults = [ x | x <- [1..], mod x 3 == 0 || mod x 5 == 0 ]
Combining lists
Problem | Solution | Examples |
---|---|---|
combining two lists | (++) | "foo" ++ "bar" --> "foobar"
[42,43] ++ [60,61] --> [42,43,60,61]
|
combining many lists | concat | concat ["foo", "bar", "baz"] --> "foobarbaz"
|
Accessing sublists
Problem | Solution | Examples |
---|---|---|
accessing the first element | head | head "foo bar baz" --> 'f'
|
accessing the last element | last | last "foo bar baz" --> 'z'
|
accessing the element at a given index | (!!) | "foo bar baz" !! 4 --> 'b'
|
accessing the first n elements
|
take | take 3 "foo bar baz" --> "foo"
|
accessing the last n elements
|
reverse , take | reverse . take 3 . reverse $ "foobar" --> "bar"
|
accessing the n elements starting from index m
|
drop, take | take 4 $ drop 2 "foo bar baz" --> "o ba"
|
Splitting lists
Problem | Solution | Examples |
---|---|---|
splitting a string into a list of words | words | words "foo bar\t baz\n" --> ["foo","bar","baz"]
|
splitting a list into two parts | splitAt | splitAt 3 "foo bar baz" --> ("foo"," bar baz")
|
Strings
Since strings are lists of characters, you can use any available list function.
Multiline strings
"foo\
\bar" --> "foobar"
Converting between characters and values
Problem | Solution | Examples |
---|---|---|
converting a character to a numeric value | ord | import Char
ord 'A' --> 65
|
converting a numeric value to a character | chr | import Char
chr 99 --> 'c'
|
Reversing a string by words or characters
Problem | Solution | Examples |
---|---|---|
reversing a string by characters | reverse | reverse "foo bar baz" --> "zab rab oof"
|
reversing a string by words | words, reverse, unwords | unwords $ reverse $ words "foo bar baz" --> "baz bar foo"
|
reversing a string by characters by words | words, reverse, map, unwords | unwords $ map reverse $ words "foo bar baz" --> "oof rab zab"
|
Converting case
Problem | Solution | Examples |
---|---|---|
converting a character to upper-case | toUpper | import Char
toUpper 'a' --> "A"
|
converting a character to lower-case | toLower | import Char
toLower 'A' --> "a"
|
converting a string to upper-case | toUpper, map | import Char
map toUpper "Foo Bar" --> "FOO BAR"
|
converting a string to lower-case | toLower, map | import Char
map toLower "Foo Bar" --> "foo bar"
|
Interpolation
TODO
Performance
For high performance requirements (where you would typically consider C), consider using Data.ByteString.
Unicode
TODO