Mathematica 什么时候创建新符号？

再会，

我早些时候以为数学在当前符号中创建新符号$Context在转换输入字符串的阶段（即分配给InString）来输入表达式（即分配给In）。但一个简单的例子打破了这一解释：

In[1]:= ?f
During evaluation of In[1]:= Information::notfound: Symbol f not found. >>
In[2]:= Names["`*"]
Out[2]= {}
In[3]:= DownValues[In]//First
InString[1]
Names["`*"]
Out[3]= HoldPattern[In[1]]:>Information[f,LongForm->False]
Out[4]= \(? f\)
Out[5]= {}

可以看到没有任何符号f in the $ContextPath尽管它已经在定义中使用In[1].

这个例子表明，原则上是可能的数学使用不存在的符号进行定义$ContextPath而不创建它们。这可能是避免使用符号创建的方法的有趣替代方法Symbol:

In[9]:= ff := Symbol["f"]
Names["`*"]
Out[10]= {"ff"}

谁能解释一下评估过程的条件和阶段数学创建新符号？

EDIT

正如萨沙在这个问题的评论中注意到的那样，实际上我默认被欺骗了ShowStringCharacters->False默认样式表 Core.nb 中输出单元格的设置，并且错过了FullForm的输出为DownValues[In]//First。在真正的符号中f没有在定义中使用In[1]我们也可以通过使用看到InputForm:

In[1]:= ?f
DownValues[In]//First//InputForm
During evaluation of In[1]:= Information::notfound: Symbol f not found. >>
Out[2]//InputForm=
HoldPattern[In[1]] :> Information["f", LongForm -> False]

抱歉仓促发言。

所以现在的问题只是关于这个阶段数学决定创建新的Symbol我们该如何预防呢？ 例如，在上面的例子中我们输入f as Symbol but 数学将其转换为String无需创建新符号。这是内置行为MakeExpression:

In[1]:= ?f
InputForm[MakeExpression[ToExpression@InString[1], StandardForm]]

During evaluation of In[1]:= Information::notfound: Symbol f not found. >>

Out[2]//InputForm=
HoldComplete[Information["f", LongForm -> False]]

也许可以定义某种类型的语法结构，在计算时间之前阻止符号创建。

关于创建新符号时的评估阶段

我们可以看到，递增$Line发生在打电话之前MakeExpression但新的Symbol创造并赋予新的价值InString and In调用后发生变量MakeExpression:

In[1]:= MakeExpression[My`boxes_,My`f_]/;!TrueQ[My`$InsideMakeExpression]:=Block[{My`$InsideMakeExpression=True},Print[$Line];Print[DownValues[InString][[All,1]]];Print[DownValues[In][[All,1]]];Print[Names["`*"]];MakeExpression[My`boxes,My`f]];
In[2]:= a
During evaluation of In[2]:= 2
During evaluation of In[2]:= {HoldPattern[InString[1]]}
During evaluation of In[2]:= {HoldPattern[In[1]]}
During evaluation of In[2]:= {}
Out[2]= a

我们可以说同样的话$PreRead https://stackoverflow.com/questions/5626387/how-to-intercept-assigning-new-value-for-the-in-variable/5626503#5626503 and $NewSymbol通话时间：

