What is the accessibility of a package's `Private` context variables? Planned maintenance scheduled April 17/18, 2019 at 00:00UTC (8:00pm US/Eastern) Announcing the arrival of Valued Associate #679: Cesar Manara Unicorn Meta Zoo #1: Why another podcast?How symbol lookup actually worksWhat are recommended guidelines for developing packages?How to properly handle mutual imports of multiple packages?How can Private functions be made completely opaque?Does one need to be careful about loading multiple (many) contexts or packages in the same session?WebServices context problemHow to pass rules to packagesA question regarding shadowed symbolsIs there any harm or benefit to Removing unneeded private symbols in packages?Information (??) of function defined in Package return the function with long name of variablesHow to resolve a context shadow problem (revised)

Two different pronunciation of "понял"

How to politely respond to generic emails requesting a PhD/job in my lab? Without wasting too much time

How is simplicity better than precision and clarity in prose?

Writing Thesis: Copying from published papers

How do I automatically answer y in bash script?

Is there a documented rationale why the House Ways and Means chairman can demand tax info?

How can I make names more distinctive without making them longer?

Why don't the Weasley twins use magic outside of school if the Trace can only find the location of spells cast?

If I can make up priors, why can't I make up posteriors?

Stars Make Stars

When communicating altitude with a '9' in it, should it be pronounced "nine hundred" or "niner hundred"?

Keep going mode for require-package

Using "nakedly" instead of "with nothing on"

Stop battery usage [Ubuntu 18]

Are my PIs rude or am I just being too sensitive?

What did Darwin mean by 'squib' here?

Why does this iterative way of solving of equation work?

What's the difference between (size_t)-1 and ~0?

Area of a 2D convex hull

Why is there no army of Iron-Mans in the MCU?

Notation for two qubit composite product state

How should I respond to a player wanting to catch a sword between their hands?

Slither Like a Snake

3 doors, three guards, one stone



What is the accessibility of a package's `Private` context variables?



Planned maintenance scheduled April 17/18, 2019 at 00:00UTC (8:00pm US/Eastern)
Announcing the arrival of Valued Associate #679: Cesar Manara
Unicorn Meta Zoo #1: Why another podcast?How symbol lookup actually worksWhat are recommended guidelines for developing packages?How to properly handle mutual imports of multiple packages?How can Private functions be made completely opaque?Does one need to be careful about loading multiple (many) contexts or packages in the same session?WebServices context problemHow to pass rules to packagesA question regarding shadowed symbolsIs there any harm or benefit to Removing unneeded private symbols in packages?Information (??) of function defined in Package return the function with long name of variablesHow to resolve a context shadow problem (revised)










10












$begingroup$


I've been reading up on how Mathematica handles contexts, $Context, $ContextPath, and a few of the tutorials they have on Packages.



What I'm wondering about is how the functions defined in, say, CustomPackage` are able to access the variables in CustomPackage`Private`.



For example,



BeginPackage["CustomPackage`"]

MyFunction::usage = "MyFunction[arg1] adds 5 to arg1."

Begin["`Private`"]

abc=5;
MyFunction[arg1_] := arg1 + abc;

End[]
EndPackage[]


When I load the package <<CustomPackage` the $ContextPath will have CustomPackage` on it, but not CustomPackage`Private`



