The following are some important points about lists in Haskell.
Lists in Haskell, unlike in Scheme, are homogeneous, meaning all elements of the list must be of the same type. For instance, the list [1, 2, 3] in Haskell is homogeneous, while the list (1 "apple") in Scheme is heterogeneous.
In a type-safe language like Haskell, the values in a tuple (Section C.8) generally have different types, but the number of elements in the tuple must be fixed. Conversely, the values of a list must all have the same type, but the number of elements in the list is not fixed.
The semantics of lexeme [] is the empty list.
The cons operator, which accepts an element (the head) and a list (the tail), is : (e.g., 1:2: [3]) and associates right-to-left.
The expression x:xs represents a list of at least one element.
The expression xs is pronounced exes.
The expression x:[] represents a list of exactly one element, just as [x] does.
The expression x:y:xs represents a list of at least two elements.
The expression x:y:[] represents a list of exactly two elements.
The functions head and tail are the Haskell analogs of the Scheme functions car and cdr, respectively.
The element selection operator (!!) on a list uses zero-based indexing. For example, [1, 2, 3, 4, 5]!!3 returns 4.
The built-in function len returns the number of elements in its only list argument.
The append operator (++) accepts two lists and appends them to each other. For example, [1, 2]++[3, 4, 5]; returns [1, 2, 3, 4, 5]). The append operator in Haskell is also inefficient, just as it is in Scheme.
The built-in function elem is a list member and returns True if its first argument is a member of its second list argument and False otherwise.
Examples:
As can be seen, in Haskell a String is a list of Chars.
3.129.25.217