insert Element at specific position - list

Question

I started Prolog (just for my own) and i am struggling with recursion.
I want a "method", that inserts an element at a specific position within a list.
What i tried so far is :
insertAt(Element,Position,List,ResultList)
insertAt(Element,0,L,[Element|L]).
insertAt(Element,Pos,[E|L],ZL):-
Pos1 is Pos-1,
insertAt(Element,Pos1,L,ZL),
append(E,ZL1,ZL).
I find i quite complicated, since i cant understand how the recursion exactly works...
Maybe someone can help me out.

Answer 1

There are several features of your code that make it hard to understand for beginners. In particular, the use of moded, low-level arithmetic is a severe impediment when interacting with the program in a playful (and in fact also in a serious) way.
For example, to understand a relation, it is useful to start with the most general query. This only asks "Is there any solution at all, and if so, what does a solution look like?". In your specific example, the most general query looks like:
?- insertAt(E, Pos, Ls0, Ls).
and this almost immediately yields an instantiation error due to the non-declarative arithmetic predicates you are using:
?- insertAt(E, Pos, Ls0, Ls).
Pos = 0,
Ls = [E|Ls0] ;
ERROR: insertAt/4: Arguments are not sufficiently instantiated
In addition, you are impeding a nice declarative reading by using an imperative name ("insert..."). This makes it unnecessarily hard to develop a feeling for relational programming.
Therefore, I recommend you: (1) Use a more declarative predicate name, and (2) use a symbolic representation of natural numbers that makes the predicate easier to understand and more general.
I will use the number 0 to represent zero, and the term s(X) to represent the successor of the number X. See successor-arithmetics for more information about this representation.
With these changes, the code becomes:
element_at(E, 0, [_|Ls], [E|Ls]).
element_at(E, s(X), [L|Ls0], [L|Ls]) :-
element_at(E, X, Ls0, Ls).
To understand this program, we read it declaratively: The first clause is true if the position is 0, and the head of the final list is E, and the tail ... etc. The second clause is true if element_at(E, X, Ls0, Ls) holds, and the head of ... etc.
Nicely, the most general query now works much better:
?- element_at(E, Pos, Ls0, Ls).
Pos = 0,
Ls0 = [_G1071|_G1072],
Ls = [E|_G1072] ;
Pos = s(0),
Ls0 = [_G1073, _G1079|_G1080],
Ls = [_G1073, E|_G1080] ;
Pos = s(s(0)),
Ls0 = [_G1073, _G1081, _G1087|_G1088],
Ls = [_G1073, _G1081, E|_G1088] .
Notice though that there is something unfair going on here: Where are answers for remaining positions? For fairer enumeration, we use length/2, stating in advance the length of the lists we are considering one after another:
?- length(Ls0, _), element_at(E, Pos, Ls0, Ls).
Ls0 = [_G1124],
Pos = 0,
Ls = [E] ;
Ls0 = [_G1124, _G1127],
Pos = 0,
Ls = [E, _G1127] ;
Ls0 = [_G1124, _G1127],
Pos = s(0),
Ls = [_G1124, E] .
And now it is clearer how the different arguments interact, because you already see various examples of terms that are described by your predicate.
In fact, to reduce the number of arguments and variable names we need to keep track of, I often use DCG notation when describing lists, and I would like to show you this alternative version too:
element_at(Element, 0, [_|Ls]) -->
[Element],
list(Ls).
element_at(Element, s(X), [L|Ls]) -->
[L],
element_at(Element, X, Ls).
list([]) --> [].
list([L|Ls]) --> [L], list(Ls).
?- length(Ls0, _), phrase(element_at(E, Pos, Ls0), Ls).
Ls0 = [_G1148],
Pos = 0,
Ls = [E] ;
Ls0 = [_G1148, _G1151],
Pos = 0,
Ls = [E, _G1151] ;
Ls0 = [_G1148, _G1151],
Pos = s(0),
Ls = [_G1148, E] .
Once you read up on dcg notation, this version will become clear to you.
At last, you may say "Well, that's nice, but s(X) notation still seems quite strange", and you may want to use the more widely used Hindu-Arabic notation for integers in your programs.
For this, we can simply take either version from above and replace s(X) notation by declarative integer arithmetic with CLP(FD) constraints. For example, with the first version:
:- use_module(library(clpfd)).
element_at(E, 0, [_|Ls], [E|Ls]).
element_at(E, X, [L|Ls0], [L|Ls]) :-
X #> 0,
X #= X0 + 1,
element_at(E, X0, Ls0, Ls).
This also works in all directions, exactly as we expect from a nicely declarative and general predicate:
?- length(Ls0, _), element_at(E, Pos, Ls0, Ls).
Ls0 = [_G2095],
Pos = 0,
Ls = [E] ;
Ls0 = [_G2095, _G2098],
Pos = 0,
Ls = [E, _G2098] ;
Ls0 = [_G2095, _G2098],
Pos = 1,
Ls = [_G2095, E] .
Please see clpfd for more information, and I hope this post encourages you to think more relationally about your Prolog code, try it in all directions, and read it declaratively. (What is being described?)

Answer 2

Let same_length/2, append/3, and length/2 take care of recursion!
insertAt(E,N,Xs,Ys) :-
same_length([E|Xs],Ys),
append(Before,Xs0,Xs),
length(Before,N),
append(Before,[E|Xs0],Ys).
Sample query:
?- insertAt(X, N, [a,b,c,d,e], Ys).
( N = 0, Ys = [X,a,b,c,d,e]
; N = 1, Ys = [a,X,b,c,d,e]
; N = 2, Ys = [a,b,X,c,d,e]
; N = 3, Ys = [a,b,c,X,d,e]
; N = 4, Ys = [a,b,c,d,X,e]
; N = 5, Ys = [a,b,c,d,e,X]
; false
).

Answer 3

A Prolog feature is pattern matching, that is rule selection based on predicate arguments. Such feature it's key to Prolog notation, allowing for compact description of relation, notably for on recursive terms, like lists. Note, lists are just 'syntactic sugar' for recursive terms, with a conventional functor (term' name, in every day parlance).
insertAt(Element,0,L,[Element|L]). % ok
insertAt(Element,Pos,[E|L],[E|ZL]):- % you forgot to cons back E
Pos1 is Pos-1,
insertAt(Element,Pos1,L,ZL). % done, append is useless
%append(E,ZL1,ZL).
SWI-Prolog has nth1/4 and nth0/4, that can perform insertion:
?- nth0(1,L,x,[1,2,3]).
L = [1, x, 2, 3].