Unification

Straightforward Unification, extensible via dispatch.

Examples

>>> from unification import *
>>> unify(1, 1)
{}
>>> unify(1, 2)
False
>>> x = var('x')

>>> unify((1, x), (1, 2))
{~x: 2}

>>> unify((x, x), (1, 2))
False

@unifiable
class Account(object):
    def __init__(self, id, name, balance):
        self.id = id
        self.name = name
        self.balance = balance

data = [Account(1, 'Alice', 100),
        Account(2, 'Bob', 0),
        Account(2, 'Charlie', 0),
        Account(2, 'Denis', 400),
        Account(2, 'Edith', 500)]

id, name, balance = var('id'), var('name'), var('balance')

>>> [unify(Account(id, name, balance), acct) for acct in data]
[{~name: 'Alice', ~balance: 100, ~id: 1},
 {~name: 'Bob', ~balance: 0, ~id: 2},
 {~name: 'Charlie', ~balance: 0, ~id: 2},
 {~name: 'Denis', ~balance: 400, ~id: 2},
 {~name: 'Edith', ~balance: 500, ~id: 2}]

>>> [unify(Account(id, name, 0), acct) for acct in data]
[False,
 {~name: 'Bob', ~id: 2},
 {~name: 'Charlie', ~id: 2},
 False,
 False]

Function Dispatch

Unification supports function dispatch through pattern matching.

from unification.match import *

n = var('n')
@match(0)
def fib(n):
    return 0

@match(1)
def fib(n):
    return 1

@match(n)
def fib(n):
    return fib(n - 1) + fib(n - 2)

>>> map(fib, [0, 1, 2, 3, 4, 5, 6, 7, 8, 0])
[0, 1, 1, 2, 3, 5, 8, 13, 21, 34]

This patten matching can be fairly complex

name, amount = var('name'), var('amount')

@match({'status': 200, 'data': {'name': name, 'credit': amount}})
def respond(name, amount):
    balance[name] +=  amount


@match({'status': 200, 'data': {'name': name, 'debit': amount}})
def respond(name, amount):
    balance[name] -= amount


@match({'status': 404})
def respond():
    print("Bad Request")

See full example in the examples directory.

Performance and Reliability

This was hacked together. Unification stresses extensibility over performance, preliminary benchmarks show that this is 2-5x slower than straight tuple-based unification.

This is somewhat reliable, the only caveat is on set unification which is challenging to do generally within this framework. It should work well in moderately complex cases but break down under very complex ones.

History

This was carved out from the LogPy and Multiple Dispatch projects.

Author

Matthew Rocklin