Garbage collection in Maple is automatic. Your program runs, intermediate objects are created, and then when objects are no longer referenced their memory is collected to be reused by the system. For example, when you do the following:
f := x+1;
f := f+1;

Maple creates the object x+1 in memory, then it creates a new object (x+1)+1 = x+2 in memory, and since the original object is no longer referenced x+1 may be garbage collected. However, there is a catch. Garbage collection in Maple is "generational", which means that memory may not be recovered inside of a large complex routine until the routine terminates. One solution is to make a subroutine to perform a memory intensive part of the computation. For example, make a new procedure which executes 10 iterations of your loop. To avoid passing too many arguments, you can use lexical scoping. For example:

foo := proc(x)
local f, c, bar;
  f := x;
  c := 1;

  bar := proc(f1)
  local f;
    f := f1;
    to 10 do
      f := f+c;
    end do;
    return f;
  end proc;

   to 10 do
      f := bar(f);
   end do;
end proc;

This is a slightly long example so bear with me. The subroutine bar executes 10 iterations of f := f+c; The variable c is from foo, it is lexically scoped into bar. This way you can avoid passing a lot of variables around. We execute f := f+c; 100 times and create 100 intermediate objects, but 90% of them are created in bar and these can be garbage collected after each call to bar terminates. 10% of them are in foo and can not be garbage collected until after foo terminates.

This may or may not solve your memory problem. It may be that the objects themselves are too large. But if it helps, there it is.