How to store symbols in a package without being parsed?

Question

I have a package file myPackage.m with the following content:

BeginPackage["myPackage`"];
load[] := {a, b, c};
EndPackage[];

When Needs is called, and the file is parsed, all the symbols in the package immediately appear in the myPackage` namespace, regardless of whether load was called or not:

Needs["myPackage`"];
Names["myPackage`*"]

{"a", "b", "c", "load"}

Is there an elegant, domestic way to only parse symbols into the given context (myPackage` in this case) when the function that includes them is called and not at parse-time? No amount of HoldComplete, Unevaluated, etc. works. I rather avoid storing the rhs (or the symbols directly) of load as a string, ToExpression-ing it only at runtime.

The only option I can think of is to have load[]:=Get["load.m"] and then store the actual definition in load.m, but this is cumbersome if one has many different functions, like load1, load2, etc., because then each definition has to be stored in a different file. Is there a clever way of playing with contexts to overcome this challange?

The reason behind is that I have to store a large amount of equation-systems (say hundreds), each with a specific name and variables, and I want them (and their variables) to be available only if they are explicitly called for by name. Thus if I call load["eq12"], I expect that the symbols of "eq12" (but only its symbols) appear in the namespace. If then I call load["eq35"], its symbols are added to the namespace too. Also, I don't want the equation variables to appear as myPackage`private`x, so I try not to define the equations in a private` subcontext.

One can use the formal symbols of the System` context (like \[FormalX], which are already loaded to the context), but then the set of variables is limited to be single character-variables.

Answer 1

There seems to be no way to fool the parsing, so you will either have to store the symbols in a separate file, or use some form of ToExpression.

What I would suggest is to use a softer version of ToExpression, and represent the r.h.s. as boxes rather than as a string. Here is what I mean:

BeginPackage["myPackage`"];

load;
boxed;
$context = $Context;
$contextPath = $ContextPath;

Begin["`Private`"];

boxed /: SetDelayed[lhs_, boxed[rhs_]] :=
  With[{boxedrhs = MakeBoxes[rhs]},
    lhs := Block[{$Context = $context, $ContextPath = $contextPath},
       ToExpression[boxedrhs]
    ]
  ]; 

Begin["`Temp`"]

load[] := boxed[{a, b, c}];

End[]
End[]
EndPackage[]; 

The symbols will still be created during parsing, but they will go into the `Private`Temp` context. If you want, you can remove them, adding a line like Remove["`Private`Temp`*"] at the end of the package.

The rhs of load is then converted to boxes. When load is called, the symbols get parsed with the same environment ($Context, $ContextPath), as if they would've been parsed inside the package normally.

Answer 2

You could store symbols related to separate equation systems in separate contexts. This way you could add/remove those additional contexts, to/from $ContextPath, at will.

How to automate assigning of appropriate symbols to appropriate contexts depends on how exactly you're defining your equation systems. You could for example post-process definition of your load function and change context of all symbols from myPackage`Private` context found in DownValues[load].

BeginPackage["myPackage`"];
Unprotect["`*"];
Remove@Evaluate[# <> "*"] & /@ $contexts;
ClearAll["`*"]

load;
unload;
$contexts;

Begin["`Private`"];
ClearAll["`*"]

load["eq12"] := {a, b, c};
load["eq35"] := {x, y, z};

$contexts = {};

Module[{tag},
    $contexts = Join @@ Last@Reap[
        DownValues[load] = DownValues[load] /. (
            lhs : Verbatim[HoldPattern]@HoldPattern@load[eqName_String] :>
                rhs_
        ) :>
            With[{context = "myPackage`" <> eqName <> "`"},
                Sow[context, tag];
                (lhs :> (
                    If[! MemberQ[$ContextPath, context], 
                        PrependTo[$ContextPath, context]
                    ];
                    rhs
                )) /.
                    sym_Symbol /; Context[sym] === "myPackage`Private`" :>
                        RuleCondition@Symbol[
                            context <> SymbolName@Unevaluated[sym]
                        ]
            ]
        ,
        tag
    ]
];

unload[eqName_String] :=
    With[{context = "myPackage`" <> eqName <> "`"},
        ($ContextPath = DeleteCases[$ContextPath, context]) /; 
            MemberQ[$contexts, context]
    ]

End[];
EndPackage[];
$ContextPath = DeleteCases[$ContextPath, Alternatives @@ $contexts];

myPackage` context contains only package public symbols:

Names["myPackage`*"]
(* {"load", "unload", "$contexts"} *)

symbols related to specific equation systems are in separate contexts:

Names[# <> "*"] & /@ $contexts
(* {
    {"myPackage`eq12`a", "myPackage`eq12`b", "myPackage`eq12`c"},
    {"myPackage`eq35`x", "myPackage`eq35`y", "myPackage`eq35`z"}
} *)

which are not in $ContextPath:

$ContextPath
(* {"myPackage`", "CloudObjectLoader`", "StreamingLoader`",
    "IconizeLoader`", "PacletManager`", "System`", "Global`"} *)

After loading equation system:

load["eq12"]
(* {a, b, c} *)

appropriate context is added to $ContextPath:

$ContextPath
(* {"myPackage`eq12`", "myPackage`", "CloudObjectLoader`", "StreamingLoader`",
    "IconizeLoader`", "PacletManager`", "System`", "Global`"} *)

and appropriate variables are identified with contexts of appropriate equation systems:

Context[a]
(* "myPackage`eq12`" *)

After unloading of equation system its context is removed from $ContextPath:

unload["eq12"]
(* {"myPackage`", "CloudObjectLoader`", "StreamingLoader`",
    "IconizeLoader`", "PacletManager`", "System`", "Global`"} *)