Lists and Recursion - Revision history

Thomas Linder Puls: format bug

2025-10-06T13:10:33Z

format bug

← Older revision		Revision as of 15:10, 6 October 2025
Line 666:		Line 666:
	stdio::write("SECOND LIST: ", Ans2, "\n\n").		stdio::write("SECOND LIST: ", Ans2, "\n\n").

	end implement main~~</vip>~~		end implement main

	goal		goal
	console::init(),		console::init(),
	main::test().		main::test().
			</vip>

	== Parsing by Difference Lists ==		== Parsing by Difference Lists ==

Thomas Linder Puls: add goal

2025-10-06T13:09:25Z

add goal

← Older revision		Revision as of 15:09, 6 October 2025
Line 667:		Line 667:

	end implement main</vip>		end implement main</vip>

			goal
			console::init(),
			main::test().

	== Parsing by Difference Lists ==		== Parsing by Difference Lists ==

Magnus Jacobsen: /* Tail Recursion */

2022-09-05T13:42:34Z

Tail Recursion

← Older revision		Revision as of 15:42, 5 September 2022
Line 305:		Line 305:
	goal		goal
	console::init(),		console::init(),
	main::length_of([1, 2, 3]~~, L~~, 0), /* start with Counter = 0 */		Length = main::length_of([1, 2, 3], 0), /* start with Counter = 0 */
	stdio::write(" L = ", L).</vip>		stdio::write("Length = ", Length).</vip>

	This version of the <vp>length_of</vp> predicate is more complicated, and in many ways less logical, than the previous one. We've presented it merely to show you that, ''by devious means, you can often find a tail-recursive algorithm for a problem that seems to demand a different type of recursion''.		This version of the <vp>length_of</vp> predicate is more complicated, and in many ways less logical, than the previous one. We've presented it merely to show you that, ''by devious means, you can often find a tail-recursive algorithm for a problem that seems to demand a different type of recursion''.

Thomas Linder Puls: Formal parameters

2022-02-02T09:34:12Z

Formal parameters

← Older revision		Revision as of 11:34, 2 February 2022
Line 625:		Line 625:
	<vip>domains		<vip>domains
	list = elem*.		list = elem*.
	elem = l(list); i(integer); c(char); s(string).		elem = l(list List); i(integer Integer); c(char Char); s(string String).
	% the functors are l, i, c, and s</vip>		% the functors are l, i, c, and s
			</vip>

	The list		The list
Line 642:		Line 643:
	domains		domains
	list = elem*.		list = elem*.
	elem =l(list); i(integer); c(char); s(string).		elem = l(list List); i(integer Integer); c(char Char); s(string String).

	predicates		predicates

Thomas Linder Puls: wrong domains

2022-02-02T09:24:23Z

wrong domains

← Older revision		Revision as of 11:24, 2 February 2022
Line 624:		Line 624:

	<vip>domains		<vip>domains
	~~llist~~ = l(list); i(integer); c(char); s(string).		list = elem*.
			elem = l(list); i(integer); c(char); s(string).
	% the functors are l, i, c, and s</vip>		% the functors are l, i, c, and s</vip>

Line 640:		Line 641:

	domains		domains
	~~llist~~ =		list = elem*.
	l(list);		elem =l(list); i(integer); c(char); s(string).
	i(integer);
	c(char);
	s(string).

	predicates		predicates

Kasper B H Petersen: /* Finding All the Solutions at Once */

2021-10-11T12:42:10Z

Finding All the Solutions at Once

← Older revision		Revision as of 14:42, 11 October 2021
Line 561:		Line 561:
	*The output ListParam, is a variable that holds the list of values collected through backtracking.		*The output ListParam, is a variable that holds the list of values collected through backtracking.

	~~The this~~ program uses list comprehension to print the average age of a group of people.		This program uses list comprehension to print the average age of a group of people.

	<vip>class main		<vip>class main

Thomas Linder Puls: review

2019-09-17T09:48:21Z

review

Show changes

Thomas Linder Puls: normal program structure

2018-10-02T12:46:11Z

normal program structure

