How to keep private package function private when adding package name to function name inside the package?

Question

I like to call my package private functions using

    mypkg`functionName[...]
  

i.e. add an explicit mypkg to each call. This way when looking at code I know which package the function lives in.

But the problem is that, even though the function is private and has no usage:: statement, Mathematica still exports it and the function can now be seen using ?? on the package and can also be called.

Here is MWE. The function parseODE is private.

BeginPackage["mypkg`"]
dsolve::usage = "mypkg`dsolve ode";

Begin["`Private`"]

dsolve[ode_] := Module[{},
      Print["In mypkg`dsolve"];
      mypkg`parseODE[ode]
   ];

parseODE[ode_] := Print["In mypkg`parseODE"];

End[];

EndPackage[];

But now

?mypkg`*

And the private function can now be seen and called

mypkg`parseODE[ode]
(*In mypkg`parseODE *)

Changing the code of the package to be like this (have to restart kernel also)

BeginPackage["mypkg`"]
dsolve::usage="mypkg`dsolve ode";

Begin["`Private`"]

dsolve[ode_]:=Module[{},
   Print["In mypkg`dsolve"];
   parseODE[ode] (*removed package name from call*)
];

parseODE[ode_]:=Print["In mypkg`parseODE"];

End[];

EndPackage[];

Now the private function parseODE do not show and can't be called

How to add package name in the call, inside my package, without having each function being exported as a result? This makes it very hard to write large code for me, as I always like to add package name to each call of function. I do this in Maple all the time with no problem. I'd like to do the same in Mathematica.

V 14

Update and workaround

I found that by calling the private function from inside the package using

 mypkg`Private`parseODE[ode]

Instead of

 mypkg`parseODE[ode]

Then it does not export it.

So I will use this as workaround. This make it little longer to type, but that is OK. I am still not sure why using mypkg`parseODE[ode] caused the function to be exported. It looks like this is just how packages work in Mathematica? but this is not common in other languages.

So now the code looks like this

BeginPackage["mypkg`"]
dsolve::usage = "mypkg`dsolve ode";

Begin["`Private`"]

dsolve[ode_] := Module[{},
      Print["In mypkg`dsolve"];
      mypkg`Private`parseODE[ode]
   ];

parseODE[ode_] := Print["In mypkg`parseODE"];

End[];

EndPackage[];

And

Answer 1

Extend my comment to an answer.

I am still not sure why using mypkg`parseODE[ode] caused the function to be exported. It looks like this is just how packages work in Mathematica?

Yeah it's the design. By writing mypkg`parseODE[ode] explicitly, you'll create the symbol parseODE under the mypkg` context, but the context mypkg` is not private because it's created by BeginPackage["mypkg`"] so it's added to $ContextPath. In this example, the private context (to be precise, the context that hasn't been added to $ContextPath) is mypkg`Private` context created by the line Begin["`Private`"].

This make it little longer to type…

The new-in-13.0 $ContextAliases may help you. Possible usage:

BeginPackage["mypkg`"];
dsolve::usage = "mypkg`dsolve ode";

Begin["`Private`"];

$ContextAliases["mypkgP`"] = "mypkg`Private`";

dsolve[ode_] := Module[{}, Print["In mypkg`dsolve"];
   mypkgP`parseODE[ode]];

parseODE[ode_] := Print["In mypkg`parseODE"];

End[];

EndPackage[];

We may even define

$ContextAliases["mypkg`"] = "mypkg`Private`";

in the package. This will hijack the mypkg` in the package temporally and cause some warning, but should not be a problem as long as we know what we're doing.

Answer 2

This is how I do it. There's no need to use full context names:

BeginPackage["mypkg`"];
dsolve::usage = "mypkg`dsolve ode";

Begin["`Private`"]; (* Sets the context. All new symbols will
                       be created in the mypkg`Private` context.
                       All such symbols, such as  parseODE, will
                       automatically refer to mypkg`Private`parseODE.
                    *)

dsolve[ode_] := Module[{},
   Print["In ", Context[dsolve], SymbolName[dsolve]];
   parseODE[ode]];

parseODE[ode_] := 
  Print["In ", Context[parseODE], SymbolName[parseODE]];

End[];

EndPackage[];

Example:

dsolve["ode"]

In mypkg`dsolve

In mypkg`Private`parseODE

Names["mypkg`*"]

(*  {"dsolve"}  *)

As long as all calls to parseODE occur before End[], they will refer to mypkg`Private`parseODE.