View source for Cookbook/Lists and strings

== 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 lists ===

{| class="wikitable"
|-
!  Problem
!  Solution
!  Examples
|-
|  combining two lists
|  [http://haskell.org/ghc/docs/latest/html/libraries/base-4.12.0.0/Prelude.html#v%3A%2B%2B (++)]
|<haskell>
"foo" ++ "bar"                  --> "foobar"
[42,43] ++ [60,61]              --> [42,43,60,61]
</haskell>
|-
|  combining many lists
|  [http://haskell.org/ghc/docs/latest/html/libraries/base-4.12.0.0/Prelude.html#v:concat concat]
| <haskell>
concat ["foo", "bar", "baz"]    --> "foobarbaz"
</haskell>
|}

=== Accessing sublists ===

{| class="wikitable"
|-
!  Problem
!  Solution
!  Examples
|-
|  accessing the first element
|  [http://haskell.org/ghc/docs/latest/html/libraries/base-4.12.0.0/Prelude.html#v:head head]
|<haskell>
head "foo bar baz"      --> 'f'
</haskell>
|-
|  accessing the last element
|  [http://haskell.org/ghc/docs/latest/html/libraries/base-4.12.0.0/Prelude.html#v%3Alast last]
|<haskell>
last "foo bar baz"      --> 'z'
</haskell>
|-
|  accessing the element at a given index
|  [http://haskell.org/ghc/docs/latest/html/libraries/base-4.12.0.0/Prelude.html#v%3A!! (!!)]
|<haskell>
"foo bar baz" !! 4      --> 'b'
</haskell>
|-
|  accessing the first <code>n</code> elements
|  [http://haskell.org/ghc/docs/latest/html/libraries/base-4.12.0.0/Prelude.html#v:take take]
| <haskell>
take 3 "foo bar baz"    --> "foo"
</haskell>
|-
|  accessing the last <code>n</code> elements
|  [http://haskell.org/ghc/docs/latest/html/libraries/base-4.12.0.0/Prelude.html#v:reverse reverse ], [http://haskell.org/ghc/docs/latest/html/libraries/base-4.12.0.0/Prelude.html#v:take take]
| <haskell>
reverse . take 3 . reverse $ "foobar"    --> "bar"
</haskell>
|-
|  accessing the <code>n</code> elements starting from index <code>m</code>
|  [http://haskell.org/ghc/docs/latest/html/libraries/base-4.12.0.0/Prelude.html#v:drop drop], [http://haskell.org/ghc/docs/latest/html/libraries/base-4.12.0.0/Prelude.html#v:take take]
| <haskell>
take 4 $ drop 2 "foo bar baz"            --> "o ba"
</haskell>
|}

=== Splitting lists ===


{| class="wikitable"
|-
!  Problem
!  Solution
!  Examples
|-
|  splitting a string into a list of words
|  [http://haskell.org/ghc/docs/latest/html/libraries/base-4.12.0.0/Prelude.html#v:words words]
| <haskell>words "foo bar\t baz\n"    --> ["foo","bar","baz"]
</haskell>
|-
|  splitting a list into two parts
|  [http://haskell.org/ghc/docs/latest/html/libraries/base-4.12.0.0/Prelude.html#v%3AsplitAt splitAt]
| <haskell>splitAt 3 "foo bar baz"    --> ("foo"," bar baz")
</haskell>
|}

== Strings ==

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

=== Multiline strings ===
<haskell>
"foo\
\bar"               --> "foobar"
</haskell>

=== Converting between characters and values ===

{| class="wikitable"
|-
!  Problem
!  Solution
!  Examples
|-
|  converting a character to a numeric value
|  [http://haskell.org/ghc/docs/latest/html/libraries/base-4.12.0.0/Data-Char.html#v:ord ord]
|<haskell>
import Data.Char
ord 'A'    --> 65
</haskell>
|-
|  converting a numeric value to a character
|  [http://haskell.org/ghc/docs/latest/html/libraries/base-4.12.0.0/Data-Char.html#v%3Achr chr]
| <haskell>
import Data.Char
chr 99     --> 'c'
</haskell>
|}

=== Reversing a string by words or characters ===

{| class="wikitable"
|-
!  Problem
!  Solution
!  Examples
|-
|  reversing a string by characters
|  [http://haskell.org/ghc/docs/latest/html/libraries/base-4.12.0.0/Prelude.html#v:reverse reverse]
|<haskell>
reverse "foo bar baz"                        --> "zab rab oof"
</haskell>
|-
|  reversing a string by words
|  [http://haskell.org/ghc/docs/latest/html/libraries/base-4.12.0.0/Prelude.html#v%3Awords words], [http://haskell.org/ghc/docs/latest/html/libraries/base-4.12.0.0/Prelude.html#v:reverse reverse], [http://haskell.org/ghc/docs/latest/html/libraries/base-4.12.0.0/Prelude.html#v%3Aunwords unwords]
| <haskell>
unwords $ reverse $ words "foo bar baz"      --> "baz bar foo"
</haskell>
|-
|  reversing a string by characters by words
|  [http://haskell.org/ghc/docs/latest/html/libraries/base-4.12.0.0/Prelude.html#v%3Awords words], [http://haskell.org/ghc/docs/latest/html/libraries/base-4.12.0.0/Prelude.html#v:reverse reverse], [http://haskell.org/ghc/docs/latest/html/libraries/base-4.12.0.0/Prelude.html#v:map map], [http://haskell.org/ghc/docs/latest/html/libraries/base-4.12.0.0/Prelude.html#v%3Aunwords unwords]
| <haskell>
unwords $ map reverse $ words "foo bar baz"  --> "oof rab zab"
</haskell>
|}

=== Converting case ===

{| class="wikitable"
|-
!  Problem
!  Solution
!  Examples
|-
|  converting a character to upper-case
|  [http://haskell.org/ghc/docs/latest/html/libraries/base-4.12.0.0/Data-Char.html#v%3AtoUpper toUpper]
|<haskell>
import Data.Char
toUpper 'a'            --> 'A'
</haskell>
|-
|  converting a character to lower-case
|  [http://haskell.org/ghc/docs/latest/html/libraries/base-4.12.0.0/Data-Char.html#v%3AtoLower toLower]
| <haskell>
import Data.Char
toLower 'A'            --> 'a'
</haskell>
|-
|  converting a string to upper-case
|  [http://haskell.org/ghc/docs/latest/html/libraries/base-4.12.0.0/Data-Char.html#v%3AtoUpper toUpper], [http://haskell.org/ghc/docs/latest/html/libraries/base-4.12.0.0/Prelude.html#v:map map]
|<haskell>
import Data.Char
map toUpper "Foo Bar"  --> "FOO BAR"
</haskell>
|-
|  converting a string to lower-case
|  [http://haskell.org/ghc/docs/latest/html/libraries/base-4.12.0.0/Data-Char.html#v%3AtoLower toLower], [http://haskell.org/ghc/docs/latest/html/libraries/base-4.12.0.0/Prelude.html#v:map map]
| <haskell>
import Data.Char
map toLower "Foo Bar"  --> "foo bar"
</haskell>
|}

=== Interpolation ===

TODO

=== Performance ===

Text handles character strings with better performance than Strings; it should be the prefered data type for UTF-8 encoded strings.

If observe that Text does not give sufficient performance,  consider [http://hackage.haskell.org/packages/archive/bytestring/latest/doc/html/Data-ByteString.html Data.ByteString], which is essentially a byte array. It can contain UTF-8 characters, but handle with care! .

=== Unicode ===

Current GHC (later than 6) encodes Strings and Text in UTF-8. This may change the behavior of some of the functions explained above when applied to characters beyond the traditional ASCII characters. Remember that not every character in UTF-8 encoding is one byte!