Lisp 和 Erlang Atoms、Ruby 和 Scheme 符号。它们有多有用？

Question

在编程语言中拥有原子数据类型的功能有多有用？

一些编程语言具有原子或符号的概念来表示某种常量。我接触过的语言（Lisp、Ruby 和 Erlang）之间存在一些差异，但在我看来，总体概念是相同的。我对编程语言设计很感兴趣，我想知道原子类型在现实生活中能提供什么价值。其他语言，如 Python、Java、C# 似乎在没有它的情况下也表现得很好。

我没有 Lisp 或 Ruby 的实际经验（我知道语法，但没有在实际项目中使用过）。我已经足够使用 Erlang 来适应那里的概念了。

Answer 1

原子是文字、常量，有自己的值名称。所见即所得，不要期望更多。原子猫的意思是“猫”，仅此而已。你不能玩弄它，你不能改变它，你不能把它打碎；这是猫。处理它。

我将原子与以名称作为值的常量进行了比较。您之前可能使用过使用常量的代码：例如，假设我有眼睛颜色的值：BLUE -> 1、棕色-> 2、绿色-> 3、其他-> 4.。您需要将常量的名称与某些基础值相匹配。原子让你忘记潜在的价值：我的眼睛颜色可以简单地是“蓝色”、“棕色”、“绿色”和“其他”。这些颜色可以在任何代码段的任何地方使用：底层值永远不会冲突，并且这样的常量不可能未定义！

