How can I return private members of a Mathematica package as the output of package functions without the "PackageName`Private`" prefix?

Question

I have created a Mathematica package that manipulates various types of input physics data into a common form of output data for further analysis. To make this process more efficient and manageable, I assign each specific set of data a different head and define the manipulation functions differently (as necessary) for each of the various heads. For example,

getX[data_AA] := data[[1]];
getY[data_AA] := data[[2]];
getZ[data_AA] := data[[3]];
getR[data_AA] := Module[{x=getX[data],y=getY[data]},Return[x^2+y^2]]
...and so on...

getR[data_BB] := data[[1]];
getPhi[data_BB] := data[[2]];
getX[data_BB] := Module[{r=getR[data],phi=getPhi[data]},Return[r*Cos[phi]]]
...and so on...

getX[data_CC] := data[[5]];
...and so on...

Accordingly, I have written functions that change the heads of the data from List (since the data are imported from files into arrays) to their respective heads so that the data can then be used as arguments in the manipulation functions like the examples above: for example,

makeAA[AAdata_] := Return[AAdata /. List -> AA]

Because I want this to all be done internally, so that one cannot simply initialize a random object in a notebook with a global head of AA and then use the manipulation functions on that arbitrarily created object (see Note below), I have made the heads private members of the module. If the data is returned, however, by the function, say,

getAAdata[filename_]

then it is displayed as

PackageName`Private`AA[PackageName`Private`AA[particle 1 data],PackageName`Private`AA[particle 2 data],...,PackageName`Private`AA[particle N data]]

instead of the more concise and, therefore, more desirable

AA[AA[particle 1 data],AA[particle 2 data],...,AA[particle N data]]

(this is especially a problem when dealing with further nested arrays).

So the question is: how can I get private objects (heads, variables, etc.) to display in outputted data without the cumbersome and cluttering "PackageName`Private`" prefix?

Note: it is not sufficient to list the heads in the public part of the package because then, even though it would solve the above problem, it would introduce an additional problem that one would be able to initialize arbitrary objects with those heads -- say, test=AA[2.1,3.2,5.4,2.3] -- and then call getX[test], which will then carry out the evaluation as it would any object with head AA. I want to reserve creating objects with those heads to other functions in the package (such as makeAA; see above).

---

This problem also shows up if I don't explicitly write a usage description/tag for a function and try to get information on the function by doing

?Function

-- all the arguments and local variables are written with the "PackageName`Private`" prefix, making it rather difficult to read the body of the function.

Thank you very much for your help!

Answer 1

A more object-oriented approach may be helpful here. For example:

BeginPackage["example`"];
thing;
new;
Begin["`Private`"];
thing /: new[thing[contents_]] :=
  Module[{thing},
   (* Supported operations: *)
   thing /: Plus[thing[x_], y_] := thing[x + y];
   thing /: Times[thing[x_], y_] := thing[x y];
   (* Example invalid operation: *)
   thing /: Power[_thing, _] := $Failed;
   (* Format value: *)
   thing /: MakeBoxes[thing, StandardForm] = InterpretationBox["thing", thing];
   (* Return symbol: *)
   thing[contents]
  ];
End[];
EndPackage[];

Now we can write, e.g,

myThing = new@thing[73];
4 myThing + 3

which gives:

thing[295] (* == thing[4 * 73 + 3] *)

However, despite the standard form (which can also be copied and pasted from output to input thanks to the InterpretationBox), the internal representation is quite different:

% // InputForm
(* -> thing$576[295] *)

As a result we can't just conjure things up without invoking new, as the methods defined on real things simply won't exist in that case:

myNewThing = thing[48];
myNewThing + 17
(* 17 + thing[48] *)

Strictly speaking, the format value would have been enough to answer your question as stated. However, it seems like an object oriented approach is quite a natural fit for what you're probably trying to achieve here, so the extra effort may be worthwhile for maintainability and robustness reasons if you intend to have a lot of different objects each with their own private methods and/or internal state.

Answer 2

Try this:

Begin["PackageName`Private`"];
?`*
End[];

which puts you in the private context when you execute ?`*. Also, note the grave mark (`) in ?`*, it ensures that the wildcard (*) is only applied to the current context not your entire $ContextPath. Incidentally, this is the same reason that Private in Begin["`Private`"] is also preceded by a grave mark, it ensures that it is a sub-context of the package context.

---

The simplest way, though, is simply to type

?PackageName`Private`*

which will not display the context path of the variables.

Answer 3

The only way to call a function/variable in a package without using the full context is to make it public, which is typically done with usage messages immediately after the BeginPackage["Package`"] and before Begin["Private`"].

To me, it seems like you just want to be able to view the definitions, etc. without it looking messy with all the context information. To do that, here's a simple way to add a definition to, uhm, Definition that does this. Include this in your package:

Unprotect@Definition;
Definition[x_Symbol] /; StringMatchQ[Context[x], "Package`" ~~ ___] := 
    StringReplace[ToString@FullDefinition[x], 
        (WordCharacter .. ~~ DigitCharacter ... ~~ "`") .. ~~ s_ :> s
    ];
Protect@Definition;

Now, all functions in your package will not have the full context displayed when you call ?foo. Note that it is not really Definition, as I'm using FullDefinition, which also gives you the definitions of all symbols foo depends on. This is only for convenience sake, so that you can still use ?. If you strictly want only Definition, create a function myDefinition instead (otherwise you'll end up with a recursion) that uses the above example with Definition instead of FullDefinition (I didn't want to mess with the parsing of ? since it's also used in pattern tests and could break a lot of things subtly).

Here's an example of it at work:

In the above code, I strip away all context information. If you want to strip only Package`Private`, then you can modify the StringReplace part accordingly.