is there a way  for a proc() in a parent module to call an exported proc in a child module, without having to use long form of the call    child:-child_proc() and just do child_proc()?  Here is an example

A:=module()
  option package;
  export foo;
  local B; #child module

  B:=module()     
     export boo;
     boo:=proc()
        print("in B:-boo()");
     end proc;
  end module;
  
  foo:=proc()
     B:-boo();  #how can one just type  boo() here?
  end proc;
end module;

B:-foo(); now works ok. But I'd like to just use  boo() and not B:-boo() since the name of the child module is too long. 

I can't figure how to do it. I can't use with(B) in the parent, Maple complains. 

When a child proc calls a parent local proc using parent_module:-parent_proc(), Maple gives an error. But when the child calls the parent local proc using just parent_proc() it works. Why is that?

parent_module:=module()
 
 local child_module;
 local parent_proc;

 export parent_entry;

 child_module:= module()
    export child_entry; 
    child_entry :=proc()
     #parent_module:-parent_proc(); #this fails
     parent_proc(); #this works
    end proc;
  end module;

 #local
 parent_proc :=proc()
   print("insider parent proc");
 end proc;

 #public
 parent_entry :=proc()
   child_module:-child_entry();
 end proc;
end module;

parent_module:-parent_entry();
              "insider parent proc"

but the other way, (the commented code above) gives

parent_module:-parent_entry();
Error, (in child_entry) module does not export `parent_proc`

my main module is getting big. I want to break it to main module, and submodule. But now everything is in the same .mpl file. I'd like to put the sub module in seperate mpl file. I do not know the syntax to do this and how to do it. I looked at the programming guide chapter 8.

Currently in main_module.mpl, lets say I have this

main_module:=module()
 option package;
 local C; 
 local sub_module;
 export main_entry;

 C:=99; #see if this can be "seen" from child module

 sub_module:= module()
    export main_entry;
    main_entry :=proc()
     print("In main_module:-sub_module:-main_entry(), C=",C):
    end proc;
  end module;
 
 main_entry :=proc()
   print("in main_module:-main_entry()"):
   sub_module:-main_entry();
 end proc;
end module;

Now main_module:-main_entry(); gives

                 "in main_module:-main_entry()"
       "In main_module:-sub_module:-main_entry(), C=", 99

I'd like to move the code of the submodule to another .mpl file. So I end up with two files, like this

# main_module.mpl
main_module:=module()
 option package;
 local C; 
 local sub_module;
 export main_entry;

 C:=99; #see if this can be "seen" from child module

 main_entry :=proc()
   print("in main_module:-main_entry()"):
   sub_module:-main_entry();
 end proc;
end module;

And

#sub_module.mpl
sub_module:= module()
    export main_entry;
    main_entry :=proc()
     print("In main_module:-sub_module:-main_entry(), C=",C):
    end proc;
 end module;

But when I do this, I can't call main_module:-main_entry(); since it gives error

Error, (in main_entry) `sub_module` does not evaluate to a module
I do not want to make sub_module a separate package. I want it to remain a sub module for the main module, so it can only be seen by the main module and no one else.

So logically sub_module is a child of main_module, but physically I want to put them in separate files to make it easier to modify.

I use plain text files for everything and use Maple to load the packages and test.

How does one go about doing this? How would this be done for the above example?

I tried $include "sub_module.mpl"; but it gives error.

main_module:=module()
 option package;
 local C; 
 local sub_module;
 export main_entry;

 C:=99; #see if this can be "seen" from child module
	
 $include "sub_module.mpl";

 main_entry :=proc()
   print("in main_module:-main_entry()"):
   sub_module:-main_entry();
 end proc;
end module;

Where the file "sub_module.mpl" contains the code for the submodule I want to insert at that location. When I read "main_module.mpl" Maple gives error

read "main_module.mpl";

Error, on line 10, syntax error, unexpected string:
 $include "sub_module.mpl";

This is too advanced for me. I am still learning module and package use in Maple.

thanks

What is the best way to check if solve returned one or more solution? Currently I check if the returned sol is of type exprseq, and if so, I put the result in a list. If the sol is not of type exprseq, then I know only one solution is returned. Here is an example

foo:=proc(eq,x)
  local sol;
  sol:=solve(eq,x);
  if whattype(sol)='exprseq' then
     sol:=[sol];
  fi;
  return(sol);
end proc:

And now

Is there better way to do this?

Maple does not have a GOTO. I do ?goto and nothing comes up (I thought it did at one point, but it seems to be gone). I also saw 

99052-How-To-Write-Procedures-That-Use-Go-To-In-Maple

GOTO is considered bad, and I agree in general. But there ONE very good use for GOTO which can't be easily replaced, which is having a common exit label. (at one work place sometime ago, this was actually the only recommened use for it in the programming guidelines. and I agree.)

Without this, one ends up with deep if then else if then else if then else., etc....

But having a common exit, where one can do common clean up things is very good. This reduced code duplication and actually makes the logic more clear.

Here is just some silly example to  illustrate

foo:=proc(x)
  if x=10 then
     .....
    close file, print common message
    return(final_result);
  fi;

  if x=12 then
     .....
    close file, print common message
    return(final_result);
  fi;

 etc...

end proc;

With common exit point, one could do

foo:=proc(x)
   if x=10 then 
      .....
     final_result :=...
     goto common_exit;
   fi;

   if x=12 then 
      .....
     final_result :=...
     goto common_exit;
   fi;

common_exit:
   close file; 
   print common message;
   return(final_result);

end proc;

The alternative is to have deep  nested if then else, like this

foo:=proc(x)
    if x=10 then 
       ..... 
       final_result :=...;
    else
         if x=12 then 
            ..... 
            final_result :=...;
         else
             if x= 20 then
                .....
                final_result :=...;
             fi;
         fi;
   fi;

  close file; 
  print common message;
 return(final_result);
end proc;

For complicated logic, I do not think the last case is better than the second one using GOTO.

The second case also eliminates duplicate code as was done in first case. Also first case has multiple return points from the proc, which is not good. As having one common return point is better.

Why was goto removed from Maple? Can one still use it somehow? Where is the documenation for it?

update

goto seems to be there. I did not think of trying, since ?goto did not show it. But now I found I could do this and it works

foo:=proc()
  local x;
  x:=10;
  goto(common_exit);
  x:=20;
common_exit:
  print(x);
end proc;

So please Maplesoft., do not remove GOTO.