So how does MyFunction know the value of abc at the delayed function call (when it is called) if the Private` context isn't on the $ContextPath










share|improve this question











$endgroup$
















    10












    $begingroup$


    I've been reading up on how Mathematica handles contexts, $Context, $ContextPath, and a few of the tutorials they have on Packages.



    What I'm wondering about is how the functions defined in, say, CustomPackage` are able to access the variables in CustomPackage`Private`.



    For example,



    BeginPackage["CustomPackage`"]

    MyFunction::usage = "MyFunction[arg1] adds 5 to arg1."

    Begin["`Private`"]

    abc=5;
    MyFunction[arg1_] := arg1 + abc;

    End[]
    EndPackage[]


    When I load the package <<CustomPackage` the $ContextPath will have CustomPackage` on it, but not CustomPackage`Private`



    So how does MyFunction know the value of abc at the delayed function call (when it is called) if the Private` context isn't on the $ContextPath










    share|improve this question











    $endgroup$














      10












      10








      10





      $begingroup$


      I've been reading up on how Mathematica handles contexts, $Context, $ContextPath, and a few of the tutorials they have on Packages.



      What I'm wondering about is how the functions defined in, say, CustomPackage` are able to access the variables in CustomPackage`Private`.



      For example,



      BeginPackage["CustomPackage`"]

      MyFunction::usage = "MyFunction[arg1] adds 5 to arg1."

      Begin["`Private`"]

      abc=5;
      MyFunction[arg1_] := arg1 + abc;

      End[]
      EndPackage[]


      When I load the package <<CustomPackage` the $ContextPath will have CustomPackage` on it, but not CustomPackage`Private`



      So how does MyFunction know the value of abc at the delayed function call (when it is called) if the Private` context isn't on the $ContextPath










      share|improve this question











      $endgroup$




      I've been reading up on how Mathematica handles contexts, $Context, $ContextPath, and a few of the tutorials they have on Packages.



      What I'm wondering about is how the functions defined in, say, CustomPackage` are able to access the variables in CustomPackage`Private`.



      For example,



      BeginPackage["CustomPackage`"]

      MyFunction::usage = "MyFunction[arg1] adds 5 to arg1."

      Begin["`Private`"]

      abc=5;
      MyFunction[arg1_] := arg1 + abc;

      End[]
      EndPackage[]


      When I load the package <<CustomPackage` the $ContextPath will have CustomPackage` on it, but not CustomPackage`Private`



      So how does MyFunction know the value of abc at the delayed function call (when it is called) if the Private` context isn't on the $ContextPath







      packages core-language scoping contexts






      share|improve this question















      share|improve this question













      share|improve this question




      share|improve this question








      edited Apr 10 at 22:10









      m_goldberg

      88.7k873200




      88.7k873200










      asked Apr 10 at 19:03









      w1resw1res

      23015




      23015




















          4 Answers
          4






          active

          oldest

          votes


















          10












          $begingroup$


          So how does MyFunction know the value of abc at the delayed function call (when it is called) if the Private` context isn't on the $ContextPath




          There is a misunderstanding here. You are assuming that abc is searched for in some context only when MyFunction[something] is evaluated. This is not the case.



          $Context and $ContextPath only affect how source code is parsed (not how expressions are evaluated). In other words, they only affect how the text you write in the package file is interpreted and converted into in-memory expressions. Once the package has been loaded with Get, this interpretation has already happened. MyFunction has been interpreted as the symbol CustomPackage`MyFunction and abc has been interpreted as CustomPackage`Private`abc, according to the value of $Context and $ContextPath at the time each was read. These are the full names of these symbols and this is how they exist in memory.



          Load the package and try this:



          Block[$ContextPath,
          Print@Definition[MyFunction]
          ]


          You'll see the following printed:



          CustomPackage`MyFunction[CustomPackage`Private`arg1_] := 
          CustomPackage`Private`arg1+CustomPackage`Private`abc


          As you can see, a context is always associated with every symbol.






          share|improve this answer











          $endgroup$




















            7












            $begingroup$

            Begin["`Private`"]; sets the current $Context to "CustomPackage `Private`". This causes two things:



            • The symbol abc will be searched in the current context first, thus in"CustomPackage`Private`". Only if it is not found there, the search goes on along $ContextPath.


            • If no matching symbol is found this way, a new symbol abc is created, namely in the current $Context which is "CustomPackage`Private`". So the full symbol name is "CustomPackage`Private`abc".


            For example, running your code in a fresh kernel and executing



            ??MyFunction


            reveals that the full definition of MyFunction is




            MyFunction[CustomPackage`Private`arg1_]:=CustomPackage`Private`arg1+CustomPackage`Private`abc




            Moreover, with



             ?*`abc


            you see that the only symbol in all contexts that matches abc is CustomPackage`Private`abc and has the value 5 assigned to it.






            share|improve this answer











            $endgroup$




















              6












              $begingroup$

              All symbols are created at load time, so when you do:



              BeginPackage["X`"];

              x::usage="Declaring x as an exported symbol in the X` context";

              Begin["`SomePrivateContext`"];

              x[a_]:=b

              End[];

              EndPackage[];


              x was created as X`x but the DownValues of x reference X`SomePrivateContext`a and X`SomePrivateContext`b which were created at the time the function was defined. These symbols are unique, so that reference only ever points that a single object.






              share|improve this answer









              $endgroup$




















                3












                $begingroup$


                So how does MyFunction know the value of abc
                at the delayed function call (when it is called)
                if the Private` context isn't on the $ContextPath?




                because "CustomPackage`Private`" is the value of $Context when MyFunction is defined (i.e. it is not just $ContextPath that determines what a function sees but also what is on $Context).




                TL:DR



                This is a timely question because it indirectly touches upon the competing imperatives of developers and end-users. To the question itself:



                The whole point of packages is that they are a form of encapsulation that allows developers to, without interferance, implement functionality for end-users without bothering them with the underlying details. In particular, the encapsulation involves controlling namespaces so that the underlying details can involve symbols that help implement the functionality but ultimately don't end-up polluting a user's namespace. All symbols defined in a "*`Private`" namespace are created for exactly this purpose.



                Hence in the OP's example, the variable abc is an underlying detail for the implementation of the public MyFunction. The developer needs the "detail" of abc but this particular symbol is of no direct interest to an end-user who typically just ends up calling MyFunction[].



                The package layout achieves this encapsulation by manipulating $ContextPath and $Context as the control-flow passes through the package when it is first loaded. This is described in the other answers and documentation but it can be useful to see it directly:



                loc[n_] := Sow[<|
                "Location" -> n,
                "$Context" -> $Context,
                "$ContextPath" -> $ContextPath|>];

                Reap[

                loc@1;

                BeginPackage["CustomPackage`"];

                loc@2;

                MyFunction::usage = "MyFunction[arg1] adds 5 to arg1.";

                Begin["`Private`"];

                loc@3;

                abc = 5;
                MyFunction[arg1_] := arg1 + abc;

                End[];

                loc@4;

                EndPackage[];

                loc@5
                ]// Last // Dataset


                enter image description here




                When I load the package <the $ContextPath will have CustomPackage on it, but not CustomPackagePrivate




                Yes, this implements both the public exporting of all CustomPackage functions but without polluting end-users namespaces with implementation details. In code around Location 3, all packages are cleared out thereby eliminating possible conflicts with existing abc definitions in currently loaded packages. This is encapsulation benefitting developers but the encapsulation benefitting end-users, as observed, is that on exiting (at Location 5) $ContextPath contains "CustomPackage`" (to provide access to MyFunction) but not "CustomPackage`Private`" thereby shielding users from symbols used in MyFunction's implementation.



                A programmatic confirmation at Location 5 gives:



                MemberQ["CustomPackage`"]@$ContextPath, 
                MemberQ["CustomPackage`Private`"]@$ContextPath,
                Context["abc"]

                True, False, "Global`"



                At Location 3 in the control-flow, the symbol abc is not contained in any of the contexts defined in $ContextPath, ("CustomPackage`", or "System`") nor is it (yet) in the context defined in $Context ("CustomPackage`Private`"). Consequently, the name abc gets created in the context currently set to $Context. At this location $Context has value "CustomPackage`Private`" and hence the symbol CustomPackage`Private`abc is created. When the control flow then moves on to MyFunction[], "CustomPackage`Private`" is still the value of $Context so this function "sees" abc (hence it not just $ContextPath that determines what a function sees but what is on both$ContextPath and $Context).



                Note how the convention of placing usage definitions at Location 2 is ostensibly for documentation purposes but its more important role is to ensure that the function goes into the package's context (see $Context at Location 2) before subsequently being made available in the implementation and for end-users (see $ContextPath at Locations 3 and 5).



                IMO it is kind of cool how these placement protocols just work intuitively without necessarily keeping front-of-mind all the control-flow manipulations, variable-creation mechanisms etc taking place behind the scenes. Hence this means being very careful changing the framework but also IMHO the time is ripe for such extensions given that the line between users/developers may well be in the process of blurring.






                share|improve this answer











                $endgroup$













                  Your Answer








                  StackExchange.ready(function()
                  var channelOptions =
                  tags: "".split(" "),
                  id: "387"
                  ;
                  initTagRenderer("".split(" "), "".split(" "), channelOptions);

                  StackExchange.using("externalEditor", function()
                  // Have to fire editor after snippets, if snippets enabled
                  if (StackExchange.settings.snippets.snippetsEnabled)
                  StackExchange.using("snippets", function()
                  createEditor();
                  );

                  else
                  createEditor();

                  );

                  function createEditor()
                  StackExchange.prepareEditor(
                  heartbeatType: 'answer',
                  autoActivateHeartbeat: false,
                  convertImagesToLinks: false,
                  noModals: true,
                  showLowRepImageUploadWarning: true,
                  reputationToPostImages: null,
                  bindNavPrevention: true,
                  postfix: "",
                  imageUploader:
                  brandingHtml: "Powered by u003ca class="icon-imgur-white" href="https://imgur.com/"u003eu003c/au003e",
                  contentPolicyHtml: "User contributions licensed under u003ca href="https://creativecommons.org/licenses/by-sa/3.0/"u003ecc by-sa 3.0 with attribution requiredu003c/au003e u003ca href="https://stackoverflow.com/legal/content-policy"u003e(content policy)u003c/au003e",
                  allowUrls: true
                  ,
                  onDemand: true,
                  discardSelector: ".discard-answer"
                  ,immediatelyShowMarkdownHelp:true
                  );



                  );













                  draft saved

                  draft discarded


















                  StackExchange.ready(
                  function ()
                  StackExchange.openid.initPostLogin('.new-post-login', 'https%3a%2f%2fmathematica.stackexchange.com%2fquestions%2f194963%2fwhat-is-the-accessibility-of-a-packages-private-context-variables%23new-answer', 'question_page');

                  );

                  Post as a guest















                  Required, but never shown

























                  4 Answers
                  4






                  active

                  oldest

                  votes








                  4 Answers
                  4






                  active

                  oldest

                  votes









                  active

                  oldest

                  votes






                  active

                  oldest

                  votes









                  10












                  $begingroup$


                  So how does MyFunction know the value of abc at the delayed function call (when it is called) if the Private` context isn't on the $ContextPath




                  There is a misunderstanding here. You are assuming that abc is searched for in some context only when MyFunction[something] is evaluated. This is not the case.



                  $Context and $ContextPath only affect how source code is parsed (not how expressions are evaluated). In other words, they only affect how the text you write in the package file is interpreted and converted into in-memory expressions. Once the package has been loaded with Get, this interpretation has already happened. MyFunction has been interpreted as the symbol CustomPackage`MyFunction and abc has been interpreted as CustomPackage`Private`abc, according to the value of $Context and $ContextPath at the time each was read. These are the full names of these symbols and this is how they exist in memory.



                  Load the package and try this:



                  Block[$ContextPath,
                  Print@Definition[MyFunction]
                  ]


                  You'll see the following printed:



                  CustomPackage`MyFunction[CustomPackage`Private`arg1_] := 
                  CustomPackage`Private`arg1+CustomPackage`Private`abc


                  As you can see, a context is always associated with every symbol.






                  share|improve this answer











                  $endgroup$

















                    10












                    $begingroup$


                    So how does MyFunction know the value of abc at the delayed function call (when it is called) if the Private` context isn't on the $ContextPath




                    There is a misunderstanding here. You are assuming that abc is searched for in some context only when MyFunction[something] is evaluated. This is not the case.



                    $Context and $ContextPath only affect how source code is parsed (not how expressions are evaluated). In other words, they only affect how the text you write in the package file is interpreted and converted into in-memory expressions. Once the package has been loaded with Get, this interpretation has already happened. MyFunction has been interpreted as the symbol CustomPackage`MyFunction and abc has been interpreted as CustomPackage`Private`abc, according to the value of $Context and $ContextPath at the time each was read. These are the full names of these symbols and this is how they exist in memory.



                    Load the package and try this:



                    Block[$ContextPath,
                    Print@Definition[MyFunction]
                    ]


                    You'll see the following printed:



                    CustomPackage`MyFunction[CustomPackage`Private`arg1_] := 
                    CustomPackage`Private`arg1+CustomPackage`Private`abc


                    As you can see, a context is always associated with every symbol.






                    share|improve this answer











                    $endgroup$















                      10












                      10








                      10





                      $begingroup$


                      So how does MyFunction know the value of abc at the delayed function call (when it is called) if the Private` context isn't on the $ContextPath




                      There is a misunderstanding here. You are assuming that abc is searched for in some context only when MyFunction[something] is evaluated. This is not the case.



                      $Context and $ContextPath only affect how source code is parsed (not how expressions are evaluated). In other words, they only affect how the text you write in the package file is interpreted and converted into in-memory expressions. Once the package has been loaded with Get, this interpretation has already happened. MyFunction has been interpreted as the symbol CustomPackage`MyFunction and abc has been interpreted as CustomPackage`Private`abc, according to the value of $Context and $ContextPath at the time each was read. These are the full names of these symbols and this is how they exist in memory.



                      Load the package and try this:



                      Block[$ContextPath,
                      Print@Definition[MyFunction]
                      ]


                      You'll see the following printed:



                      CustomPackage`MyFunction[CustomPackage`Private`arg1_] := 
                      CustomPackage`Private`arg1+CustomPackage`Private`abc


                      As you can see, a context is always associated with every symbol.






                      share|improve this answer











                      $endgroup$




                      So how does MyFunction know the value of abc at the delayed function call (when it is called) if the Private` context isn't on the $ContextPath




                      There is a misunderstanding here. You are assuming that abc is searched for in some context only when MyFunction[something] is evaluated. This is not the case.



                      $Context and $ContextPath only affect how source code is parsed (not how expressions are evaluated). In other words, they only affect how the text you write in the package file is interpreted and converted into in-memory expressions. Once the package has been loaded with Get, this interpretation has already happened. MyFunction has been interpreted as the symbol CustomPackage`MyFunction and abc has been interpreted as CustomPackage`Private`abc, according to the value of $Context and $ContextPath at the time each was read. These are the full names of these symbols and this is how they exist in memory.



                      Load the package and try this:



                      Block[$ContextPath,
                      Print@Definition[MyFunction]
                      ]


                      You'll see the following printed:



                      CustomPackage`MyFunction[CustomPackage`Private`arg1_] := 
                      CustomPackage`Private`arg1+CustomPackage`Private`abc


                      As you can see, a context is always associated with every symbol.







                      share|improve this answer














                      share|improve this answer



                      share|improve this answer








                      edited Apr 10 at 20:07

























                      answered Apr 10 at 19:47









                      SzabolcsSzabolcs

                      164k14448949




                      164k14448949





















                          7












                          $begingroup$

                          Begin["`Private`"]; sets the current $Context to "CustomPackage `Private`". This causes two things:



                          • The symbol abc will be searched in the current context first, thus in"CustomPackage`Private`". Only if it is not found there, the search goes on along $ContextPath.


                          • If no matching symbol is found this way, a new symbol abc is created, namely in the current $Context which is "CustomPackage`Private`". So the full symbol name is "CustomPackage`Private`abc".


                          For example, running your code in a fresh kernel and executing



                          ??MyFunction


                          reveals that the full definition of MyFunction is




                          MyFunction[CustomPackage`Private`arg1_]:=CustomPackage`Private`arg1+CustomPackage`Private`abc




                          Moreover, with



                           ?*`abc


                          you see that the only symbol in all contexts that matches abc is CustomPackage`Private`abc and has the value 5 assigned to it.






                          share|improve this answer











                          $endgroup$

















                            7












                            $begingroup$

                            Begin["`Private`"]; sets the current $Context to "CustomPackage `Private`". This causes two things:



                            • The symbol abc will be searched in the current context first, thus in"CustomPackage`Private`". Only if it is not found there, the search goes on along $ContextPath.


                            • If no matching symbol is found this way, a new symbol abc is created, namely in the current $Context which is "CustomPackage`Private`". So the full symbol name is "CustomPackage`Private`abc".


                            For example, running your code in a fresh kernel and executing



                            ??MyFunction


                            reveals that the full definition of MyFunction is




                            MyFunction[CustomPackage`Private`arg1_]:=CustomPackage`Private`arg1+CustomPackage`Private`abc




                            Moreover, with



                             ?*`abc


                            you see that the only symbol in all contexts that matches abc is CustomPackage`Private`abc and has the value 5 assigned to it.






                            share|improve this answer











                            $endgroup$















                              7












                              7








                              7





                              $begingroup$

                              Begin["`Private`"]; sets the current $Context to "CustomPackage `Private`". This causes two things:



                              • The symbol abc will be searched in the current context first, thus in"CustomPackage`Private`". Only if it is not found there, the search goes on along $ContextPath.


                              • If no matching symbol is found this way, a new symbol abc is created, namely in the current $Context which is "CustomPackage`Private`". So the full symbol name is "CustomPackage`Private`abc".


                              For example, running your code in a fresh kernel and executing



                              ??MyFunction


                              reveals that the full definition of MyFunction is




                              MyFunction[CustomPackage`Private`arg1_]:=CustomPackage`Private`arg1+CustomPackage`Private`abc




                              Moreover, with



                               ?*`abc


                              you see that the only symbol in all contexts that matches abc is CustomPackage`Private`abc and has the value 5 assigned to it.






                              share|improve this answer











                              $endgroup$



                              Begin["`Private`"]; sets the current $Context to "CustomPackage `Private`". This causes two things:



                              • The symbol abc will be searched in the current context first, thus in"CustomPackage`Private`". Only if it is not found there, the search goes on along $ContextPath.


                              • If no matching symbol is found this way, a new symbol abc is created, namely in the current $Context which is "CustomPackage`Private`". So the full symbol name is "CustomPackage`Private`abc".


                              For example, running your code in a fresh kernel and executing



                              ??MyFunction


                              reveals that the full definition of MyFunction is




                              MyFunction[CustomPackage`Private`arg1_]:=CustomPackage`Private`arg1+CustomPackage`Private`abc




                              Moreover, with



                               ?*`abc


                              you see that the only symbol in all contexts that matches abc is CustomPackage`Private`abc and has the value 5 assigned to it.







                              share|improve this answer














                              share|improve this answer



                              share|improve this answer








                              edited Apr 10 at 19:35

























                              answered Apr 10 at 19:25









                              Henrik SchumacherHenrik Schumacher

                              60.2k582169




                              60.2k582169





















                                  6












                                  $begingroup$

                                  All symbols are created at load time, so when you do:



                                  BeginPackage["X`"];

                                  x::usage="Declaring x as an exported symbol in the X` context";

                                  Begin["`SomePrivateContext`"];

                                  x[a_]:=b

                                  End[];

                                  EndPackage[];


                                  x was created as X`x but the DownValues of x reference X`SomePrivateContext`a and X`SomePrivateContext`b which were created at the time the function was defined. These symbols are unique, so that reference only ever points that a single object.






                                  share|improve this answer









                                  $endgroup$

















                                    6












                                    $begingroup$

                                    All symbols are created at load time, so when you do:



                                    BeginPackage["X`"];

                                    x::usage="Declaring x as an exported symbol in the X` context";

                                    Begin["`SomePrivateContext`"];

                                    x[a_]:=b

                                    End[];

                                    EndPackage[];


                                    x was created as X`x but the DownValues of x reference X`SomePrivateContext`a and X`SomePrivateContext`b which were created at the time the function was defined. These symbols are unique, so that reference only ever points that a single object.






                                    share|improve this answer









                                    $endgroup$















                                      6












                                      6








                                      6





                                      $begingroup$

                                      All symbols are created at load time, so when you do:



                                      BeginPackage["X`"];

                                      x::usage="Declaring x as an exported symbol in the X` context";

                                      Begin["`SomePrivateContext`"];

                                      x[a_]:=b

                                      End[];

                                      EndPackage[];


                                      x was created as X`x but the DownValues of x reference X`SomePrivateContext`a and X`SomePrivateContext`b which were created at the time the function was defined. These symbols are unique, so that reference only ever points that a single object.






                                      share|improve this answer









                                      $endgroup$



                                      All symbols are created at load time, so when you do:



                                      BeginPackage["X`"];

                                      x::usage="Declaring x as an exported symbol in the X` context";

                                      Begin["`SomePrivateContext`"];

                                      x[a_]:=b

                                      End[];

                                      EndPackage[];


                                      x was created as X`x but the DownValues of x reference X`SomePrivateContext`a and X`SomePrivateContext`b which were created at the time the function was defined. These symbols are unique, so that reference only ever points that a single object.







                                      share|improve this answer












                                      share|improve this answer



                                      share|improve this answer










                                      answered Apr 10 at 19:20









                                      b3m2a1b3m2a1

                                      28.8k359166




                                      28.8k359166





















                                          3












                                          $begingroup$


                                          So how does MyFunction know the value of abc
                                          at the delayed function call (when it is called)
                                          if the Private` context isn't on the $ContextPath?




                                          because "CustomPackage`Private`" is the value of $Context when MyFunction is defined (i.e. it is not just $ContextPath that determines what a function sees but also what is on $Context).




                                          TL:DR



                                          This is a timely question because it indirectly touches upon the competing imperatives of developers and end-users. To the question itself:



                                          The whole point of packages is that they are a form of encapsulation that allows developers to, without interferance, implement functionality for end-users without bothering them with the underlying details. In particular, the encapsulation involves controlling namespaces so that the underlying details can involve symbols that help implement the functionality but ultimately don't end-up polluting a user's namespace. All symbols defined in a "*`Private`" namespace are created for exactly this purpose.



                                          Hence in the OP's example, the variable abc is an underlying detail for the implementation of the public MyFunction. The developer needs the "detail" of abc but this particular symbol is of no direct interest to an end-user who typically just ends up calling MyFunction[].



                                          The package layout achieves this encapsulation by manipulating $ContextPath and $Context as the control-flow passes through the package when it is first loaded. This is described in the other answers and documentation but it can be useful to see it directly:



                                          loc[n_] := Sow[<|
                                          "Location" -> n,
                                          "$Context" -> $Context,
                                          "$ContextPath" -> $ContextPath|>];

                                          Reap[

                                          loc@1;

                                          BeginPackage["CustomPackage`"];

                                          loc@2;

                                          MyFunction::usage = "MyFunction[arg1] adds 5 to arg1.";

                                          Begin["`Private`"];

                                          loc@3;

                                          abc = 5;
                                          MyFunction[arg1_] := arg1 + abc;

                                          End[];

                                          loc@4;

                                          EndPackage[];

                                          loc@5
                                          ]// Last // Dataset


                                          enter image description here




                                          When I load the package <the $ContextPath will have CustomPackage on it, but not CustomPackagePrivate




                                          Yes, this implements both the public exporting of all CustomPackage functions but without polluting end-users namespaces with implementation details. In code around Location 3, all packages are cleared out thereby eliminating possible conflicts with existing abc definitions in currently loaded packages. This is encapsulation benefitting developers but the encapsulation benefitting end-users, as observed, is that on exiting (at Location 5) $ContextPath contains "CustomPackage`" (to provide access to MyFunction) but not "CustomPackage`Private`" thereby shielding users from symbols used in MyFunction's implementation.



                                          A programmatic confirmation at Location 5 gives:



                                          MemberQ["CustomPackage`"]@$ContextPath, 
                                          MemberQ["CustomPackage`Private`"]@$ContextPath,
                                          Context["abc"]

                                          True, False, "Global`"



                                          At Location 3 in the control-flow, the symbol abc is not contained in any of the contexts defined in $ContextPath, ("CustomPackage`", or "System`") nor is it (yet) in the context defined in $Context ("CustomPackage`Private`"). Consequently, the name abc gets created in the context currently set to $Context. At this location $Context has value "CustomPackage`Private`" and hence the symbol CustomPackage`Private`abc is created. When the control flow then moves on to MyFunction[], "CustomPackage`Private`" is still the value of $Context so this function "sees" abc (hence it not just $ContextPath that determines what a function sees but what is on both$ContextPath and $Context).



                                          Note how the convention of placing usage definitions at Location 2 is ostensibly for documentation purposes but its more important role is to ensure that the function goes into the package's context (see $Context at Location 2) before subsequently being made available in the implementation and for end-users (see $ContextPath at Locations 3 and 5).



                                          IMO it is kind of cool how these placement protocols just work intuitively without necessarily keeping front-of-mind all the control-flow manipulations, variable-creation mechanisms etc taking place behind the scenes. Hence this means being very careful changing the framework but also IMHO the time is ripe for such extensions given that the line between users/developers may well be in the process of blurring.






                                          share|improve this answer











                                          $endgroup$

















                                            3












                                            $begingroup$


                                            So how does MyFunction know the value of abc
                                            at the delayed function call (when it is called)
                                            if the Private` context isn't on the $ContextPath?




                                            because "CustomPackage`Private`" is the value of $Context when MyFunction is defined (i.e. it is not just $ContextPath that determines what a function sees but also what is on $Context).




                                            TL:DR



                                            This is a timely question because it indirectly touches upon the competing imperatives of developers and end-users. To the question itself:



                                            The whole point of packages is that they are a form of encapsulation that allows developers to, without interferance, implement functionality for end-users without bothering them with the underlying details. In particular, the encapsulation involves controlling namespaces so that the underlying details can involve symbols that help implement the functionality but ultimately don't end-up polluting a user's namespace. All symbols defined in a "*`Private`" namespace are created for exactly this purpose.



                                            Hence in the OP's example, the variable abc is an underlying detail for the implementation of the public MyFunction. The developer needs the "detail" of abc but this particular symbol is of no direct interest to an end-user who typically just ends up calling MyFunction[].



                                            The package layout achieves this encapsulation by manipulating $ContextPath and $Context as the control-flow passes through the package when it is first loaded. This is described in the other answers and documentation but it can be useful to see it directly:



                                            loc[n_] := Sow[<|
                                            "Location" -> n,
                                            "$Context" -> $Context,
                                            "$ContextPath" -> $ContextPath|>];

                                            Reap[

                                            loc@1;

                                            BeginPackage["CustomPackage`"];

                                            loc@2;

                                            MyFunction::usage = "MyFunction[arg1] adds 5 to arg1.";

                                            Begin["`Private`"];

                                            loc@3;

                                            abc = 5;
                                            MyFunction[arg1_] := arg1 + abc;

                                            End[];

                                            loc@4;

                                            EndPackage[];

                                            loc@5
                                            ]// Last // Dataset


                                            enter image description here




                                            When I load the package <the $ContextPath will have CustomPackage on it, but not CustomPackagePrivate




                                            Yes, this implements both the public exporting of all CustomPackage functions but without polluting end-users namespaces with implementation details. In code around Location 3, all packages are cleared out thereby eliminating possible conflicts with existing abc definitions in currently loaded packages. This is encapsulation benefitting developers but the encapsulation benefitting end-users, as observed, is that on exiting (at Location 5) $ContextPath contains "CustomPackage`" (to provide access to MyFunction) but not "CustomPackage`Private`" thereby shielding users from symbols used in MyFunction's implementation.



                                            A programmatic confirmation at Location 5 gives:



                                            MemberQ["CustomPackage`"]@$ContextPath, 
                                            MemberQ["CustomPackage`Private`"]@$ContextPath,
                                            Context["abc"]

                                            True, False, "Global`"



                                            At Location 3 in the control-flow, the symbol abc is not contained in any of the contexts defined in $ContextPath, ("CustomPackage`", or "System`") nor is it (yet) in the context defined in $Context ("CustomPackage`Private`"). Consequently, the name abc gets created in the context currently set to $Context. At this location $Context has value "CustomPackage`Private`" and hence the symbol CustomPackage`Private`abc is created. When the control flow then moves on to MyFunction[], "CustomPackage`Private`" is still the value of $Context so this function "sees" abc (hence it not just $ContextPath that determines what a function sees but what is on both$ContextPath and $Context).



                                            Note how the convention of placing usage definitions at Location 2 is ostensibly for documentation purposes but its more important role is to ensure that the function goes into the package's context (see $Context at Location 2) before subsequently being made available in the implementation and for end-users (see $ContextPath at Locations 3 and 5).



                                            IMO it is kind of cool how these placement protocols just work intuitively without necessarily keeping front-of-mind all the control-flow manipulations, variable-creation mechanisms etc taking place behind the scenes. Hence this means being very careful changing the framework but also IMHO the time is ripe for such extensions given that the line between users/developers may well be in the process of blurring.






                                            share|improve this answer











                                            $endgroup$















                                              3












                                              3








                                              3





                                              $begingroup$


                                              So how does MyFunction know the value of abc
                                              at the delayed function call (when it is called)
                                              if the Private` context isn't on the $ContextPath?




                                              because "CustomPackage`Private`" is the value of $Context when MyFunction is defined (i.e. it is not just $ContextPath that determines what a function sees but also what is on $Context).




                                              TL:DR



                                              This is a timely question because it indirectly touches upon the competing imperatives of developers and end-users. To the question itself:



                                              The whole point of packages is that they are a form of encapsulation that allows developers to, without interferance, implement functionality for end-users without bothering them with the underlying details. In particular, the encapsulation involves controlling namespaces so that the underlying details can involve symbols that help implement the functionality but ultimately don't end-up polluting a user's namespace. All symbols defined in a "*`Private`" namespace are created for exactly this purpose.



                                              Hence in the OP's example, the variable abc is an underlying detail for the implementation of the public MyFunction. The developer needs the "detail" of abc but this particular symbol is of no direct interest to an end-user who typically just ends up calling MyFunction[].



                                              The package layout achieves this encapsulation by manipulating $ContextPath and $Context as the control-flow passes through the package when it is first loaded. This is described in the other answers and documentation but it can be useful to see it directly:



                                              loc[n_] := Sow[<|
                                              "Location" -> n,
                                              "$Context" -> $Context,
                                              "$ContextPath" -> $ContextPath|>];

                                              Reap[

                                              loc@1;

                                              BeginPackage["CustomPackage`"];

                                              loc@2;

                                              MyFunction::usage = "MyFunction[arg1] adds 5 to arg1.";

                                              Begin["`Private`"];

                                              loc@3;

                                              abc = 5;
                                              MyFunction[arg1_] := arg1 + abc;

                                              End[];

                                              loc@4;

                                              EndPackage[];

                                              loc@5
                                              ]// Last // Dataset


                                              enter image description here




                                              When I load the package <the $ContextPath will have CustomPackage on it, but not CustomPackagePrivate




                                              Yes, this implements both the public exporting of all CustomPackage functions but without polluting end-users namespaces with implementation details. In code around Location 3, all packages are cleared out thereby eliminating possible conflicts with existing abc definitions in currently loaded packages. This is encapsulation benefitting developers but the encapsulation benefitting end-users, as observed, is that on exiting (at Location 5) $ContextPath contains "CustomPackage`" (to provide access to MyFunction) but not "CustomPackage`Private`" thereby shielding users from symbols used in MyFunction's implementation.



                                              A programmatic confirmation at Location 5 gives:



                                              MemberQ["CustomPackage`"]@$ContextPath, 
                                              MemberQ["CustomPackage`Private`"]@$ContextPath,
                                              Context["abc"]

                                              True, False, "Global`"



                                              At Location 3 in the control-flow, the symbol abc is not contained in any of the contexts defined in $ContextPath, ("CustomPackage`", or "System`") nor is it (yet) in the context defined in $Context ("CustomPackage`Private`"). Consequently, the name abc gets created in the context currently set to $Context. At this location $Context has value "CustomPackage`Private`" and hence the symbol CustomPackage`Private`abc is created. When the control flow then moves on to MyFunction[], "CustomPackage`Private`" is still the value of $Context so this function "sees" abc (hence it not just $ContextPath that determines what a function sees but what is on both$ContextPath and $Context).



                                              Note how the convention of placing usage definitions at Location 2 is ostensibly for documentation purposes but its more important role is to ensure that the function goes into the package's context (see $Context at Location 2) before subsequently being made available in the implementation and for end-users (see $ContextPath at Locations 3 and 5).



                                              IMO it is kind of cool how these placement protocols just work intuitively without necessarily keeping front-of-mind all the control-flow manipulations, variable-creation mechanisms etc taking place behind the scenes. Hence this means being very careful changing the framework but also IMHO the time is ripe for such extensions given that the line between users/developers may well be in the process of blurring.






                                              share|improve this answer











                                              $endgroup$




                                              So how does MyFunction know the value of abc
                                              at the delayed function call (when it is called)
                                              if the Private` context isn't on the $ContextPath?




                                              because "CustomPackage`Private`" is the value of $Context when MyFunction is defined (i.e. it is not just $ContextPath that determines what a function sees but also what is on $Context).




                                              TL:DR



                                              This is a timely question because it indirectly touches upon the competing imperatives of developers and end-users. To the question itself:



                                              The whole point of packages is that they are a form of encapsulation that allows developers to, without interferance, implement functionality for end-users without bothering them with the underlying details. In particular, the encapsulation involves controlling namespaces so that the underlying details can involve symbols that help implement the functionality but ultimately don't end-up polluting a user's namespace. All symbols defined in a "*`Private`" namespace are created for exactly this purpose.



                                              Hence in the OP's example, the variable abc is an underlying detail for the implementation of the public MyFunction. The developer needs the "detail" of abc but this particular symbol is of no direct interest to an end-user who typically just ends up calling MyFunction[].



                                              The package layout achieves this encapsulation by manipulating $ContextPath and $Context as the control-flow passes through the package when it is first loaded. This is described in the other answers and documentation but it can be useful to see it directly:



                                              loc[n_] := Sow[<|
                                              "Location" -> n,
                                              "$Context" -> $Context,
                                              "$ContextPath" -> $ContextPath|>];

                                              Reap[

                                              loc@1;

                                              BeginPackage["CustomPackage`"];

                                              loc@2;

                                              MyFunction::usage = "MyFunction[arg1] adds 5 to arg1.";

                                              Begin["`Private`"];

                                              loc@3;

                                              abc = 5;
                                              MyFunction[arg1_] := arg1 + abc;

                                              End[];

                                              loc@4;

                                              EndPackage[];

                                              loc@5
                                              ]// Last // Dataset


                                              enter image description here




                                              When I load the package <the $ContextPath will have CustomPackage on it, but not CustomPackagePrivate




                                              Yes, this implements both the public exporting of all CustomPackage functions but without polluting end-users namespaces with implementation details. In code around Location 3, all packages are cleared out thereby eliminating possible conflicts with existing abc definitions in currently loaded packages. This is encapsulation benefitting developers but the encapsulation benefitting end-users, as observed, is that on exiting (at Location 5) $ContextPath contains "CustomPackage`" (to provide access to MyFunction) but not "CustomPackage`Private`" thereby shielding users from symbols used in MyFunction's implementation.



                                              A programmatic confirmation at Location 5 gives:



                                              MemberQ["CustomPackage`"]@$ContextPath, 
                                              MemberQ["CustomPackage`Private`"]@$ContextPath,
                                              Context["abc"]

                                              True, False, "Global`"



                                              At Location 3 in the control-flow, the symbol abc is not contained in any of the contexts defined in $ContextPath, ("CustomPackage`", or "System`") nor is it (yet) in the context defined in $Context ("CustomPackage`Private`"). Consequently, the name abc gets created in the context currently set to $Context. At this location $Context has value "CustomPackage`Private`" and hence the symbol CustomPackage`Private`abc is created. When the control flow then moves on to MyFunction[], "CustomPackage`Private`" is still the value of $Context so this function "sees" abc (hence it not just $ContextPath that determines what a function sees but what is on both$ContextPath and $Context).



                                              Note how the convention of placing usage definitions at Location 2 is ostensibly for documentation purposes but its more important role is to ensure that the function goes into the package's context (see $Context at Location 2) before subsequently being made available in the implementation and for end-users (see $ContextPath at Locations 3 and 5).



                                              IMO it is kind of cool how these placement protocols just work intuitively without necessarily keeping front-of-mind all the control-flow manipulations, variable-creation mechanisms etc taking place behind the scenes. Hence this means being very careful changing the framework but also IMHO the time is ripe for such extensions given that the line between users/developers may well be in the process of blurring.







                                              share|improve this answer














                                              share|improve this answer



                                              share|improve this answer








                                              edited yesterday

























                                              answered Apr 11 at 4:18









                                              Ronald MonsonRonald Monson

                                              3,1831634




                                              3,1831634



























                                                  draft saved

                                                  draft discarded
















































                                                  Thanks for contributing an answer to Mathematica Stack Exchange!


                                                  • Please be sure to answer the question. Provide details and share your research!

                                                  But avoid


                                                  • Asking for help, clarification, or responding to other answers.

                                                  • Making statements based on opinion; back them up with references or personal experience.

                                                  Use MathJax to format equations. MathJax reference.


                                                  To learn more, see our tips on writing great answers.




                                                  draft saved


                                                  draft discarded














                                                  StackExchange.ready(
                                                  function ()
                                                  StackExchange.openid.initPostLogin('.new-post-login', 'https%3a%2f%2fmathematica.stackexchange.com%2fquestions%2f194963%2fwhat-is-the-accessibility-of-a-packages-private-context-variables%23new-answer', 'question_page');

                                                  );

                                                  Post as a guest















                                                  Required, but never shown





















































                                                  Required, but never shown














                                                  Required, but never shown












                                                  Required, but never shown







                                                  Required, but never shown

































                                                  Required, but never shown














                                                  Required, but never shown












                                                  Required, but never shown







                                                  Required, but never shown







                                                  Popular posts from this blog

                                                  Sum ergo cogito? 1 nng

                                                  三茅街道4182Guuntc Dn precexpngmageondP