Python 中的求和类型

百变鹏仔 4天前 #Python

文章标签类型

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

data op = add | sub | mul  deriving (show)data expr  = lit integer  | binop op expr expr  deriving (show)val :: expr -> integerval (lit val) = valval (binop op lhs rhs) =  let x = val lhs      y = val rhs   in apply op x yapply :: op -> integer -> integer -> integerapply add x y = x + yapply sub x y = x - yapply mul x y = x * yval (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)

但是，这有一些缺点：

实施匹配

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

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 的完整定义，供参考。

立即学习“Python免费学习笔记（深入）”；

奖励功能

递归定义

不幸的是，枚举（还）无法完成定义 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:    passenum(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 链慢得多。然而，通常的经验法则适用于此：如果您喜欢枚举的人体工学优势，请使用枚举；如果它太慢，则将其替换为“生成的”代码。

文章推荐

Python 中的求和类型

表示求和类型

实施匹配

实现枚举

奖励功能

更多邓德方法

递归定义

结论

2020年适用于Linux程序员的10个最佳Python集成开发环境

获取字典中的第一个和最后一个元素的Python程序

在Python中漂亮地打印XML

Python日志基础 - 简易指南

如何在Python中创建静态类数据和静态类方法？