In Maple 11 we have:

> A := <a,b,c>:
> a := 1:  b := 2: c := 3:
> convert(A, list);
                                   [1, 2, 3]

In Maple 2015 we have:

> A := <a,b,c>:
> a := 1:  b := 2: c := 3:
> convert(A, list);
                                   [a, b, c]

Is that change really intended?

I have a table whose indices and entries are strings, as in:

    T := table(["green" = "gruen", "red" = "rot", "blue" = "blau"]);

Thus, T["green"] evaluates to "gruen" but T["asdf"] evaluates to T"asdf".

What is a good way to detect that "green" is a predefined index into the table but "asdf" is not?  I do it in a somewhat clumsy way, as in:

> has("green", [indices(T, 'nolist')]);
        true

> has("asdf", [indices(T, 'nolist')]);
        false

I suspect that there ought to be a less elaborate way of doing that.

I wish to evaluate the expression

knowing that

where a is a constant.  It is not hard to see, assuming enough differentiability,  that the expression evaluates to

I know how to do this when all the derivatives are expressed in terms of the diff() operator.  Here it is:

eq := diff(u(x,t),t) = a^2*diff(u(x,t),x,x);
expr := diff(u(x,t),t,t);
eval['recurse'](expr,[eq]);

However, I would prefer to do the computations when all derivatives are expressed in terms of the D operator but cannot get that to work.  What is the trick?

Consider

> z := Int(f(t-s), s=0..1);

The result is clearly a function of t (and definitely not a function of s, which is a dummy variable).  Let's define

> F := unapply(z, t);

Then

> F(q);

as expected.  However:

> F(s);

which is not correct, as this confuses the argument s of F with the dummy integration variable s.  How would you salvage the situation?

In the following, the diff operator calcuates the derivative correctly, but the D operator doesn't.  A bug?

Here is a worksheet containing the commands above in case you want to try it yourself: mw.mw