← Older revision		Revision as of 14:46, 2 October 2018
Line 174:		Line 174:
	For example, if you just want to print out the elements of the list, here is what you do:		For example, if you just want to print out the elements of the list, here is what you do:

	<vip>~~class my~~		<vip>implement main
	~~predicates~~
	~~write_a_list : (integer*).~~
	~~end class~~

	~~implement my~~		clauses
	clauses		run() :-
	write_a_list([]).		write_a_list([1, 2, 3]).
	/* If the list is empty, do nothing more. */
	write_a_list([H\|T]):-		class predicates
	/* Match the head to H and the tail to T, then... */		write_a_list : (integer*).
	stdio::write(H),stdio::nl,		clauses
	write_a_list(T).		write_a_list([]).
	end implement		/* If the list is empty, do nothing more. */
			write_a_list([H\|T]):-
			/* Match the head to H and the tail to T, then... */
			stdio::write(H),
			stdio::nl,
			write_a_list(T).

			end implement main

	goal		goal
	console::~~init~~(),		console::runUtf8(main::run).</vip>
	my::~~write_a_list([1, 2, 3]~~).</vip>

	Here are the two write_a_list clauses described in natural language:		Here are the two write_a_list clauses described in natural language:
Line 199:		Line 202:
	*Otherwise, to write a list, write its head (which is a single element), then write its tail (a list).		*Otherwise, to write a list, write its head (which is a single element), then write its tail (a list).

	The ~~first time through, the goal~~ is:		The <vp>write_a_list</vp> predicate is called from <vp>run</vp> clause:

	<vip>~~my::~~write_a_list([1, 2, 3]).</vip>		<vip>write_a_list([1, 2, 3])</vip>

	This matches the second clause, with H=1 and T=[2, 3]; this writes 1 and then calls write_a_list recursively with the tail of the list:		This matches the second clause, with H=1 and T=[2, 3]; this writes 1 and then calls write_a_list recursively with the tail of the list:

	<vip>~~my::~~write_a_list([2, 3]).		<vip>write_a_list([2, 3]).
	/* This is write_a_list(T). */</vip>		/* This is write_a_list(T). */</vip>

	This recursive call matches the second clause, this time with H=2 and T=[3], so it writes 2 and again calls write_a_list recursively:		This recursive call matches the second clause, this time with H=2 and T=[3], so it writes 2 and again calls write_a_list recursively:

	<vip>~~my::~~write_a_list([3]).</vip>		<vip>write_a_list([3]).</vip>

	Now, which clause will this goal match? Recall that, even though the list [3] has only one element; it does have a head and tail; the head is 3 and the tail is []. So, again the goal matches the second clause, with H=3 and T=[]. Hence, 3 is written and write_a_list is called recursively like this:		Now, which clause will this goal match? Recall that, even though the list [3] has only one element; it does have a head and tail; the head is 3 and the tail is []. So, again the goal matches the second clause, with H=3 and T=[]. Hence, 3 is written and write_a_list is called recursively like this:

	<vip>~~my::~~write_a_list([]).</vip>		<vip>write_a_list([]).</vip>

	Now you see why this program needs the first clause. The second clause will not match this goal because [] cannot be divided into head and tail. So, if the first clause were not there, the goal would fail. As it is, the first clause matches and the goal succeeds without doing anything further.		Now you see why this program needs the first clause. The second clause will not match this goal because [] cannot be divided into head and tail. So, if the first clause were not there, the goal would fail. As it is, the first clause matches and the goal succeeds without doing anything further.

EJP at 10:26, 3 November 2016

2016-11-03T10:26:24Z

← Older revision		Revision as of 12:26, 3 November 2016
Line 261:		Line 261:
	*TailLength in the goal to L in the clause.		*TailLength in the goal to L in the clause.

	Recall that TailLength in the goal will not interfere with ~~TailLengt''h''~~ in the clause, because '''''each recursive invocation of a clause has its own set of variables'''''.		Recall that TailLength in the goal will not interfere with TailLength in the clause, because '''''each recursive invocation of a clause has its own set of variables'''''.

	So now the problem is to find the length of [3], which will be 1, and then add 1 to that to get the length of [2, 3], which will be 2. So far, so good.		So now the problem is to find the length of [3], which will be 1, and then add 1 to that to get the length of [2, 3], which will be 2. So far, so good.

Thomas Linder Puls: category

2016-03-04T10:15:39Z

← Older revision		Revision as of 12:15, 4 March 2016
Line 869:		Line 869:
	*The process of ''parsing by difference lists'' works by reducing the problem; the example in this tutorial transforms a string of input into a Prolog structure that can be used or evaluated later.		*The process of ''parsing by difference lists'' works by reducing the problem; the example in this tutorial transforms a string of input into a Prolog structure that can be used or evaluated later.

	~~==References==~~
	[[ru:Списки и рекурсия]]		[[ru:Списки и рекурсия]]
	[[Category:~~Tutorials~~]]		[[Category:Data types and handling]]