List

Much like shopping lists in the real world, lists in Haskell are very useful. List stores multiple homogeneous items in index based way.

List not only helps to store the items in it but also it helps user to perform multiple operations on it. In Haskell, lists are a homogeneous data structure. It stores several elements of the same type. That means that we can have a list of integers or a list of characters but we can't have a list that has a few integers and then a few characters. And now, a list!

We can use the let keyword to define a name right in GHCI. Doing let a = 1 inside GHCI is the equivalent of writing a = 1 in a script and then loading it.


ghci> let numberList = [1, 4, 6, 7]  
ghci> numberList  
[1, 4, 6, 7]

As you can see, lists are denoted by square brackets and the values in the lists are separated by commas. If we tried a list like [1,2,'a',3,'b','c',4], Haskell would show error that characters (which are, by the way, denoted as a character between single quotes) are not numbers.

Speaking of characters, strings are just lists of characters. "haskell" is just syntactic sugar for ['h','a','s','k','e', 'l', 'l']. Because strings are lists, we can use list functions on them, which is really handy.

Operations on List

Lets learn about operations performed on the lists in haskell

Append two lists :

In haskell, we can append two list using the ++ operators.


ghci> [1,2,3,4] ++ [5,6,7,8]  
[1,2,3,4,5,6,7,8]

consing :

In addition to specifying the whole list at once using square brackets and commas, you can build them up piece by piece using the (:) operator pronounced "cons".

The process of building up a list this way is often referred to as consing

We can also add list and a individual element to the list to the first place using : operator in haskell, : will be very useful when you have a huge list.


ghci> 0:[1,2,3,4,5]  
[0,1,2,3,4,5]

// below will not work
ghci> [1,2,3,4,5]  : 7

Index !! in haskell lists

It is important to get an element based on the index of the element in the list, haskell provides !!(index) operator to get a value from a particular index. In haskell the index starts with 0;


ghci> "karthiQ" !! 5  
'i'  
ghci> [1, 2, 3, 4, 5] !! 1  
2 

From the below image you can understand how the list is stored. list-in-haskell

If you try t access 6th element when only is there then haskell will throw an error
*** Exception: Prelude.!!: index too large

Lists of lists

Lists can contain anything — as long as they are all of the same type. Because lists are things too, lists can contain other lists!

Example for list of lists in haskell:


Lists can contain lists
ghci> let listOfLists = [[1,2],[3,4],[5,6]]
ghci> listOfLists
[[1,2],[3,4],[5,6]]

We can access list of lists using the !! index operator


ghci> listOfLists !! 2
[5,6]

We also can acces sthe elements preent in the list of lists using index operator.


ghci> listOfLists !! 2 !! 1
6

The lists within a list can be of different lengths but they can't be of different types. Just like you can't have a list that has some characters and some numbers, you can't have a list that has some lists of characters and some lists of numbers.

Functions in haskell list

head

head takes a list and returns its head, The head of a list is basically its first element.


ghci> head [1,3,5,6]  
1  

If you have the list in a variable then head will bring teh first element but it has no effect on the list. So original list stays same.


ghci> let li =[2,3,4,5]
ghci> head li
2
ghci>
ghci> li
[2,3,4,5]
ghci>

tail

tail takes a list and returns its tail, In other words, tail removes the first element from the list and returns the remaining list. BUt it doenot have any effect on original list.


ghci> let li =[2,3,4,5]
ghci> li
[2,3,4,5]
ghci> tail li
[3,4,5]
ghci> li
[2,3,4,5]
ghci>  

last

last takes a list and returns its last element. It has no effect on original list


ghci> let li =[2,3,4,5]
ghci> li
[2,3,4,5]
ghci> last li
5

init

init takes a list and returns list without the last element of the list, has no effect on original list

ghci> let li =[2,3,4,5]
ghci> li
[2,3,4,5]
ghci> init li
[2,3,4]
ghci>

length

length takes a list and returns its length, length is number of elements present in the list. The last index is always length-1 as list index starts from 0