^{取自http://learnyousomeerlang.com/starting-out-for-real#原子}

话虽如此，原子最终在语义上更适合在其他语言被迫使用字符串、枚举或定义的地方描述代码中的数据。它们更安全、更友好，可实现类似的预期结果。

Answer 2

一个简短的例子展示了操作符号的能力如何产生更干净的代码：（代码是在Scheme中，Lisp的一种方言）。

(define men '(socrates plato aristotle))

(define (man? x) 
    (contains? men x))

(define (mortal? x) 
    (man? x))

;; test

> (mortal? 'socrates)
=> #t

您可以使用字符串或整数常量编写此程序。但符号版本有一定的优点。保证符号在系统中是唯一的。这使得比较两个符号与比较两个指针一样快。这显然比比较两个字符串要快。使用整数常量允许人们编写无意义的代码，例如：

(define SOCRATES 1)
;; ...

(mortal? SOCRATES)
(mortal? -1) ;; ??

这个问题的详细答案可以在书中找到 Common Lisp ：符号计算简单介绍。

Answer 3

当你的语义值没有自然的底层“本机”表示时，原子（在 Erlang 或 Prolog 等中）或符号（在 Lisp 或 Ruby 等中）——这里仅称为原子——非常有用。它们采用 C 风格枚举的空间，如下所示：

enum days { MONDAY, TUESDAY, WEDNESDAY, THURSDAY, FRIDAY, SATURDAY, SUNDAY }

不同之处在于原子通常不需要声明，并且它们没有需要担心的底层表示。 Erlang 或 Prolog 中的原子 monday 的值为“theatom monday”，仅此而已。

虽然确实可以从字符串类型中获得与从原子中获得的大部分相同的用途，但后者有一些优点。首先，因为保证原子是唯一的（在幕后它们的字符串表示形式被转换为某种形式的易于测试的 ID），所以比较它们比比较等效字符串要快得多。其次，它们是不可分割的。例如，原子 monday 无法测试它是否以 day 结尾。它是一个纯粹的、不可分割的语义单位。换句话说，与字符串表示形式相比，您的概念重载更少。

您还可以通过 C 样式枚举获得许多相同的好处。尤其是比较速度，如果有的话，更快。但是...它是一个整数。你可以做一些奇怪的事情，比如将 SATURDAY 和 SUNDAY 转换为相同的值：

enum days { SATURDAY, SUNDAY = 0, MONDAY, TUESDAY, WEDNESDAY, THURSDAY, FRIDAY }

这意味着你不能相信不同的“符号”（枚举）是不同的东西，这使得对代码的推理变得更加困难。同样，通过有线协议发送枚举类型也是有问题的，因为无法区分它们和常规整数。原子不存在这个问题。原子不是一个整数，并且永远不会看起来像幕后的一个。

Answer 4

作为一名 C 程序员，我在理解 Ruby 符号到底是什么时遇到了问题。看到源码中符号是如何实现的，我恍然大悟。

在 Ruby 代码内部，有一个全局哈希表，字符串映射到整数。所有 Ruby 符号都保存在那里。 Ruby 解释器在源代码解析阶段使用该哈希表将所有符号转换为整数。然后在内部所有符号都被视为整数。这意味着一个符号仅占用 4 个字节的内存，并且所有比较都非常快。

所以基本上你可以将 Ruby 符号视为以非常聪明的方式实现的字符串。 它们看起来像字符串，但执行起来几乎像整数。

当创建一个新字符串时，在 Ruby 中会分配一个新的 C 结构来保存该对象。对于两个 Ruby 字符串，有两个指针指向两个不同的内存位置（可能包含相同的字符串）。然而，符号会立即转换为 C int 类型。因此，无法将两个符号区分为两个不同的 Ruby 对象。这是实施的副作用。只需在编码时记住这一点即可。

Answer 5

在 Lisp 中，符号和原子是两个不同且不相关的概念。

通常在 Lisp 中，ATOM 并不是一种特定的数据类型。它是 NOT CONS 的缩写。

(defun atom (item)
  (not (consp item)))

此外，ATOM 类型与 类型相同（不是 CONS）。

在 Common Lisp 中，任何不是 cons cell 的东西都是原子。

SYMBOL 是一种特定的数据类型。

符号是具有名称和身份的对象。符号可以驻留在包中。符号可以有一个值、一个函数和一个属性列表。

CL-USER 49 > (describe 'FOO)

FOO is a SYMBOL
NAME          "FOO"
VALUE         #<unbound value>
FUNCTION      #<unbound function>
PLIST         NIL
PACKAGE       #<The COMMON-LISP-USER package, 91/256 internal, 0/4 external>

在 Lisp 源代码中，变量、函数、类等的标识符都写为符号。如果阅读器读取 Lisp s 表达式，如果未知符号（在当前包中可用），它会创建新符号，或者重用现有符号（如果在当前包中可用）。如果 Lisp 阅读器读取list 就像

(snow snow)

这样，它创建了一个包含两个 cons 单元的列表。每个 cons 单元的 CAR 都指向同一个符号 snow。

另外请注意，plist (符号的属性列表可以存储符号的附加元信息，这可以是作者、源位置等。用户也可以在他/她的程序中使用此功能。

Answer 6

在Scheme（以及Lisp家族的其他成员）中，符号不仅有用，而且是必不可少的。

这些语言的一个有趣的属性是它们是同像。一个Scheme程序或表达式本身可以表示为一个有效的Scheme数据结构。

一个例子可能会让这一点更清楚（使用Gauche方案）：

> (define x 3)
x
> (define expr '(+ x 1))
expr
> expr
(+ x 1)
> (eval expr #t)
4

这里，expr只是一个列表，由符号+、符号x组成，以及数字1。我们可以像任何其他列表一样操作这个列表，传递它等等。但我们也可以评估它，在这种情况下它将被解释为代码。

为了实现这一点，Scheme 需要能够区分符号和字符串文字。在上面的示例中，x 是一个符号。它不能在不改变含义的情况下替换为字符串文字。如果我们获取一个列表 '(print x)（其中 x 是一个符号）并对其进行求值，则它的含义不同于 '(print "x") ，其中“x”是一个字符串。

顺便说一下，使用Scheme 数据结构表示Scheme 表达式的能力不仅仅是一个噱头；将表达式读取为数据结构并以某种方式转换它们是宏的基础。

Answer 7

你说 python 没有原子或符号的类似物实际上是不正确的。在 python 中制作表现得像原子的对象并不困难。只是制作物体。普通的空物体。示例：

>>> red = object()
>>> blue = object()
>>> c = blue
>>> c == red
False
>>> c == blue
True
>>> 

田田！ python 中的原子！我一直用这个技巧。事实上，你可以走得更远。你可以给这些对象一个类型：

>>> class Colour:
...  pass
... 
>>> red = Colour()
>>> blue = Colour()
>>> c = blue
>>> c == red
False
>>> c == blue
True
>>> 

现在，你的颜色有一个类型，所以你可以做这样的事情：

>>> type(red) == Colour
True
>>> 

所以，这在功能上或多或少与 lispy 符号相同，以及它们的属性列表。

Answer 8

在某些语言中，关联数组文字的键的行为类似于符号。

在Python[1]中，是一个字典。

d = dict(foo=1, bar=2)

在 Perl[2] 中，是一个散列。

my %h = (foo => 1, bar => 2);

在 JavaScript[3] 中，是一个对象。

var o = {foo: 1, bar: 2};

在这些情况下，foo 和 bar 就像符号，即不带引号的不可变字符串。

[1] 证明：

x = dict(a=1)
y = dict(a=2)

(k1,) = x.keys()
(k2,) = y.keys()

assert id(k1) == id(k2)

[2] 这并不完全正确：

my %x = (a=>1);
my %y = (a=>2);

my ($k1) = keys %x;
my ($k2) = keys %y;

die unless \$k1 == \$k2; # dies

[1] 在 JSON 中，不允许使用此语法，因为必须用引号引起来的键。我不知道如何证明它们是符号，因为我不知道如何读取变量的内存。

Answer 9

原子保证是唯一且完整的，与浮点常量值相反，浮点常量值可能会因编码、通过线路发送它们、在另一端解码并转换回浮点时的不准确性而有所不同。无论您使用什么版本的解释器，它都能确保atom始终具有相同的“值”并且是唯一的。

Erlang VM 将所有模块中定义的所有原子存储在全局原子表中。

Erlang 中没有布尔数据类型。相反，原子 true 和 false 用于表示布尔值。这可以防止人们做这种令人讨厌的事情：

#define TRUE FALSE //Happy debugging suckers

在 Erlang 中，您可以将原子保存到文件中，读回它们，通过远程 Erlang VM 之间的线路传递它们等。

就像示例一样，我将把几个术语保存到一个文件中，然后读回它们。这是 Erlang 源文件 lib_misc.erl （或者我们现在最感兴趣的部分）：

-module(lib_misc).
-export([unconsult/2, consult/1]).

unconsult(File, L) ->
    {ok, S} = file:open(File, write),
    lists:foreach(fun(X) -> io:format(S, "~p.~n",[X]) end, L),
    file:close(S).

consult(File) ->
    case file:open(File, read) of
    {ok, S} ->
        Val = consult1(S),
        file:close(S),
        {ok, Val};
    {error, Why} ->
        {error, Why}
    end.

consult1(S) ->
    case io:read(S, '') of
    {ok, Term} -> [Term|consult1(S)];
    eof        -> [];
    Error      -> Error
    end.

现在我将编译这个模块并将一些术语保存到文件中：

1> c(lib_misc).
{ok,lib_misc}
2> lib_misc:unconsult("./erlang.terms", [42, "moo", erlang_atom]).
ok
3>

在文件 erlang.erl 中。 terms 我们将得到以下内容：

42.
"moo".
erlang_atom. 

现在让我们读回它：

3> {ok, [_, _, SomeAtom]} = lib_misc:consult("./erlang.terms").   
{ok,[42,"moo",erlang_atom]}
4> is_atom(SomeAtom).
true
5>

您看到数据已成功从文件中读取，并且变量 SomeAtom 确实保存了一个原子 erlang_atom.

---

^{lib_misc.erl 内容摘自 Joe Armstrong 的《Programming Erlang: Software for a Concurrent World》，The Pragmatic Bookshelf 出版。其余源代码位于此处。}

Answer 10

在 Ruby 中，符号经常用作哈希中的键，因此 Ruby 1.9 甚至引入了构造哈希的简写。您之前写的是：

{:color => :blue, :age => 32}

现在可以写成：

{color: :blue, age: 32}

本质上，它们是介于字符串和整数之间的东西：在源代码中它们类似于字符串，但有很大的差异。相同的两个字符串实际上是不同的实例，而相同的符号始终是相同的实例：

> 'foo'.object_id
# => 82447904 
> 'foo'.object_id
# => 82432826 
> :foo.object_id
# => 276648 
> :foo.object_id
# => 276648 

这会对性能和内存消耗产生影响。而且，它们是不可变的。一旦分配就不能更改。

一个有争议的经验法则是对每个不用于输出的字符串使用符号而不是字符串。

虽然看起来可能无关紧要，但大多数代码突出显示编辑器对符号的颜色与代码的其余部分不同，从而进行视觉区分。

Answer 11

我在其他语言（例如，C）中遇到的类似概念的问题可以很容易地表达为：

#define RED 1
#define BLUE 2

#define BIG 1
#define SMALL 2

或

enum colors { RED, BLUE  };
enum sizes  { BIG, SMALL };

导致以下问题：

if (RED == BIG)
    printf("True");
if (BLUE == 2)
    printf("True");

两者都没有真正意义。原子解决了类似的问题，但没有上述缺点。

Answer 12

原子就像一个开放的枚举，具有无限可能的值，并且无需预先声明任何内容。这就是它们在实践中通常的使用方式。

例如，在 Erlang 中，进程期望接收几种消息类型之一，并且用原子标记消息是最方便的。大多数其他语言都会使用枚举作为消息类型，这意味着每当我想发送新类型的消息时，我都必须将其添加到声明中。

此外，与枚举不同，原子值集可以组合。假设我想监控 Erlang 进程的状态，并且我有一些标准的状态监控工具。我可以扩展我的流程以响应状态消息协议以及其他消息类型。使用枚举，我将如何解决这个问题？

enum my_messages {
  MSG_1,
  MSG_2,
  MSG_3
};

enum status_messages {
  STATUS_HEARTBEAT,
  STATUS_LOAD
};

问题是MSG_1是0，STATUS_HEARTBEAT也是0。当我收到类型0的消息时，它是什么？对于原子，我就没有这个问题。

原子/符号不仅仅是具有恒定时间比较的字符串:)。

Answer 13

原子提供快速的相等性测试，因为它们使用身份。与枚举类型或整数相比，它们具有更好的语义（为什么要用数字表示抽象符号值？）并且它们不限于像枚举这样的固定值集。

妥协是它们的创建比文字字符串更昂贵，因为系统需要知道所有现有实例以保持唯一性；这主要花费编译器的时间，但它消耗的内存为 O（唯一原子的数量）。