Personal tools

Cookbook/Lists and strings

From HaskellWiki

< Cookbook(Difference between revisions)
Jump to: navigation, search
(→Splitting strings)
Current revision (02:10, 1 February 2010) (edit) (undo)
m (Fixed a couple of the list shorthands)
 
(23 intermediate revisions not shown.)
Line 1: Line 1:
-
Since strings are lists of characters, you can use any available list function.
+
== Lists ==
 +
 
 +
In Haskell, lists are what Arrays are in most other languages.
 +
 
 +
=== Creating simple lists ===
 +
 
 +
{| class="wikitable"
 +
|-
 +
! Problem
 +
! Solution
 +
! Examples
 +
|-
 +
| creating a list with given elements
 +
| -
 +
|<haskell>
 +
3 : 12 : 42 : [] --> [3,12,42]
 +
'f' : 'o' : 'o' : [] --> "foo"
 +
</haskell>
 +
|-
 +
| creating a list with stepsize 1
 +
| -
 +
|<haskell>
 +
[1..10] --> [1,2,3,4,5,6,7,8,9,10]
 +
['a'..'z'] --> "abcdefghijklmnopqrstuvwxyz"
 +
</haskell>
 +
|-
 +
| creating a list with different stepsize
 +
| -
 +
|<haskell>
 +
[1,3..10] --> [1,3,5,7,9]
 +
['a','c'..'z'] --> "acegikmoqsuwy"
 +
</haskell>
 +
|-
 +
| creating an infinite constant list
 +
| -
 +
|<haskell>
 +
[1,1..] --> [1,1,1,1,1,...
 +
</haskell>
 +
|-
 +
| creating an infinite list with stepsize 1
 +
| -
 +
| <haskell>
 +
[1..] --> [1,2,3,4,5,...
 +
</haskell>
 +
|}
 +
 
 +
=== List comprehensions ===
 +
 
 +
The list of all squares can also be written in a more comprehensive way, using list comprehensions:
 +
 
 +
<haskell>
 +
squares = [x*x | x <- [1..]]
 +
</haskell>
 +
 
 +
List comprehensions allow for constraints as well:
 +
 
 +
<haskell>
 +
-- multiples of 3 or 5
 +
mults = [ x | x <- [1..], mod x 3 == 0 || mod x 5 == 0 ]
 +
</haskell>
 +
 
-
= Combining strings =
+
=== Combining lists ===
{| class="wikitable"
{| class="wikitable"
Line 9: Line 69:
! Examples
! Examples
|-
|-
-
| combining two strings
+
| combining two lists
| [http://haskell.org/ghc/docs/latest/html/libraries/base/Prelude.html#v%3A%2B%2B (++)]
| [http://haskell.org/ghc/docs/latest/html/libraries/base/Prelude.html#v%3A%2B%2B (++)]
|<haskell>
|<haskell>
"foo" ++ "bar" --> "foobar"
"foo" ++ "bar" --> "foobar"
 +
[42,43] ++ [60,61] --> [42,43,60,61]
</haskell>
</haskell>
|-
|-
-
| combining many strings
+
| combining many lists
| [http://haskell.org/ghc/docs/latest/html/libraries/base/Prelude.html#v:concat concat]
| [http://haskell.org/ghc/docs/latest/html/libraries/base/Prelude.html#v:concat concat]
| <haskell>
| <haskell>
Line 22: Line 83:
|}
|}
-
= Accessing substrings =
+
=== Accessing sublists ===
{| class="wikitable"
{| class="wikitable"
Line 30: Line 91:
! Examples
! Examples
|-
|-
-
| accessing the first character
+
| accessing the first element
| [http://haskell.org/ghc/docs/latest/html/libraries/base/Prelude.html#v:head head]
| [http://haskell.org/ghc/docs/latest/html/libraries/base/Prelude.html#v:head head]
|<haskell>
|<haskell>
Line 36: Line 97:
</haskell>
</haskell>
|-
|-
-
| accessing the last character
+
| accessing the last element
| [http://haskell.org/ghc/docs/latest/html/libraries/base/Prelude.html#v%3Alast last]
| [http://haskell.org/ghc/docs/latest/html/libraries/base/Prelude.html#v%3Alast last]
|<haskell>
|<haskell>
Line 42: Line 103:
</haskell>
</haskell>
|-
|-
-
| accessing the character at a given index
+
| accessing the element at a given index
| [http://haskell.org/ghc/docs/latest/html/libraries/base/Prelude.html#v%3A!! (!!)]
| [http://haskell.org/ghc/docs/latest/html/libraries/base/Prelude.html#v%3A!! (!!)]
|<haskell>
|<haskell>
Line 48: Line 109:
</haskell>
</haskell>
|-
|-
-
| accessing the first <code>n</code> characters
+
| accessing the first <code>n</code> elements
| [http://haskell.org/ghc/docs/latest/html/libraries/base/Prelude.html#v:take take]
| [http://haskell.org/ghc/docs/latest/html/libraries/base/Prelude.html#v:take take]
| <haskell>
| <haskell>
Line 54: Line 115:
</haskell>
</haskell>
|-
|-
-
| accessing the last <code>n</code> characters
+
| accessing the last <code>n</code> elements
| [http://haskell.org/ghc/docs/latest/html/libraries/base/Prelude.html#v:reverse reverse ], [http://haskell.org/ghc/docs/latest/html/libraries/base/Prelude.html#v:take take]
| [http://haskell.org/ghc/docs/latest/html/libraries/base/Prelude.html#v:reverse reverse ], [http://haskell.org/ghc/docs/latest/html/libraries/base/Prelude.html#v:take take]
| <haskell>
| <haskell>
Line 60: Line 121:
</haskell>
</haskell>
|-
|-
-
| accessing the <code>n</code> characters starting from index <code>m</code>
+
| accessing the <code>n</code> elements starting from index <code>m</code>
| [http://haskell.org/ghc/docs/latest/html/libraries/base/Prelude.html#v:drop drop], [http://haskell.org/ghc/docs/latest/html/libraries/base/Prelude.html#v:take take]
| [http://haskell.org/ghc/docs/latest/html/libraries/base/Prelude.html#v:drop drop], [http://haskell.org/ghc/docs/latest/html/libraries/base/Prelude.html#v:take take]
| <haskell>
| <haskell>
Line 67: Line 128:
|}
|}
-
= Splitting strings =
+
=== Splitting lists ===
Line 81: Line 142:
</haskell>
</haskell>
|-
|-
-
| splitting a string into two parts
+
| splitting a list into two parts
| [http://haskell.org/ghc/docs/latest/html/libraries/base/Prelude.html#v%3AsplitAt splitAt]
| [http://haskell.org/ghc/docs/latest/html/libraries/base/Prelude.html#v%3AsplitAt splitAt]
| <haskell>splitAt 3 "foo bar baz" --> ("foo"," bar baz")
| <haskell>splitAt 3 "foo bar baz" --> ("foo"," bar baz")
Line 87: Line 148:
|}
|}
-
= Multiline strings =
+
== Strings ==
 +
 
 +
Since strings are lists of characters, you can use any available list function.
 +
 
 +
=== Multiline strings ===
<haskell>
<haskell>
"foo\
"foo\
Line 93: Line 158:
</haskell>
</haskell>
-
= Converting between characters and values =
+
=== Converting between characters and values ===
{| class="wikitable"
{| class="wikitable"
Line 116: Line 181:
|}
|}
-
= Reversing a string by words or characters =
+
=== Reversing a string by words or characters ===
{| class="wikitable"
{| class="wikitable"
Line 143: Line 208:
|}
|}
-
= Converting case =
+
=== Converting case ===
{| class="wikitable"
{| class="wikitable"
Line 180: Line 245:
|}
|}
-
=Interpolation =
+
=== Interpolation ===
TODO
TODO
-
= Performance =
+
=== Performance ===
For high performance requirements (where you would typically consider
For high performance requirements (where you would typically consider
C), consider using [http://hackage.haskell.org/packages/archive/bytestring/latest/doc/html/Data-ByteString.html Data.ByteString].
C), consider using [http://hackage.haskell.org/packages/archive/bytestring/latest/doc/html/Data-ByteString.html Data.ByteString].
-
= Unicode =
+
=== Unicode ===
TODO
TODO

Current revision

Contents

1 Lists

In Haskell, lists are what Arrays are in most other languages.

1.1 Creating simple lists

Problem Solution Examples
creating a list with given elements - 
3 : 12 : 42 : []        --> [3,12,42]
'f' : 'o' : 'o' : []    --> "foo"
creating a list with stepsize 1 - 
[1..10]                 --> [1,2,3,4,5,6,7,8,9,10]
['a'..'z']              --> "abcdefghijklmnopqrstuvwxyz"
creating a list with different stepsize - 
[1,3..10]               --> [1,3,5,7,9]
['a','c'..'z']          --> "acegikmoqsuwy"
creating an infinite constant list - 
[1,1..]                   --> [1,1,1,1,1,...
creating an infinite list with stepsize 1 - 
[1..]                 --> [1,2,3,4,5,...

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 lists (++) 
"foo" ++ "bar"                  --> "foobar"
[42,43] ++ [60,61]              --> [42,43,60,61]
combining many lists concat 
concat ["foo", "bar", "baz"]    --> "foobarbaz"

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

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 list 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

TODO

Retrieved from "http://www.haskell.org/haskellwiki/Cookbook/Lists_and_strings"