从包中获取当前上下文 [英] Getting current context from within Package

问题描述

我的笔记本中有类似以下内容.

I had something like the following in my notebook.

test1[g_] := (g == 5);
test2[g_] := (g == 6);
tests={"test1", "test2"}
ToExpression[#][5] & /@ tests

当我将此代码放入包时它不起作用，因为 test1 现在被称为 MyPackage'Private'test1.如何修改最后一行以使此代码在包内和笔记本内运行?

When I put this code in a package it doesn't work because test1 is now called MyPackage'Private'test1. How can I modify the last line to make this code run both inside package and inside notebook?

更新这就是为什么我使用 ToExpression 而不是使用 Symbols 的原因.回想起来，也许用 Symbols 来代替更容易

Update Here's why I was doing doing ToExpression as opposed to using Symbols. In retrospect, maybe it's easier to use Symbols instead

我有一个函数，我称之为 getGraphs["LeafFree","Planar",!"Tree",...] 来获取所有无叶、平面而不是树的图.其中一些字符串是 GraphData 中的类，而另一些是我自己的类.对于我自己的每个类，我都有一个具有相同名称的函数，例如测试属性的 LeafFree.在 notebook 中，使用上述 ToExpression 代码是实现这一点的最快方法.

I had a function which I call like getGraphs["LeafFree","Planar",!"Tree",...] to get all graphs that are leaf free, planar and not trees. Some of those strings are classes in GraphData, while others were my own classes. For each of my own classes I had a function with identical name, like LeafFree that tested the property. In the notebook, using ToExpression code like above was the quickest way to implement this.

getGraphs[n_Integer, cl__] := getGraphs[{n, n}, cl];
getGraphs[{nmin_Integer, nmax_Integer}, cl__] := 
 Module[{maxgraphnum = 100},
  customClasses = {"isLeafFree", ! "isLeafFree"};
  classes = {cl}\[Backslash]customClasses;
  builtinClasses = 
   GraphData["Classes"] \[Tilde] (Not /@ GraphData["Classes"]);
  Assert[classes \[Subset] builtinClasses];
  isLeafFree[gname_] := 
   FreeQ[GraphData[gname, "DegreeSequence"], 0 | 1];

  posClasses = Cases[classes\[Backslash]customClasses, _String];
  posGroup = 
   If[posClasses == {}, GraphData[nmin ;; nmax], 
    GraphData[posClasses, nmin ;; nmax]];
  negClasses = classes\[Backslash]posClasses;
  negGroups = GraphData[#[[1]], nmin ;; nmax] & /@ negClasses;

  result = Complement[posGroup, Sequence @@ negGroups];
  customTest[g_] := 
   And @@ (ToExpression[#][g] & /@ ({cl} \[Intersection] 
        customClasses));
  (*result=Take[result,Min[Length[result],100]];*)

  result = Select[result, customTest]
  ]

推荐答案

我同意上面的评论，您或许应该有一个令人信服的理由来这样做，但这里是.这是我在这种情况下使用的代码，它允许在运行时在您喜欢的任何上下文中解析您的符号:

I agree with the comments above that you should perhaps have a compelling reason to do this, but here goes. Here is a code I use in such cases, which allows your symbol to be parsed in whatever context you like, at run-time:

SetAttributes[ParseTimeNameSpaceWrapper,HoldFirst];
Options[ParseTimeNameSpaceWrapper] = {
  LocalizingContext->"MyLocalizingContext`",
  DefaultImportedContexts:>{"Imported1`", "Imported2`"},
  ExtraImportedContexts:>   {}
};



ParseTimeNameSpaceWrapper[code_,opts:OptionsPattern[]]:=
Module[{result,
  context = OptionValue[LocalizingContext],
  defcontexts = OptionValue[DefaultImportedContexts],
  extraContexts = OptionValue[ExtraImportedContexts],
  allContexts},
  allContexts = {Sequence@@defcontexts,Sequence@@extraContexts};
  BeginPackage[context,If[allContexts==={},Sequence@@{},allContexts]];      
    result = code;  
  EndPackage[];
  result
]; 

您可以使用选项来指定存在这些符号的一些上下文，您希望在解析阶段导入这些上下文.您可以从任何包或笔记本中调用它，符号将根据您指定的任何上下文进行解析.

You can use options to specify some contexts where these symbols exist, that you want to import during the parse stage. You can call this from any package or notebook, and the symbol will be parsed according to whatever context you specify.

HTH

回复评论(因为它使问题更加具体):毫无疑问，在运行时 Context[] 将显示调用函数的当前上下文(在这种情况下是全局的).我的意思是别的:Context 有一个语法 Context[symbol]，如果它在 $ContextPath 上，则给出任何符号的上下文.例如，Context[getGraphs] 返回 Bulatov'showGraphs'.因此，如果您需要自动确定某个导出函数的上下文，则调用Context[function].您可以使用它来构造该包的其他(私有)函数的全名.这是一个自包含的示例:

Responding to a comment (since it made the question more specific): There is no question that at run-time Context[] will display whatever is the current context from where the function was called (Global in that case). I meant something else: Context has a syntax Context[symbol], to give a context of any symbol if it is on the $ContextPath. For example, Context[getGraphs] returns Bulatov'showGraphs'. Therefore, if you need to determine the context of some exported function automatically, you call Context[function]. You can use this to construct full names of other (private) functions of that package. Here is a self - contained example:

In[1]:= 
BeginPackage["MyTest`"]; 
f[x_, y_, context_: Context[f]] :=
  Module[{f1str = "function1", f2str = "function2", f1, f2}, 
    {f1, f2} = ToExpression[context <> "Private`" <> #] & /@ {f1str, f2str};
    f1[x, y];
    f2[x, y];];

Begin["`Private`"];

function1[x_, y_] :=  Print["In function1: arguments are ", x, " , ", y];
function2[x_, y_] :=  Print["In function2: arguments are ", x, " , ", y];

End[]
EndPackage[];

Out[6]= "MyTest`Private`"

In[8]:= f[1, 2]

During evaluation of In[8]:= In function1: arguments are 1 , 2

During evaluation of In[8]:= In function2: arguments are 1 , 2

其中 x,y 只是一些示例参数.然后，您实际上从未提供最后一个参数，但您可以在函数内使用 context 变量，为其他函数构造长名称，如上面的示例代码所示.或者，您可以在函数体内直接使用 Context[f]，而不向其添加任何参数.

where x,y are just some sample arguments. Then, you never actually supply the last argument, but you can use the context variable inside your function, to construct long names for your other functions, as in the sample code above. Or you could just plain use Context[f] inside body of the function, and not add any arguments to it.

这篇关于从包中获取当前上下文的文章就介绍到这了，希望我们推荐的答案对大家有所帮助，也希望大家多多支持IT屋！