In[1]:= $NewSymbol:=Print["Names[\"`*\"]=",Names["`*"],"\nDownValues[InString]=",DownValues[InString][[All,1]],"\nDownValues[In]=",DownValues[In][[All,1]],"\nName: ",#1,"\tContext: ",#2]&
In[2]:= a
During evaluation of In[2]:= Names["`*"]={}
DownValues[InString]={HoldPattern[InString[1]]}
DownValues[In]={HoldPattern[In[1]]}
Name: a Context: Global`
Out[2]= a

$Pre执行after新分配给In被制作并且after创造一切新的Symbols 在当前$Context:

In[1]:= $Pre := (Print[Names["`*"]]; 
   Print[DownValues[In][[All, 1]]]; ##) &

In[2]:= a

During evaluation of In[2]:= {a}

During evaluation of In[2]:= {HoldPattern[In[1]],HoldPattern[In[2]]}

Out[2]= a

看起来不可能拦截为其分配新值In多变的 https://stackoverflow.com/questions/5626387/how-to-intercept-assigning-new-value-for-the-in-variable/5626503#5626503.

结论：新Symbols 是在调用后创建的$PreRead, MakeExpression and $NewSymbol但在打电话之前$Pre.

关于您在edit部分：不确定这是否是您的想法，但在前端会话中您可以使用$PreRead在解析阶段将符号保留为字符串。这是一种可能的黑客方法：

symbolQ = StringMatchQ[#, RegularExpression["[a-zA-Z$][a-zA-Z$`0-9]*"]] &;

ClearAll[keepSymbolsAsStrings];
SetAttributes[keepSymbolsAsStrings, HoldAllComplete];

$PreRead  = # //. RowBox[{"keepSymbolsAsStrings", rest___}] :>
 RowBox[{"keepSymbolsAsStrings", 
   Sequence @@ ({rest} //. x_String?symbolQ :>
       With[{context = Quiet[Context[x]]},            
        StringJoin["\"", x, "\""] /; 
         Head[context] === Context])}] &;

仅当该符号尚不存在时才会将其转换为字符串（通过检查Context[symbol_string_name]）。例如

In[4]:= keepSymbolsAsStrings[a+b*Sin[c]]//FullForm

Out[4]//FullForm= keepSymbolsAsStrings[Plus["a",Times["b",Sin["c"]]]]

重要的是keepSymbolsAsStrings首先定义，以便创建该符号。这使得它可重入：

In[6]:= keepSymbolsAsStrings[a+b*Sin[c]*keepSymbolsAsStrings[d+e*Sin[f]]]//FullForm

Out[6]//FullForm= 
  keepSymbolsAsStrings[Plus["a",Times["b",Sin["c"],
  keepSymbolsAsStrings[Plus["d",Times["e",Sin["f"]]]]]]]

现在，您可以在解析代码后以您喜欢的方式处理这些符号（保留为字符串）。您还可以使用不同的symbolQ函数 - 我只是为了举例而使用一个简单的函数。

但这对包不起作用。我没有看到对包执行此操作的直接方法。一种简单的方法是动态地重新定义Needs，以与预处理阶段类似的方式在字符串级别修改源代码，并有效地调用Needs关于修改后的源。但字符串级源代码修改通常很脆弱。

HTH

Edit

上面的代码有一个缺陷，即很难区分哪些字符串是字符串，哪些是上述函数转换的符号。您可以通过更改上面的代码来修改ClearAll[keepSymbolsAsStrings] to ClearAll[keepSymbolsAsStrings, symbol] and StringJoin["\"", x, "\""] by RowBox[{"symbol", "[", StringJoin["\"", x, "\""], "]"}]跟踪结果表达式中的哪些字符串对应于转换后的符号。

Edit 2

这是修改后的代码，基于MakeExpression而不是$PreRead，正如@Alexey所建议的：

symbolQ =  StringMatchQ[#, RegularExpression["[a-zA-Z$][a-zA-Z$0-9`]*"]] &;

ClearAll[keepSymbolsAsStrings, symbol];
SetAttributes[keepSymbolsAsStrings, HoldAllComplete];

Module[{tried},
 MakeExpression[RowBox[{"keepSymbolsAsStrings", rest___}], form_] :=
  Block[{tried = True},
    MakeExpression[
       RowBox[{"keepSymbolsAsStrings", 
         Sequence @@ ({rest} //. x_String?symbolQ :>
            With[{context = Quiet[Context[x]]},            
             RowBox[{"symbol", "[", StringJoin["\"", x, "\""], "]"}] /;
             Head[context] === Context])}], form]
  ] /;!TrueQ[tried]
]

我们需要trick https://stackoverflow.com/questions/4198961/what-is-in-your-mathematica-tool-bag/5149656#5149656托德·盖利 (Todd Gayley) 打破了定义中的无限递归MakeExpression。下面再次举例：

In[7]:= keepSymbolsAsStrings[a+b*Sin[c]]//FullForm

Out[7]//FullForm= keepSymbolsAsStrings[Plus[symbol["a"],Times[symbol["b"],Sin[symbol["c"]]]]]

In[8]:= keepSymbolsAsStrings[a+b*Sin[c]*keepSymbolsAsStrings[d+e*Sin[f]]]//FullForm

Out[8]//FullForm=  keepSymbolsAsStrings[Plus[symbol["a"],Times[symbol["b"],Sin[symbol["c"]],
keepSymbolsAsStrings[Plus[symbol["d"],Times[symbol["e"],Sin[symbol["f"]]]]]]]]

这种方法更干净，因为$PreRead仍然可供最终用户使用。