Tutorials

h1. List in Scol

Lists are very common in Scol.

A list can be extended dynamically. Its use memory can increase and, in a long list, the accessing an element can take a "long" time.

A list is always a tuple with two element : the first element and the next of the list. This next is itself composed of the first element of this next and the next of the next ...

<pre>

first element next

			first element next

						first element next

									first element next

												nil

</pre>

The last element is **always** nil : this is the end of our list.

Example : 0 1 2 3 4 5 6 7

<pre>

0 next

	1 next

		2 next

			3 next

				4 next

					5 next

						6 next

							7 nil

</pre>

So, we get in Scol :

<pre>

[0 next] with next is [1 next_2] with next_2 is [2 next_3] .... until [7 nil]

</pre>

So, we get really in Scol :

<pre>

[0 [1 [2 [3 [4 [5 [6 [7 nil]]]]]]]]

</pre>

We can write the same exact list with this other manner :

<pre>

0::1::2::3::4::5::6::7::nil

</pre>

This is faster but the structure disappears.

*hd* <list> returns the first element (head)

*tl* <list> returns the next (tail)

h2. What is the type of a list ?

Generally, the type of a list is *[u0 r1]*, u0 for any type, simple or complex, r1 for the first level of recursivity. The second level, r2, exists, rarest. r3 ... rn are theoretical.

h3. Example :

*[I r1]* : a list of integers

*[[S F] r1]* : a list of tuple, each tuple has two element, a string (F) and a float (F)

*[[[[S I I] r1] I S] r1]* : a list of tuples, each tuple has three elements : another list, an integer, a string.

*[[S r1] r1]* : a list of list of strings. We will meet often this when we parse a text : each line is a list of words, the text is a list of lines.

h2. How get the Nth element ?

h3. By a Scol function (standard api) : 

*nth_list* <list> <position>

<pre>

set list = [0 [10 [21 [32 [43 [54 [65 [76 nil]]]]]]]];

set n = nth_list list 5;	// is 54

</pre>

h3. By writing a recursive function. 

We find again the structure of a list :

<pre>

fun getNelement (list, n)=

	if list == nil then

		nil	// the list is smaller then n

	else

		let list -> [first next] in

		if n == 0 then

			first

		else

			getNelement next n-1;;	// we continue with the next of the current list

fun main ()=

	_showconsole;

	set list = [0 [10 [21 [32 [43 [54 [65 [76 nil]]]]]]]];

	_fooId getNelement list 5;	// 54 is displayed

	0;;

</pre>

Note : the list is unchanged before and after the threatment by getNelement !

h2. How get the size of a list ?

h3. By a Scol function (standard api) : 

*sizelist* <list>

<pre>

set list = [0 [10 [21 [32 [43 [54 [65 [76 nil]]]]]]]];

set size = sizelist list;	// is 8

</pre>

h3. By writing a recursive function. 

We find again the structure of a list :

<pre>

fun getSizeList (list, n)=

	if list == nil then

		n	// we are at the end of the list (= nil)

	else

		getSizeList	tl list n+1;; // we continue with the next of the current list

fun main ()=

	_showconsole;

	set list = [0 [10 [21 [32 [43 [54 [65 [76 nil]]]]]]]];

	_fooId getSizeList list 0;	// 8 is displayed

	0;;

</pre>

h2. How set the Nth element ?

By writing a recursive function. We find again the structure of a list :

<pre>

fun setNelement (list, position, value)=

	if list == nil then

		nil	// the list is smaller then n

	else

		if position == 0 then

			[value tl list] // or value :: (tl list), it is the same thing

		else

			[hd list setNelement tl list position-1 value];; // we continue with the next of the current list

fun main ()=

	_showconsole;

	set list = [0 [10 [21 [32 [43 [54 [65 [76 nil]]]]]]]];

	set list = setNelement list 5 100;	// [0 [10 [21 [32 [43 [100 [65 [76 nil]]]]]]]]

	0;;

</pre>

h2. How to get a sub list from a position ?

By writing a recursive function. We find again the structure of a list :

<pre>

fun getSubList (list, position)=

	if list == nil then

		nil	// the list is smaller then n

	else

		if position == 0 then

			list

		else

			getSubList tl list position-1;; // we continue with the next of the current list

fun main ()=

	_showconsole;

	set list = [0 [10 [21 [32 [43 [54 [65 [76 nil]]]]]]]];

	set list = getSubList list 5;	// [54 [65 [76 nil]]]

	0;;

</pre>

h2. How to find the position of an element ?

By writing a recursive function. We find again the structure of a list :

<pre>

fun findAnInteger (list, intToFind, position)= // all types except a string (S)

	if list == nil then

		nil	// not found

	else

		if intToFind == hd list then

			position

		else

			findAnInteger tl list intToFind position+1;; // we continue with the next of the current list

fun findAString (list, strToFind, position)= // type string (S) only

	if list == nil then

		nil	// not found

	else

		if (!strcmp strToFind hd list )then

			position

		else

			findAString tl list strToFind position+1;; // we continue with the next of the current list

