1

When writing packages I met the following problem. The way I name helper functions is like

BeginPackage["test`"];
ClearAll@@Names[$Context<>"*"];

test0[]:=0;
test0helper1[]:=0; test0helper2[]:=0;
...


EndPackage[];

When Get["test`"] the public symbols under test` will be cleared by ClearAll@@Names[$Context<>"*"]; but the symbols under test0` are remained unchanged.

I need a fast way of searching and clearing all symbols under the contexts like symbol`*, where symbols are from some specific contexts.

To set up and test the problem, the following codes generate 10 symbols for each of the 200 sub-contexts:

BeginPackage["test`"];

ToExpression["
    test"<>#1<>"[]=0;
    test"<>#1<>"`a"<>#2<>"[]=0;
"]&@@@Flatten[
    Outer[List,ToString/@Range[200],ToString/@Range[10]],
    1
];


EndPackage[];

Names["test`*"]//Shallow
Names["test1`*"]
Names["test2`*"]

enter image description here

The direct way of clearing these helper functions is like

clearHelper[contexts__] :=
    (
        {contexts}//Map[Names[#<>"*"]&]//
            Map[ClearAll@Evaluate[#<>"`*",#<>"`*`*"]&,#,{2}]&;
    );

which is rather inefficient

test1`a1[]
clearHelper["test`"]//Timing
test1`a1[]

enter image description here

In some days earlier I used another method of managing helper functions: each symbol with helper functions is tagged by

test0//hasHelpers

where hasHelpers will store test0 into a public list $hasHelpers shared by all packages. Then I abandoned this method since frequently appending symbols to list will slow down Get and I'm tired of adding test0//hasHelpers.

Is there some clever way of solving this problem?

Or are there editors or IDEs that can auto-complete contexts? e.g. symbols like test0`helper1[] within BeginPackage["test`"] or Begin["`Private`"] will be parsed into *.wl as

test`test0`helper1[]

automatically?

Lacia
  • 2,253
  • 3
  • 19
  • 2
    Is Names["test*`*"] adequate? That syntax is also supported by Clear and Remove. – WReach Oct 27 '22 at 03:39
  • @WReach No, the symbols in a package test` are certainly not fitted into test*`*. A feature I forgot to say is that the association from symbols like testn to the contexts testn` can be quite sparse since only a few functions need helper functions. And the naive inefficient function clearHelper just traverses this association one by one. – Lacia Oct 27 '22 at 03:51
  • Maybe you dismissed the first comment too quickly? With Names["test*`*"] I get {test0`helper1, test0`helper2, test0}. Note the last one, test0, which is in the test` context. – user293787 Oct 27 '22 at 06:17
  • 3
    Is there a reason why you don't want to follow the standard way: BeginPackage["Test\"]; test0; Begin["`Private`"] test0[]:=helper1[] ... .... End[]; EndPackage[]. Then you could just doClearAll["`", "``*"]and still onlytest0` is exported from the package. – Kuba Oct 27 '22 at 06:48
  • @user293787 the functions in test` are not named as test0 in REAL examples. – Lacia Oct 28 '22 at 00:44
  • @Kuba I don't know which style is "standard". For example there are systems symbols like System`SparseArray with lots of SparseArray`*. I prefer to name helper1 as test`test0`helper0 or test`private`test0`helper0 so that the names of helper functions for different public functions will not be conflict. But test`test0`helper0 is too lengthy and then I choose test0`helper0. – Lacia Oct 28 '22 at 00:49
  • @Kuba For example, if two public functions f1 and f2 call the same private function helper0, I prefer to make them decoupled: f1 calls f1`helper0 and f2 calls f2`helper0. – Lacia Oct 28 '22 at 00:52

2 Answers2

3

Start with what is a package.

Then you can do

ClearAll["`*`", "`*`*"]

"`*" is a shorthand for $Context<>"*" and "`*`*" will find even 'deeper' symbols like test1`a`b`c`foo

Related: 189660

If you insist on a private context specific to an exported function then the final code can be:

BeginPackage["Test`"]

ClearAll["*&quot;,&quot;`"]


test0::usage = ""
  test1::usage = ""


Begin["test0"]


test0[]:= helper01[];


helper01[]:=0;


End[]


Begin["test1"]


test1[]:= helper11[];


helper11[]:=2;


End[]


EndPackage[]

test0[]
test1[]

0 2

Notice that you could have helper01 and helper11 called both helper and it would work just fine because they are created in different contexts:

DownValues@test0

{HoldPattern[test0[]] :> Test`test0`helper01[]}

But I don't think this is a good idea because it could be confusing to have the same name within a single file.

Kuba
  • 136,707
  • 13
  • 279
  • 740
1

For now I have changed the code styles, roughly following from https://github.com/WolframResearch/PacletCICD-Examples-AdvancedSample

For the original problem, the following function is faster

clearHelperFunction[contexts__,level_Integer:1] :=
    Module[ {helperList,helperContextList},
        helperContextList =
            Quiet[NestList[#<>"`*"&,#<>"`*",level-1],{StringJoin::string}]/.{all_:>Hold[all&]}//ReleaseHold;
        helperList =
            {contexts}//Map[Names[#<>"*"]&]//Map[helperContextList,#,{2}]&//Flatten;
        helperList = 
            DeleteCases[helperList,Alternatives@@`clearHelper`exceptionList];
        ClearAll@@helperList
    ];
clearHelperFunction[] :=
    StringCases[$ContextPath,StartOfString~~selfContext~~___]//Flatten//Apply[clearHelperFunction];
`clearHelper`exceptionList = {
    "FE`*"
};

enter image description here

There are quite tricky issues concerning Names, ClearAll, ..., e.g.

SeedRandom[1]

data=RandomWord[100];


data//Map[ClearAll]//Quiet//RepeatedTiming//First
data//Apply[ClearAll]//Quiet//RepeatedTiming//First

enter image description here

see also Why Names will search all subcontexts?

I'd also like to compare the different code editors and styles I have tried.

Editors

  • notebook, inconvenient for multi-file project;
  • vscode + Wolfram extension, the formatting functionality is a bit weird;
  • eclipse + Wolfram workbench, outdated, e.g. do not support |-> and non-English characters

Currently I use the last one.

Style

  • main function foo with helper functions foo`h1, foo`h2, ... - the approach in this question. This is really bad but the drawbacks can be cured:

    • symbols can collide. There can be different versions of foo, then the helpers collide.

    • hard to manage.

    • Solution: use $ContextAliases to resolve the context foo` to package`foo`Private`. But, it seems that in version 13.3 $ContextAliases is quite slow.

  • main function foo with helper functions `foo`h1, `foo`h2, .... This could be the most convenient approach. Drawback:

    • Wolfram workbench does not support renaming symbols starting from backtick like `foo`h1

  • multiple subcontext in single file by Begin, End. As pointed by @kuba, this can cause confusion and is hard to rename.

  • single subcontext for each file, see e.g. https://mathematica.stackexchange.com/a/176591/86893 https://github.com/WolframResearch/PacletCICD-Examples-AdvancedSample. This could be the best approach without undocumented functionalities or third-party paclets. see also another style What to be aware when using new-style package?

Lacia
  • 2,253
  • 3
  • 19