简体中文(ZH-CN) English(EN) 繁体中文(ZH-TW) 日本語(JA) 한국어(KO) Melayu(MS) Français(FR) Deutsch(DE)
首页 > 后端开发 > Python教程 > 正文

Python 中的求和类型

Mary-Kate Olsen
发布： 2024-10-19 06:18:02
原创
647 人浏览过

Sum Types in 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
登录后复制

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

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
登录后复制
登录后复制

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

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

# 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
登录后复制
登录后复制

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

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)
登录后复制
登录后复制

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

奖励功能

更多邓德方法

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

class Expr:
    # ...
    def match(self, handlers):
        # ...
登录后复制
登录后复制

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

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
登录后复制
登录后复制

递归定义

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

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}")
登录后复制
登录后复制

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

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}")
登录后复制
登录后复制

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

def map(self, fn):
    return self.match(
        some=lambda x: Option.some(fn(x)),
        _=lambda: Option.none(),
    )
登录后复制
登录后复制

结论

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

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
登录后复制
登录后复制

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

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

以上是Python 中的求和类型的详细内容。更多信息请关注PHP中文网其他相关文章！

来源：dev.to
上一篇：如何在 VS Code 中运行时隐藏 Python 脚本中的文件路径？ 下一篇：如何使用 Selenium Python 从 Shadow Root 中提取数据？
本站声明
本文内容由网友自发贡献，版权归原作者所有，本站不承担相应法律责任。如您发现有涉嫌抄袭侵权的内容，请联系admin@php.cn
作者最新文章
最新问题
function_exists()无法判定自定义函数 function test()    {        return true;    }    if (function_exists('TEST')) {        ech...
来自于 2024-04-29 11:01:01
0
2
1616
google 浏览器 手机版显示的怎么实现 老师您好，google 浏览器怎么变成手机版样式的？
来自于 2024-04-23 00:22:19
0
10
1770
子窗口操作父窗口，输出没反应 前两句可执行，最后一句没法应
来自于 2024-04-19 15:37:47
0
1
1511
父窗口没有输出 document.onclick = function(){ window.opener.document.write('我是子窗口的输出');                  ...
来自于 2024-04-18 23:52:34
0
1
1423
关于CSS思维导图的课件在哪？ 课件
来自于 2024-04-16 10:10:18
0
0
1468
相关专题
更多>
热门推荐
热门教程
更多>
相关教程
热门推荐
最新课程
最新下载
更多>
网站特效
网站源码
网站素材
前端模板
关于我们 免责声明 Sitemap
PHP中文网：公益在线PHP培训，帮助PHP学习者快速成长！