Python 中的求和类型

学习知识要善于思考，思考，再思考！今天golang学习网小编就给大家带来《Python 中的求和类型》，以下内容主要包含等知识点，如果你正在学习或准备学习文章，就都不要错过本文啦~让我们一起来看看吧，能帮助到你就更好了！

python 是一门可爱的语言。然而，在使用 python 时，我经常发现自己缺少对总和类型的内置支持。像 haskell 和 rust 这样的语言让这种事情变得如此简单：

data op = add | sub | mul
  deriving (show)

data expr
  = lit integer
  | binop op expr expr
  deriving (show)

val :: expr -> integer
val (lit val) = val
val (binop op lhs rhs) =
  let x = val lhs
      y = val rhs
   in apply op x y

apply :: op -> integer -> integer -> integer
apply add x y = x + y
apply sub x y = x - y
apply mul x y = x * y

val (binop add (binop mul (lit 2) (lit 3)) (lit 4))
-- => 10

虽然 python 不支持这种开箱即用的构造，但我们将看到像 expr 这样的类型仍然可以（并且容易）表达。此外，我们可以创建一个装饰器来为我们处理所有令人讨厌的样板文件。结果与上面的 haskell 示例没有太大不同：

# the `enum` decorator adds methods for constructing and matching on the
# different variants:
@enum(add=(), sub=(), mul=())
class op:
    def apply(self, x, y):
        return self.match(
            add=lambda: x + y,
            sub=lambda: x - y,
            mul=lambda: x * y,
        )


# recursive sum types are also supported:
@enum(lit=(int,), bin_op=lambda: (op, expr, expr))
class expr:
    def val(self):
        return self.match(
            lit=lambda value: value,
            bin_op=lambda op, lhs, rhs: op.apply(lhs.val(), rhs.val()),
        )


expr.bin_op(
    op.add(),
    expr.bin_op(op.mul(), expr.lit(2), expr.lit(3)),
    expr.lit(4)
).val()
# => 10

表示求和类型

我们将使用“标记联合”来表示总和类型。通过示例很容易理解：

class expr:
    def lit(value):
        e = expr()
        e.tag = "lit"
        e.value = value
        return e

    def bin_op(op, lhs, rhs):
        e = expr()
        e.tag = "bin_op"
        e.op = op
        e.lhs = lhs
        e.rhs = rhs
        return e

每个变体都是同一类的实例（在本例中为 expr）。每个都包含一个“标签”，指示它是哪个变体，以及特定于它的数据。

使用 expr 的最基本方法是使用 if-else 链：

class expr:
    # ...
    def val(self):
        if self.tag == "lit":
            return self.value
        elif self.tag == "bin_op":
            x = self.lhs.val()
            y = self.rhs.val()
            return self.op.apply(x, y)

但是，这有一些缺点：

• 在使用 expr 的所有地方都会重复相同的 if-else 链。
• 更改标签的值（例如从“lit”到“literal”）会中断 现有代码。
• 消费总和类型需要了解实现细节（即标签和 每个变体使用的字段名称）。

实施匹配

我们可以通过公开用于消耗总和类型的单个公共匹配方法来避免所有这些问题：

class expr:
    # ...
    def match(self, handlers):
        # ...

但首先我们需要使不同的变体更加统一。每个变体现在不再将其数据存储在各个字段中，而是将其存储在名为 data 的元组中：

class expr:
    def lit(value):
        e = expr()
        e.tag = "lit"
        e.data = (value,)
        return e

    def bin_op(op, lhs, rhs):
        e = expr()
        e.tag = "bin_op"
        e.data = (op, lhs, rhs)
        return e

这使我们能够实现匹配：

class expr:
    # ...
    def match(self, **handlers):
        if self.tag in handlers:
            return handlers[self.tag](*self.data)
        else:
            raise runtimeerror(f"missing handler for {self.tag}")

我们一举解决了上述所有问题！作为另一个例子，为了换个环境，这是以这种方式转录的 rust 选项类型：

class option:
    def some(x):
        o = option()
        o.tag = "some"
        o.data = (x,)
        return o

    def none():
        o = option()
        o.tag = "none"
        o.data = ()
        return o

    def match(self, **handlers):
        if self.tag in handlers:
            return handlers[self.tag](*self.data)
        else:
            raise runtimeerror(f"missing handler for {self.tag}")

    def __repr__(self):
        return self.match(
            some=lambda x: f"option.some({repr(x)})",
            none=lambda: "option.none()",
        )

    def __eq__(self, other):
        if not isinstance(other, option):
            return notimplemented
        return self.tag == other.tag and self.data == other.data

    def map(self, fn):
        return self.match(
            some=lambda x: option.some(fn(x)),
            none=lambda: option.none()
        )

option.some(2).map(lambda x: x**2)
# => option.some(4)

作为生活质量的一项小福利，我们可以在匹配中支持特殊的通配符或“包罗万象”的处理程序，用下划线 (_) 表示：

def match(self, **handlers):
    if self.tag in handlers:
        return handlers[self.tag](*self.data)
    elif "_" in handlers:
        return handlers["_"]()
    else:
        raise runtimeerror(f"missing handler for {self.tag}")

这允许我们使用如下匹配：

def map(self, fn):
    return self.match(
        some=lambda x: option.some(fn(x)),
        _=lambda: option.none(),
    )

实现枚举

正如 option 类所示，创建总和类型所需的许多代码都遵循相同的模式：