fun main ()=

	_showconsole;

	set list = [0 [10 [21 [32 [43 [54 [65 [76 nil]]]]]]]];

	_fooId findAnInteger list 54 0;	// 5

	0;;

</pre>

h2. How compare two lists ?

By writing a recursive function. We find again the structure of a list :

<pre>

fun cmpLists (listA, listB)=

	if ((listA == nil) && (listB == nil)) then // lists are ended, we return 1 (true)

		1

	else if (hd listA) == (hd listB) then	// First elements are equals, we continue with the next

		cmpLists tl listA tl listB

	else	// first elements ae differents, we stop and returns 0 (false)

		0;;

fun main ()=

	_showconsole;

	set listA = [0 [10 [21 [32 [43 [54 [65 [76 nil]]]]]]]];

	set listB = [0 [10 [21 [32 [43 [54 [65 nil]]]]]]];

	_fooId cmpLists listA listB;	// 0, not equal

	0;;

</pre>

---------------------

To try it, copy this code :

- In _tutorials/list.pkg_ :

<pre>

typeof listA = [I r1];;

typeof listB = [I r1];;

fun getNelement (list, n)=

	if list == nil then

		nil	// the list is smaller then n

	else

		let list -> [first next] in

		if n == 0 then

			first

		else

			getNelement next n-1;;	// we continue with the next of the current list

fun mainGetNelement ()=

	_showconsole;

	set listA = [0 [10 [21 [32 [43 [54 [65 [76 nil]]]]]]]];

	_fooId getNelement listA 5;	// 54 is displayed

	0;;

fun getSizeList (list, n)=

	if list == nil then

		n	// we are at the end of the list (= nil)

	else

		getSizeList	tl list n+1;; // we continue with the next of the current list

fun mainSizeList ()=

	_showconsole;

	set listA = [0 [10 [21 [32 [43 [54 [65 [76 nil]]]]]]]];

	_fooId getSizeList listA 0;	// 8 is displayed

	0;;

fun setNelement (list, position, value)=

	if list == nil then

		nil	// the list is smaller then n

	else

		if position == 0 then

			[value tl list] // or value :: (tl list), it is the same thing

		else

			[hd list setNelement tl list position-1 value];; // we continue with the next of the current list

fun mainSetNelement ()=

	_showconsole;

	set listA = [0 [10 [21 [32 [43 [54 [65 [76 nil]]]]]]]];

	set listA = setNelement listA 5 100;	// [0 [10 [21 [32 [43 [100 [65 [76 nil]]]]]]]]

	_fooIdList listA;

	0;;

fun getSubList (list, position)=

	if list == nil then

		nil	// the list is smaller then n

	else

		if position == 0 then

			list

		else

			getSubList tl list position-1;; // we continue with the next of the current list

fun mainSubList ()=

	_showconsole;

	set listA = [0 [10 [21 [32 [43 [54 [65 [76 nil]]]]]]]];

	set listA = getSubList listA 5;	// [54 [65 [76 nil]]]

	_fooIdList listA;

	0;;

fun findAnInteger (list, intToFind, position)= // all types except a string (S)

	if list == nil then

		nil	// not found

	else

		if intToFind == hd list then

			position

		else

			findAnInteger tl list intToFind position+1;; // we continue with the next of the current list

fun findAString (list, strToFind, position)= // type string (S) only

	if list == nil then

		nil	// not found

	else

		if (!strcmp strToFind hd list )then

			position

		else

			findAString tl list strToFind position+1;; // we continue with the next of the current list

fun mainFind ()=

	_showconsole;

	set listA = [0 [10 [21 [32 [43 [54 [65 [76 nil]]]]]]]];

	_fooId findAnInteger listA 54 0;	// 5

	0;;

fun cmpLists (listA, listB)=

	if ((listA == nil) && (listB == nil)) then // lists are ended, we return 1 (true)

		1

	else if (hd listA) == (hd listB) then	// First elements are equals, we continue with the next

		cmpLists tl listA tl listB

	else	// first elements ae differents, we stop and returns 0 (false)

		0;;

fun mainCmp ()=

	_showconsole;

	set listA = [0 [10 [21 [32 [43 [54 [65 [76 nil]]]]]]]];

	set listB = [0 [10 [21 [32 [43 [54 [65 nil]]]]]]];

	_fooId cmpLists listA listB;

	0;;

</pre>

- In _tutorials/list.scol_ :

<pre>

_load "tutorials/list.pkg"

mainGetNelement

mainSizeList

mainSetNelement

mainSubList

mainFind

mainCmp

</pre>

Note :

In files "locked/lib/stdlib.pkg" et "locked/lib/_mlistlib.pkg", functions about lists are already coded. For use them, add the line _load "locked/lib/stdlib.pkg" and(or) the line _load "locked/lib/_mlistlib.pkg" in your launcher.

Other functions about list are availables in the Syspack library.

License : "CC-BY-SA-2.0":https://creativecommons.org/licenses/by-sa/2.0/

Tutorial by iri

Updated by /