Mutual package imports in Mathematica

*To*: mathgroup at smc.vnet.net*Subject*: [mg112564] Mutual package imports in Mathematica*From*: Leonid Shifrin <lshifr at gmail.com>*Date*: Mon, 20 Sep 2010 05:42:50 -0400 (EDT)

Hello group, This post is about mutual package imports. I encountered such a situation which led to certain (surmountable) difficulties in my work. I looked up on the group's archive and did not find anything on the topic (may be I was not looking long enough), so after I solved my problem, I decided to post my findings below in the hope that they may be of some help to others getting into the same situation. If this is a repetition of some well-known common wisdom, my apologies. Suppose you have two packages, the main one, and the helper one. The main one needs some of the functionality of the helper one, and you want to keep the context of the helper package on the context path after the main one loads. But, here is the problem: the helper one also needs some of the functionality of the main one. Such situation may be preferable for better designs in some rare cases. So, here is a naive attempt: (* Main package *) BeginPackage["MyMainPackage`",{"MyHelperPackage`"}] Fun1::usage="Fun1[x_] squares its argument"; Fun2::usage= "Fun2[x_] computes a square root of its argument"; Fun3::usage = "Fun3[x_,y_] is a more complex function"; Begin["`Private`"] (*Needs["MyHelperPackage`"];*) Fun1[x_]:=x^2; Fun2[x_]:=Sqrt[x] Fun3[x_,y_]:=(x+y)*HFun1[x,y]; End[] EndPackage[] (* Helper package *) BeginPackage["MyHelperPackage`"] HFun1::usage="This is a helper function"; Begin["`Private`"]; Needs["MyMainPackage`"]; HFun1[x_,y_]:=Fun1[x]+Fun2[y] End[] EndPackage[] Everything looks fine, so the function HFun1 ought to use functions Fun1 and Fun2 from the main package (this was what I was thinking anyway)). Now we try to use this: In[37]:= Needs["MyMainPackage`"] In[38]:= HFun1[1, 2] Out[38]= MyHelperPackage`Private`Fun1[1] + MyHelperPackage`Private`Fun2[2] In[39]:= Fun3[1, 2] Out[39]= 3 (MyHelperPackage`Private`Fun1[1] + MyHelperPackage`Private`Fun2[2]) Alas, this did not happen. The point is that the package MyHelperPackage` is read before those definitions in the main package (because listing in in a list of dependent packages in BeginPackage["MyMainPackage`",...] causes Needs to be called on MyHelperPackage` before even the public part of the main package is read, and therefore, while the context "MyMainPackage`" *is* on the contextpath of MyHelperPackage` when the latter is read, the function names are not yet there in that context and could not be found. Therefore, MyHelperPackage` made up its own private names for Fun1 and Fun2, which is obviously what we don't want. Solution: 1. If we don't need the context of the helper package to remain on the contextpath after the main package gets loaded, then there is no problem at all - import the helper package privately. In that case, the public portion of the main package with all public functions is read first, and this those names are already there by the time the helper package is loaded. Of course, the helper package must still import the main one (hidden import say). In code, this will now look like: BeginPackage["MyMainPackage`"] Fun1::usage="Fun1[x_] squares its argument"; Fun2::usage= "Fun2[x_] computes a square root of its argument"; Fun3::usage = "Fun3[x_,y_] is a more complex function"; Begin["`Private`"] Needs["MyHelperPackage`"]; Fun1[x_]:=x^2; Fun2[x_]:=Sqrt[x] Fun3[x_,y_]:=(x+y)*HFun1[x,y]; End[] EndPackage[] Now we can check: In[44]:= Needs["MyMainPackage`"] In[45]:= HFun1[1, 2] Out[45]= HFun1[1, 2] In[46]:= Fun3[1, 2] Out[46]= 3 (1 + Sqrt[2]) We see that the problem has been solved in part, but that the helper context is then still unavailable: the HFun1[1, 2] evaluates to itself. 2. If we do need to leave the helper package on the context path (as in our example), this can be accomplished by the following trick: add lines BeginPackage["MyMainPackage`",{"MyHelperPackage`"}] EndPackage[] to the end of your main package, which in its final form will look like: BeginPackage["MyMainPackage`"] Fun1::usage="Fun1[x_] squares its argument"; Fun2::usage= "Fun2[x_] computes a square root of its argument"; Fun3::usage = "Fun3[x_,y_] is a more complex function"; Begin["`Private`"] Needs["MyHelperPackage`"]; Fun1[x_]:=x^2; Fun2[x_]:=Sqrt[x] Fun3[x_,y_]:=(x+y)*HFun1[x,y]; End[] EndPackage[] BeginPackage["MyMainPackage`",{"MyHelperPackage`"}] EndPackage[] In this case, starting with a fresh kernel, everything works as planned: In[53]:= Needs["MyMainPackage`"] In[54]:= HFun1[1, 2] Out[54]= 1 + Sqrt[2] In[55]:= Fun3[1, 2] Out[55]= 3 (1 + Sqrt[2]) Now, one may argue that mutual imports may reflect bad design, but IMO they can, very occasionally, be quite handy and lead to actually better designs. In any case, this is another possibility, whether or not to use it is a different issue. I hope that I don't waste everyone's time and bandwidth, and that someone will find this useful or perhaps adds something I missed. Regards, Leonid