ghci> let li =[2,3,4,5]
ghci> li
[2,3,4,5]
ghci> length li
4
ghci>

null

null checks if a list is empty. If it is, it returns True, otherwise it returns False. This will be useful when you are not sure whether a list has some elements or not.


ghci> null [1,2,3]  
False  
ghci> null []  
True 

reverse

reverse reverses the given list of items.


ghci> reverse [5,4,3,2,1]  
[1,2,3,4,5]  

take

take takes number and a list. It extracts that many elements from the beginning of the list. Watch


ghci> let li =[2,3,4,5]
ghci> li
[2,3,4,5]
ghci> drop 2 li
[4,5]
ghci> li
[2,3,4,5]
ghci> take 3 li
[2,3,4]
ghci> li
[2,3,4,5]
ghci>

drop

drop works in a similar way, only it drops the number of elements from the beginning of a list.


ghci> let li =[2,3,4,5]
ghci> li
[2,3,4,5]
ghci> drop 2 li
[4,5]
ghci> li
[2,3,4,5]
ghci>

elem

elem takes a thing and a list of things and tells us if that thing is an element of the list. It's usually called as an infix function because it's easier to read that way. elem should be used along with the ` and it is not singe quote


ghci> 4 `elem` li
True
ghci>

Mathematical function on list

maximum and minimum

maximum takes a list of stuff that can be put in some kind of order and returns the biggest element. minimum returns the smallest element in that list


ghci> let li =[2,3,4,5]
ghci> li
[2,3,4,5]
ghci> maximum li
5
ghci> minimum li
2
ghci>

sum

sum takes a list of numbers and returns their sum.


ghci> let li =[2,3,4,5]
ghci> li
[2,3,4,5]
ghci> sum li
14

product

product takes a list of numbers and returns their product.


ghci> let li =[2,3,4,5]
ghci> li
[2,3,4,5]
ghci> product li
120
ghci>

Ranges with Lists in haskell

Range (..

Haskell is able to generate the number based on he given range, range is nothing but interval between two number.

Haskell generates the ranges based on the given function. Ranges are generated using .. operator in Haskell

To make a list containing all the natural numbers from 1 to 20, you just write [1..10]. That is the equivalent of writing [1,2,3,4,5,6,7,8,9,10] and there's no difference between writing one or the other except that writing out long enumeration sequences manually is stupid.


ghci> [1..20]  
[1,2,3,4,5,6,7,8,9,10,11,12,13,14,15,16,17,18,19,20]  
ghci> ['a'..'z']  
"abcdefghijklmnopqrstuvwxyz"  
ghci> ['K'..'Z'] 

cycle

cycle takes a list and cycles it into an infinite list. If you just try to display the result, it will go on forever so you have to slice it off somewhere.


ghci> take 7 (cycle [0,2,4])
[0,2,4,0,2,4,0]
ghci>

repeat

repeat takes an element and produces an infinite list of just that element. It's like cycling a list with only one element.


ghci> take 3 (repeat 7)
[7,7,7]
ghci>

replicate

replicate function create given number of the same element in a list.


ghci> replicate 10 7
[7,7,7,7,7,7,7,7,7,7]
ghci>

About Author

Myself KarthiQ, I am the author of this blog, I know ways to write a good article but some how I donot have the skills to make it to reach people, would you like help me to reach more people By sharing this Article in the social media.

Share this Article Facebook
Comment / Suggestion Section
Point our Mistakes and Post Your Suggestions

Recent Addition

new tutorial Protractor Online Training : I am starting online training course for Protractor with Typescript from 15th November 2018.

You can attend first 3 classes for free, the total course fee is INR 10,000

The course time would be 8.00 PM(IST) for the first three classes

The course time would be 8.00 PM(IST) for the first three classes

If you are interested to learn then you can join the course by sending email to chercher.tech@gmail.com

or Register below


Subscribe
 
Join My Facebook Group
Join Group