Mathematica 什么时候创建新符号？

Question

美好的一天，

我之前认为 Mathematica 在转换输入字符串（分配给 InString$Context 中创建新符号code>) 来输入表达式（分配给 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]= {}

您可以看到 $ContextPath 中没有符号 f，尽管它已经在 In[1 的定义内部使用。 ]。

此示例表明，原则上可以在 Mathematica 中使用 $ContextPath 中不存在的符号进行定义，而无需创建它们。这可能是使用 Symbol 避免创建符号的方法的有趣替代方法：

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

任何人都可以解释在评估过程的哪些条件和阶段 Mathematica 创建新符号吗？

编辑

正如 Sasha 在这个问题的评论中注意到的那样，实际上我被默认样式表 Core.nb 中输出单元格的默认 ShowStringCharacters->False 设置欺骗了并错过了 DownValues[In]//First 输出的 FullForm。实际上，In[1] 的定义中并未使用符号 f，正如我们也可以通过使用 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]

抱歉，仓促的声明。

所以现在的问题只是关于 Mathematica 决定创建新符号的阶段以及我们如何阻止它？ 例如，在上面的示例中，我们输入 f 作为 Symbol，但 Mathematica 将其转换为 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 和 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 和 $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 在对 In 进行新分配之后以及在创建所有新之后执行当前$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 变量分配新值。

---

结论：新的 Symbol 是在调用 $PreRead、MakeExpression 和 $NewSymbol 之后、调用 之前创建的>$Pre。

Answer 1

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

symbolQ = StringMatchQ[#, RegularExpression["[a-zA-Z$][a-zA-Z
关于您在 edit 部分中的问题：不确定这是否是您的想法，但在前端会话中，您可以使用 $PreRead 在解析过程中将符号保留为字符串阶段。这是一种可能的技巧：
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] 更改为 ClearAll[keepSymbolsAsStrings, symbol] 和 StringJoin["\"", x, "\"" ] 通过 RowBox[{"s​​ymbol", "[", StringJoin["\"", x, "\""], "]"}] 来跟踪哪些字符串结果表达式中对应于转换后的符号。

编辑 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]
]

我们需要 技巧打破了 < 定义中的无限递归代码>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。

Answer 2

您可以使用 $NewSymbol 和 $NewMessage 以便更好地了解符号创建时间。但从虚拟书中，当在 $Context 和 $ContextPath 中都找不到该符号时，该符号是在 $Context 中创建的。

Answer 3

我认为您对输入解析为表达式时创建符号的基本理解是正确的。

微妙的部分是行开头的 ? （以及 << 和 >>）专门解析以允许字符串不需要引号。 （这里的隐式字符串是 ? 的 *Min* 等模式，以及 << 和 >> 的文件名。 。）