@Carl Love Thanks again.  Please forgive my stupidity, but how do I use something different from Maple's 2d-input? Is that tab "C 2D input" not the standard input?   I am asking this because I had to change from () to NULL which means I have been using Maple's 2d-input.   I haven't test the procedure as yet since the testing list takes ages to be built.

@Carl Love Many thanks but Classify it is not available on Maple 14.  I have Maple 2016 installed on two computers but my floating license is for Maple 14.   The other answer is ok for small lists but as you have correctly pointed out is not for large list which is my case (250.000 elements).  

@emendes I noticed that the solution does not seem to work unless I use expand(p).   Does it make sense?

@Carl Love many many thanks.  I have wrapped it up in a procedure using the helpful tips you have listed when answering my previous question.  If I may, could you tell me how I can limit the time and memory Maple spends in a procedure? One of my procedures uses groebner basis and depending on the set of polynomials, it crashes my 30 GB (ram) desktop.

@Carl Love Many many thanks.  The examples are very helpful and I have managed to get some of old procedures modified to use the ideas in the examples.

@Carl Love Many thanks.   I am positive that I didn't get it.  Suppose I want to write a procedure with two parameters, say, f and vars.  Both are list and the second parameter, vars, should have the length of f (the only two conditions I need to test).  I confess that I don't know even where to start. 

@Carl Love Mnay thanks.   Can you explain the options you have added to the calling args of the function, specially the variable v?

@Carl Love Many thanks.  Nice explanation. Some of the syntax used is unknown to me.  Any tutorial, book and so on that might be useful to grasp the usage and meaning of them?  Again, thank you.

@John Fredsted Thank you ever so much for the solutions and I will stick with eval (no predilection for subs).   I found my mistake in all other examples: I have type r*x (1-x) instead of r*x*(1-x).

@John Fredsted Many thanks but that it is exactly what i am trying to avoid, that is, the function using l[1], l[2] and etc.  f will be used inside of a proc.

If instead of what you proposed I define  f:=(x,y,z) -> [y, y z - x, -15 x y - x z - x], (f@@4)  returns an error message.  

It seems that f:=()->[] and f:=()-> (), unless defined as you did,  are not the answer.  Same goes for the solution using eval.   All of them work if the list has more than one element, that is, [x,y,z] but they don't work if the list is [x]. I hope I am wrong.

It seems that my only alternative is to use subs if I want to stick with list. 

@John Fredsted what I would like to achieve is f...f(f(f(f(x)))), where x is always a list.  Let me simplify the last example to hopefully clarify where I am facing the problem.

ee := [r*x(1-x)];
                                               [r x(1 - x)]
eval(ee, [x]=~[x]);
                                               [r x(1 - x)]
eval(ee, [x]=~eval(ee,[x]=~[x]));
                                               [r r(1 - r x(1 - x)) x(1 - x)(1 - r x(1 - x))]

ff := x-> [r*x(1-x)];
                                                x -> r x(1 - x)
ff(op([x]));
                                                [r x(1 - x)]
ff(op([r*x(1-x)]));
                                                [r r(1 - r x(1 - x)) x(1 - x)(1 - r x(1 - x))]
subs(x = x, [r*x(1-x)]);
                                                [r x(1 - x)]
subs(x = op([r*x(1-x)]), r*x(1-x));
                                                [r (r x(1 - x))(1 - r x(1 - x))]

subs gives what I need but I don't know why the other two commands give different results. What bothers me is if I do something similar using the orginal problem, the result is the same as in subs.

bb := [y, y*z-x, -15*x*y-x*z-x]:

eval(bb, [x, y, z]=~[x, y, z]);
                                               [y, y z - x, -15 x y - x z - x]

eval(bb, [x, y, z]=~bb));
                                               [y z - x, (y z - x) (-15 x y - x z - x) - y,-15 y (y z - x) - y (-15 x y - x z - x) - y]

subs([x = bb[1], y = bb[2], z = bb[3]], bb);
                                               [y z - x, (y z - x) (-15 x y - x z - x) - y,-15 y (y z - x) - y (-15 x y - x z - x) - y]

I must be missing something.  

@emendes Please tell me what I am doing wrong.

G := createFunc([r*x(1-x)], [x]);

s1 := G(op([x]));

G(op([x+~T/2*~s1]));

The last command returns something different from r (1-x-1/2 r T (1-x) x) (x+1/2 r T (1-x) x) which is just to plug x+1/2 r T (1-x) x into the place of x in r*x(1-x).   

@John Fredsted  Many thanks.  Nice function.  I completely forgot unapply.

@Carl Love Yes, it is a symbol.  I want to include it as the third arg when calling test2. Is the use of args the right thing to do?  Or can I do something like proc(f,vars,samp) where samp is optional and f and vars are list.  If not given, samp will be T.  Many thanks.

@Kitonum Many thanks.  arg was a typo.   test2 is part of what I need.  Below is a modified version of test2 with f of f.

test2 := proc ()

local f, vars, res;

f := args[1];

vars := args[2];

res := eval(f, [x,y,z]=~vars);

res :=eval(f, [x,y,z]=~(vars+T*~res));

end proc

is that correct?  Is there a more concise way of doing f of f?   How can I add  simplify between the stages of f of f (4 times) ?