Consider the list [x,y,z], say. Does there in Maple exist some fundamental function for querying the position in the list of x,y, and z, respectively? I am unable to locate any such. Such a function can, of course, be constructed, an example being the following:

listPos := (l::list) -> table(zip(`=`,l,[$(1..nops(l))])):
pos := listPos([x,y,z]);
pos[x],
pos[y],
pos[z];

But that seems unsatisfactory. The same question concerning Vectors: Consider Vector([x,y,z]), say. Here, the following code, say, will perform the task:

VectorPos := (V::Vector) -> table([map(rhs = lhs,op(2,V))[]]):
pos := VectorPos(Vector([x,y,z]));
pos[x],
pos[y],
pos[z];

PS: Of course, list and Vectors can be converted into one another, so any one of the codes above can in practice be used to perform both tasks.

Wanting to edit a post of mine, I accidentally clicked the 'More'-button and chose 'Edit' on anothers post. I immediately saw that it was not my post, and did of course not alter it. But it left me somewhat shocked, for it would seem to imply that anyone can edit (and delete, as well, have just investigated that) anyones post(s). That I think is something that really needs to be remedied as soon as possible.

Consider the following:

conv1 := (x) -> eval(x, tau*f(t) = f(-t)):     # Using eval
conv2 := (x) -> algsubs(tau*f(t) = f(-t),x):   # Using algsubs
expr := Vector([
     tau*f(t),
   I*tau*f(t)
]);
conv1(expr),
conv2(expr);

I would have expected both components of expr to have been transformed, just as they do if algsubs is used, but the second component containing the imaginary unit I as well is not. Why not? Note that if I is replaced by any real number, then the substitution works quite as expected. Why should going from real to complex numbers change things fundamentally?

Additional note: Even though algsubs works above, I would like to avoid using it because the actual system I have contains more than a hundred substitutions to (potentially) be made, and algsubs can only take one at a time, in constrast to eval which in principle can take indefinitely (though finitely, of course) many at a time.

PS: In case the reader is wondering, tau is supposed to be a time reversal operator acting on some time-dependent function f(t).

Consider the following lines:

eqs := {x - a*y,y - a*x};
sol := solve(eqs,y);

In general, sol will be NULL, but if a²=1 then the equations can be solved. How can such side relations be implemented in connection with solving?

PS: The above example is of course a grossly simplified one.

Note added: Perhaps it would be prudent to mention that the variable 'a' above is intended to be a symbolic place holder for some operator acting on some functions x,y, and having square equal to the identity map; it is not simply some algebraic number. The equations should thus be solved for x,y using a²=1, without having assigned anything to 'a' itself. For the simple example above, this can be done using the function eliminate, as suggested by Axel Vogt, but for more complicated cases, its success seems quite unlikely: for one thing, how can one determine, by looking at the set of equations, which variables can or should be eliminated?

The issue Type check of parameters was resolved using the depends modifier. As far as I can tell, this modifier is not allowed for expected or keyword parameters, though. Thus the issue seems to reemerge for these types of parameters. Consider the following test example:

createModule := proc(V::Vector)
   local dim := LinearAlgebra:-Dimension(V);
   module()
      export f,g,h;
      f := proc( x::depends('Vector'(dim))              ) x end proc;
      g := proc( x::expects('Vector'(dim)) := something ) x end proc;
      h := proc({x::        'Vector'(dim)  := something}) x end proc;
   end module
end proc:
createModule(Vector(4)):-f(    Vector(4));
createModule(Vector(4)):-g(    Vector(4));
createModule(Vector(4)):-h(x = Vector(4));

The function f is just a restatement of the already resolved issue, compare the above link, while the functions g and h are for the expected and keyword parameter cases, respectively. The problem remains the same: the variable dim is not evaluated for g and h. What to do? Does there exist a solution equally satisfactory as the one for f?