For other curves, use Path(...) instead of Line(...). Type
?PathInt
for examples.

The integrals of P dx + Q dy ...   are line integrals. See
?LineInt

@1valdis 

As I understand (not being a specialist or working in string theory) the link refers to a projection of a higher dimensional manifold into R^3.
Before asking such a question you should provide the wanted projection, i.e. the parametric surface, preferable in Maple notation.

@acer 

Yes, I forgot about it. So, no need to return unevaluated by hand as I did.

@Bachatero 

Maple is not intended (prepared?) for such manipulations.
Just consider:

restart;
fn:=sum(x[i]^2,i=1..n);
f5:=eval(fn,n=5);

diff(fn, x[1]) assuming n::posint;
                               0
diff(f5, x[1]);
                             2 x[1]

[You can't use Maple e.g. in Functional Analysis. Here one needs pen+paper+brain for the moment].

@WilburC 

If f is a procedure (such as f:=sin) then

evalf(Int(f, x=0..1))

is incorrect because actually f has nothing to do with x.
(even if Maple could have been less strict and accept it).

Executing
evalf(Int(f, 0..1))
Maple will call f only with numeric arguments
which is not the case for
evalf(Int(f(x), x=0..1))
where f(x) is evaluated first, x being a symbol, not a numeric.
Your initial g called with a nonnumeric argument will produce an error, that's why it must be "unevaluated".
My previous version returns unevaluated when the argument is nonnumeric, so it needs not being unevaluated..

@WilburC 

Probably you have an older version of Maple.
Search for "premature evaluation" to understand the role of the quotes here.

Here is a version of g which does not need quotes.

g:=proc(a)
local y;
if type(a,numeric) then fsolve(a*y^2-sin(y),y=2)
else 'g'(a) end if;
end proc:

evalf( Int(g(x),x=1..2));

@Bendesarts 

This is certainly possible using directly components (instead of Explore which uses such components internally).
Of course using Explore is easier but a little limited in this case; I would switch to components only if the present simple solution is definitely inacceptable.

@Carl Love 
You mean of course
evalf(Int(x-> h(g(x)), 1..2));

@Bachatero 

It would not be difficult to write a procedure `combine/product`  to transform e.g.

product(a^p[i]*b[i],i=1..n);
into
a^sum(p[i],i=1..n)*product(b[i],i=1..n);
but I am not sure whether it's worth it. Note that actually the second expression is longer.

What has to do ec1 with your question?

@Markiyan Hirnyk 

restart;
Order:=15:
ec:=sin(x+y)+sin(x)-y:
ec0:=simplify(subs(x=z+Pi,ec)):
solve(series(ec0,y),y):
R:=subs(z=x-Pi,%);

   R := -x+Pi+(1/12)*(x-Pi)^3-(1/240)*(x-Pi)^5+(1/10080)*(x-Pi)^7+(17/362880)*(x-Pi)^9-(1153/159667200)*(x-Pi)^11+(13297/24908083200)*(x-Pi)^13+O((x-Pi)^15)

series( sin(x+R)+sin(x)-R, x=Pi ); #check
    O((x-Pi)^15)

@Markiyan Hirnyk 

@Carl Love 

# A simple proc, un-optimized, un-tested that
# should return the RootOfs with multiplicity >= m.
restart;
mindets:=proc(e,m)
local ss,ii,fs;

   fs := proc(u)   
   if nops([StringTools:-SearchAll(convert(u,string),ss)])   
      >=m then true else false
   fi
   end;

ss:=convert(e,string);
ii:=indets(e,RootOf);
select(fs,ii)
end:

e:= 10 + sin(RootOf(a^5-5)+RootOf(a^9-9)+RootOf(c^3-3)+sqrt(RootOf(z^3-3)));
mindets(e,2);

@Carl Love 

This was my first thought too. But sometimes it is better to keep some RootOfs.
Or, make the alias only if they repeat.

Probably the best solution would be an interactive program with suggested sub-expressions to be "covered" and the possibility to use your own names for them.

@Carl Love 

Sorry, I simply forgot to do it, not because I do not appreciate your professional contribution. I really do; and thank you, of course!

V.A.

@Carl Love 

Interesting approach.
It should also consider situations like

eval(g(x),x=2*x);

where it fails.