# 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 -
```[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"
```
combining many lists concat
```concat ["foo", "bar", "baz"]    --> "foobarbaz"
```

## Accessing sublists

Problem Solution Examples
```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"
```

TODO

## Performance

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

TODO