Best way to define algebraic data types in Python? [closed]

Answer 1

I have developed a simple library that allows one to define tagged unions based on @dataclases with optional fields here:

https://pypi.org/project/tagged-dataclasses/

Answer 2

Macropy provides algebraic data types, pattern matching and more!

Answer 3

In Python variables already can have multiple instances (not simultaneously of course).

>>> x = 5 
>>> type(x)
<type 'int'>
>>> x = ["you", "me", "them"]
>>> type(x)
<type 'list'> 

For example in your code you can do:

def f(x):

    if isinstance(x, int):
        pass
    elif isinstance(x, float):
        pass
    else:
        raise TypeError

If you want to stay closer to Haskell you can do something like this. Say in Haskell you have

data Item = Person String Int String | Car String Bool

In Python 3.6 you write

def g(x):
    tag, *values = x

    if tag == 'Person':
        name, age, e_mail_address = values

        # do something
        pass
    elif tag == 'Car':    
        brand, is_diesel = values

        # do something
        pass
    else:
        raise TypeError

In Haskell it is also called 'sum types'.

An alternative is to use classes. Makes more explicit what is going on. For example Haskell's Either is

data Either a b = Left a | Right b

In Python Either Int Float it will be something like

class Either:

    def __init__(self, a=None, b=None):
        if (a is None) and (b is not None):                 
            self._left  = None
            self._right = float(b) 
        elif (a is not None) and (b is None): 
            self._left  = int(a)
            self._right = None
        else:
            raise TypeError 

    @property
    def is_left(self): 
        return self._left is not None

    @property
    def is_right(self):
        return self._right is not None

    @property 
    def value(self):
        if self.is_left:
            return self._left
        elif self.is_right:
            return self._right 

    def __eq__(self, other):
        if isinstance(other, Either):
            if self.is_left == other.is_left:
                return self.value == other.value 
            else:
                return False   
        else:
            raise TypeError 

    def __str__(self):
        return str(self.value)

Answer 4

Here's an implementation of sum types in relatively Pythonic way.

import attr


@attr.s(frozen=True)
class CombineMode(object):
    kind = attr.ib(type=str)
    params = attr.ib(factory=list)

    def match(self, expected_kind, f):
        if self.kind == expected_kind:
            return f(*self.params)
        else:
            return None

    @classmethod
    def join(cls):
        return cls("join")

    @classmethod
    def select(cls, column: str):
        return cls("select", params=[column])

Crack open an interpreter and you'll see familiar behavior:

>>> CombineMode.join()
CombineMode(kind='join_by_entity', params=[])

>>> CombineMode.select('a') == CombineMode.select('b')
False

>>> CombineMode.select('a') == CombineMode.select('a')
True

>>> CombineMode.select('foo').match('select', print)
foo

Note: The @attr.s decorator comes from the attrs library, it implements __init__, __repr__, and __eq__, but it also freezes the object. I included it because it cuts down on the implementation size, but it's also widely available and quite stable.

Sum types are sometimes called tagged unions. Here I used the kind member to implement the tag. Additional per-variant parameters are implemented via a list. In true Pythonic fashion, this is duck-typed on the input & output sides but not strictly enforced internally.

I also included a match function that does basic pattern matching. Type safety is also implemented via duck typing, a TypeError will be raised if the passed lambda's function signature doesn't align with the actual variant you're trying to match on.

These sum types can be combined with product types (list or tuple) and still retain a lot of the critical functionality required for algebraic data types.

Problems

This doesn't strictly constrain the set of variants.

Answer 5

The typing module provides Union which, dissimilar to C, is a sum type. You'll need to use mypy to do static type checking, and there's a notable lack of pattern matching, but combined with tuples (product types), that's the two common algebraic types.

from dataclasses import dataclass
from typing import Union


@dataclass
class Point:
    x: float
    y: float


@dataclass
class Circle:
    x: float
    y: float
    r: float


@dataclass
class Rectangle:
    x: float
    y: float
    w: float
    h: float


Shape = Union[Point, Circle, Rectangle]


def print_shape(shape: Shape):
    if isinstance(shape, Point):
        print(f"Point {shape.x} {shape.y}")
    elif isinstance(shape, Circle):
        print(f"Circle {shape.x} {shape.y} {shape.r}")
    elif isinstance(shape, Rectangle):
        print(f"Rectangle {shape.x} {shape.y} {shape.w} {shape.h}")


print_shape(Point(1, 2))
print_shape(Circle(3, 5, 7))
print_shape(Rectangle(11, 13, 17, 19))
# print_shape(4)  # mypy type error