class foo:
    # for each variant:
    def my_variant(bar, quux):
        # construct an instance of the class:
        f = foo()
        # give the instance a distinct tag:
        f.tag = "my_variant"
        # save the values we received:
        f.data = (bar, quux)
        return f

    # this is always the same:
    def match(self, **handlers):
        if self.tag in handlers:
            return handlers[self.tag](*self.data)
        elif "_" in handlers:
            return handlers["_"]()
        else:
            raise runtimeerror(f"missing handler for {self.tag}")

我们不用自己编写这个，而是编写一个装饰器来根据变体的一些描述来生成这些方法。

def enum(**variants):
    pass

什么样的描述？最简单的事情是提供变体名称列表，但我们还可以通过提供我们期望的参数类型来做得更好。我们将使用枚举来自动增强我们的 option 类，如下所示：

# add two variants:
# - one named `some` that expects a single argument of any type.
# - one named `none` that expects no arguments.
@enum(some=(object,), none=())
class option:
    pass

枚举的基本结构如下所示：

def enum(**variants):
    def enhance(cls):
        # add methods to the class cls.
        return cls

    return enhance

这是一个返回另一个函数的函数，该函数将使用我们正在增强的类作为其唯一参数来调用。在增强中，我们将附加用于构建每个变体的方法以及匹配。

首先，匹配，因为它只是复制意大利面：

def enhance(cls):
    def match(self, **handlers):
        if self.tag in handlers:
            return handlers[self.tag](*self.data)
        elif "_" in handlers:
            return handlers["_"]()
        else:
            raise valueerror(f"missing handler for {self.tag}")

    # add a method named "match" to the class cls, whose value is the
    # `match` function defined above:
    setattr(cls, "match", match)

    return cls

添加方法来构造每个变体只是稍微复杂一些。我们迭代变体字典，为每个条目定义一个方法：

def enhance(cls):
    # ...
    for tag, sig in variants.items():
        setattr(cls, tag, make_constructor(tag, sig))

    return cls

其中 make_constructor 为带有标签（和名称）标签和“类型签名”sig 的变体创建构造函数：

def enhance(cls):
    # ...
    def make_constructor(tag, sig):
        def constructor(*data):
            # validate the data passed to the constructor:
            if len(sig) != len(data):
                raise valueerror(f"expected {len(sig)} items, not {len(data)}")
            for x, ty in zip(data, sig):
                if not isinstance(x, ty):
                    raise typeerror(f"expected {ty} but got {repr(x)}")

            # just a generalization of what we've seen above:
            inst = cls()
            inst.tag = tag
            inst.data = data
            return inst

        return constructor

    for tag, sig in variants.items():
        setattr(cls, tag, make_constructor(tag, sig))

    return cls

这里是 enum 的完整定义，供参考。

奖励功能

更多邓德方法

我们可以使用 __repr__ 和 __eq__ 方法轻松增强我们的 sum 类：

def enhance(cls):
    # ...
    def _repr(self):
        return f"{cls.__name__}.{self.tag}({', '.join(map(repr, self.data))})"

    setattr(cls, "__repr__", _repr)

    def _eq(self, other):
        if not isinstance(other, cls):
            return notimplemented
        return self.tag == other.tag and self.data == other.data

    setattr(cls, "__eq__", _eq)

    return cls

通过以这种方式改进增强功能，我们可以以最小的方式定义选项：

@enum(some=(object,), none=())
class option:
    def map(self, fn):
        return self.match(
            some=lambda x: option.some(fn(x)),
            _=lambda: option.none(),
        )

递归定义

不幸的是，枚举（还）无法完成定义 expr 的任务：

@enum(add=(), sub=(), mul=())
class op:
    pass

@enum(lit=(int,), bin_op=(op, expr, expr))
class expr:
    pass

# nameerror: name 'expr' is not defined

我们在定义类 expr 之前使用它。这里一个简单的解决方法是在定义类后简单地调用装饰器：

class expr:
    pass

enum(lit=(int,), bin_op=(op, expr, expr))(expr)

但是我们可以做一个简单的改变来支持这一点：允许“签名”是一个返回元组的函数：

@enum(lit=(int,), bin_op=lambda: (op, expr, expr))
class expr:
    pass

所有这些都需要对 make_constructor 进行一些小的更改：

def make_constructor(tag, sig):
    def constructor(*data):
        nonlocal sig
        # if sig is a "thunk", thaw it out:
        if callable(sig):
            sig = sig()

        # ...

结论

尽管我们精美的新枚举装饰器可能很有用，但它也有其缺点。最明显的是无法执行任何类型的“嵌套”模式匹配。在 rust 中，我们可以做这样的事情：

fn foo<t: debug>(x: option<option<t>>) {
    match x {
        some(some(value)) => println!("{:?}", value),
        _ => {}
    }
}

但是我们被迫执行双重匹配才能获得相同的结果：

def foo(x):
    return x.match(
        some=lambda x1: x1.match(
            some=lambda value: print(value),
            _=lambda: None
        ),
        _=lambda: None
    )

也就是说，此类案例似乎相对很少见。

另一个缺点是匹配需要构造和调用大量函数。这意味着它可能比等效的 if-else 链慢得多。然而，通常的经验法则适用于此：如果您喜欢枚举的人体工学优势，请使用枚举；如果它太慢，则将其替换为“生成的”代码。

今天带大家了解了的相关知识，希望对你有所帮助；关于文章的技术知识我们会一点点深入介绍，欢迎大家关注golang学习网公众号，一起学习编程~