”;
The List, Tuples and Record data structures can be used to store a collection of values.
This chapter discusses how to use List in Elm.
A List is a collection of homogeneous values. The values in a list must all be of the same data type.
Consider the following limitations while using variables to store values −
-
Variables are scalar in nature. In other words, at the time of declaration a variable can hold only one value. This means that to store n values in a program, n variable declarations will be needed. Hence, the use of variables is not feasible when one needs to store a larger collection of values.
-
Variables in a program are allocated memory in random order, thereby making it difficult to retrieve/read the values in the order of their declaration.
Syntax
List_name = [value1,value2,value3.....valuen]
Illustration
The following example shows how to use a List in Elm. Try this example in elm REPL −
> myList1 = [10,20,30] [10,20,30] : List number > myList2 = ["hello","world"] ["hello","world"] : List String
If we try adding values of different types into a list, the compiler will throw a type mismatch error. This is shown below.
> myList = [1,"hello"] -- TYPE MISMATCH --------------------------------------------- repl-temp-000.elm The 1st and 2nd entries in this list are different types of values. 4| [1,"hello"] ^^^^^^^ The 1st entry has this type: number But the 2nd is: String
List operations
Following table shows the common operations on a List −
| Sr. No | Method | Description |
|---|---|---|
| 1 | isEmpty : List a -> Bool | checks if list is empty |
| 2 | reverse : List a -> Bool | reverses input list |
| 3 | length : List a -> Int | returns size of the list |
| 4 | maximum : List comparable -> Maybe.Maybe comparable | returns maximum value |
| 5 | minimum : List comparable -> Maybe.Maybe comparable | returns minimum value |
| 6 | sum : List number -> number | returns sum of all elements in list |
| 7 | product : List number -> number | checks if list is empty |
| 8 | sort : List comparable -> List comparable | sorts list in ascending order |
| 9 | concat : List (List a) -> List a | merges a bunch of list into one |
| 10 | append : List a -> List a -> List a | merges two lists together |
| 11 | range : Int -> Int -> List Int | returns a list of numbers from start to end |
| 12 | filter : (a -> Bool) -> List a -> List a | filters list of values from input list |
| 13 | head : List a -> Maybe.Maybe a | returns the first element from list |
| 14 | tail : : List a -> Maybe.Maybe (List a) | returns all elements except the head |
isEmpty
This function returns true if a list is empty.
Syntax
List.isEmpty list_name
To check the signature of function, type the following in elm REPL −
> List.isEmpty <function> : List a -> Bool
Illustration
> List.isEmpty <function> : List a -> Bool > List.isEmpty [10,20,30] False : Bool
reverse
This function reverses the list.
Syntax
List.reverse list_name
To check the signature of function, type the following in elm REPL −
> List.reverse <function> : List a -> List a
Illustration
> List.reverse [10,20,30] [30,20,10] : List number
length
This function returns the length of a list.
Syntax
List.length list_name
To check the signature of function, type the following in elm REPL −
> List.length <function> : List a -> Int
Illustration
> List.length [10,20,30] 3 : Int
maximum
This function returns the maximum element in a non-empty list.
Syntax
List.maximum list_name
To check the signature of function, type the following in elm REPL −
> List.maximum <function> : List comparable -> Maybe.Maybe comparable
Illustration
> List.maximum [10,20,30] Just 30 : Maybe.Maybe number > List.maximum [] Nothing : Maybe.Maybe comparable
minimum
This function returns the minimum element in a non-empty list.
Syntax
List.minimum list_name
To check the signature of function, type the following in elm REPL −
> List.minimum <function> : List comparable -> Maybe.Maybe comparable
Illustration
> List.minimum [10,20,30] Just 10 : Maybe.Maybe number
sum
This function returns the sum of all elements in a list.
Syntax
List.sum list_name
To check the signature of function, type the following in elm REPL −
> List.sum <function> : List number -> number
Illustration
> List.sum [10,20,30] 60 : number
product
This function returns the product of all elements in a list.
Syntax
List.product list_name
To check the signature of function, type the following in elm REPL −
<function> : List number -> number
Illustration
List.product [10,20,30] 6000 : number
sort
This function sorts values from lowest to highest in a list.
Syntax
List.sort list_name
To check the signature of function, type the following in elm REPL −
> List.sort <function> : List comparable -> List comparable
Illustration
> List.sort [10,20,30] [10,20,30] : List number
concat
This function concatenates a bunch of lists into a single list.
Syntax
List.concat [ [list_name1],[list_name2],[list_name3],.....[list_nameN] ]
To check the signature of function, type the following in elm REPL −
> List.concat <function> : List (List a) -> List a
Illustration
> List.concat [[10,20], [30,40],[50,60]] [10,20,30,40,50,60] : List number
append
This function puts two lists together.
Syntax
List.append [list_name1] [list_name2]
To check the signature of function, type the following in elm REPL −
> List.append <function> : List a -> List a -> List a
Illustration
> List.append [10,20] [30,40] [10,20,30,40] : List number
The ++ operator can also be used to append a list to another. This is shown in the example below −
> [10.1,20.2] ++ [30.3,40.4] [10.1,20.2,30.3,40.4] : List Float
range
This function creates a list of numbers, every element increasing by one. The lowest and the highest number that should be in the list is passed to the function.
Syntax
List.range start_range end_range
To check the signature of function, type the following in elm REPL −
> List.range <function> : Int -> Int -> List Int
Illustration
> List.range 1 10 [1,2,3,4,5,6,7,8,9,10] : List Int
filter
This function filters a set of values from input list. Keep only the values that pass the test.
Syntax
List.filter test_function input_list
To check the signature of function, type the following in elm REPL −
> List.filter <function> : (a -> Bool) -> List a -> List a
Illustration
Following example filters all even numbers from an input list
> List.filter (n -> n%2==0) [10,20,30,55] [10,20,30] : List Int
head
This function returns the first element from input list.
Syntax
List.head input_list
To check the signature of function, type the following in elm REPL −
> List.head <function> : List a -> Maybe.Maybe a
Illustration
> List.head [10,20,30,40] Just 10 : Maybe.Maybe number > List.head [] Nothing : Maybe.Maybe a
tail
This function returns all elements after first in the list.
Syntax
List.tail input_list
To check the signature of function, type the following in elm REPL −
> List.tail <function> : List a -> Maybe.Maybe (List a)
Illustration
> List.tail [10,20,30,40,50] Just [20,30,40,50] : Maybe.Maybe (List number) > List.tail [10] Just [] : Maybe.Maybe (List number) > List.tail [] Nothing : Maybe.Maybe (List a)
Using the Cons Operator
The cons operator ( :: ) adds an element to the front of a list.
Illustration
> 10::[20,30,40,50] [10,20,30,40,50] : List number
The new element to be added and the data-type of the values in the list must match. The compiler throws an error if the data types do not match.
> [1,2,3,4]::[5,6,7,8] -- TYPE MISMATCH --------------------------------- ------------ repl-temp-000.elm The right side of (::) is causing a type mismatch. 3| [1,2,3,4]::[5,6,7,8] ^^^^^^^^^ (::) is expecting the right side to be a: List (List number) But the right side is: List number Hint: With operators like (::) I always check the left side first. If it seems fine, I assume it is correct and check the right side. So the problem may be in how the left and right arguments interact.
Lists are immutable
Let us check if lists are immutable in Elm. The first list myList when concatenated with value 1 creates a new list and is returned to myListCopy. Therefore, if we display initial list, its values will not be changed.
> myList = [10,20,30] [10,20,30] : List number > myListCopy = 1::myList [1,10,20,30] : List number > myList [10,20,30] : List number >myList == myListCopy False : Bool
”;