Cookbook/Lists and strings

From HaskellWiki

(Difference between revisions)

Revision as of 13:44, 23 April 2009

1 Lists
2 Strings

1 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.

1.1 Infinite lists

Prelude> [1..]

The list of all squares:

square x = x*x
squares = map square [1..]

But in the end, you probably don't want to use infinite lists, but make them finite. You can do this with

take

Prelude> take 10 squares
[1,4,9,16,25,36,49,64,81,100]

1.2 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 ]

1.3 Combining lists

Problem	Solution	Examples
combining two strings	(++)	"foo" ++ "bar" --> "foobar"
combining many strings	concat	concat ["foo", "bar", "baz"] --> "foobarbaz"

1.4 Accessing sublists

Problem	Solution	Examples
accessing the first character	head	head "foo bar baz" --> 'f'
accessing the last character	last	last "foo bar baz" --> 'z'
accessing the character at a given index	(!!)	"foo bar baz" !! 4 --> 'b'
accessing the first `n` characters	take	take 3 "foo bar baz" --> "foo"
accessing the last `n` characters	reverse , take	reverse . take 3 . reverse $ "foobar" --> "bar"
accessing the `n` characters starting from index `m`	drop, take	take 4 $ drop 2 "foo bar baz" --> "o ba"

1.5 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 string into two parts	splitAt	splitAt 3 "foo bar baz" --> ("foo"," bar baz")

2 Strings

Since strings are lists of characters, you can use any available list function.

2.1 Multiline strings

"foo\
\bar"               --> "foobar"

2.2 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'

2.3 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"

2.4 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"

2.5 Interpolation

TODO

2.6 Performance

For high performance requirements (where you would typically consider C), consider using Data.ByteString.

2.7 Unicode