Получение текущего контекста из пакета

Я согласен с комментариями выше, что у вас, возможно, должна быть веская причина для этого, но вот. Вот код, который я использую в таких случаях, который позволяет анализировать ваш символ в любом контексте, который вам нравится, во время выполнения:

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
]; 

Вы можете использовать параметры, чтобы указать некоторые контексты, в которых существуют эти символы, которые вы хотите импортировать на этапе синтаксического анализа. Вы можете вызвать это из любого пакета или блокнота, и символ будет проанализирован в соответствии с любым контекстом, который вы укажете.

ХТН

Редактировать:

Отвечая на комментарий (поскольку он сделал вопрос более конкретным): нет никаких сомнений в том, что во время выполнения Context[] будет отображать любой текущий контекст, из которого была вызвана функция (глобальный в этом случае). Я имел в виду другое: Context имеет синтаксис Context[symbol], чтобы дать контекст любого символа, если он находится на $ContextPath. Например, Context[getGraphs] возвращает Bulatov'showGraphs'. Поэтому, если вам нужно автоматически определить контекст какой-либо экспортируемой функции, вы вызываете Context[function]. Вы можете использовать это для создания полных имен других (частных) функций этого пакета. Вот самодостаточный пример:

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] внутри тела функции и не добавлять к ней никаких аргументов.

ToExpression использует текущую привязку $Context при создании символов, поэтому вы можете принудительно интерпретировать ваше выражение в определенном контексте следующим образом:

Block[{$Context="MyPackage`Private`"}, ToExpression[#][5]] & /@ tests

Я не уверен, что понимаю обстоятельства исходного вопроса. Вы можете получить текущий контекст, используя $Context или Context[]... но ToExpression будет автоматически использовать текущий контекст без вмешательства.

Если я запускаю выставленный код в блокноте, он работает нормально. Если я запускаю это так:

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

... он также работает нормально. Я могу заставить его потерпеть неудачу, если я запущу его так:

(* in the package file *)
Begin["MyPackage`Private`"]
test1[g_] := (g == 5);
test2[g_] := (g == 6);
End[]

(* in the notebook *)
tests = {"test1", "test2"}
ToExpression[#][5] & /@ tests

... который не только терпит неудачу, но и создает ложные символы в контексте блокнота. Вы можете обойти эту проблему, используя рецепт Block выше.

Если вы хотите зафиксировать контекст, действовавший в момент загрузки кода пакета, вы можете сделать что-то вроде этого:

(* in the package *)
Begin["MyPackage`Private`"]
test1[g_] := (g == 5);
test2[g_] := (g == 6);
tests = {"test1", "test2"};
With[{context = $Context},
  runTests[] := Block[{$Context = context}, ToExpression[#][5]] & /@ tests
]
End[]

(* in the notebook *)
MyPackage`Private`runTests[]

runTests использует With для внедрения контекста закрытого пакета в его определение.

Как отметил Янус, лучше использовать символы, чем строки, поскольку они автоматически управляют всей проблемой контекста, но это предполагает, что ваш фактический вариант использования разрешает использование символов.