-- TODO: build some generic benchmark harness
[case testBenchmarkTree]
from typing import Optional
class Node:
    def __init__(self, value: int) -> None:
        self.value = value
        self.left = None  # type: Optional[Node]
        self.right = None  # type: Optional[Node]
    def sum(self) -> int:
        left = 0
        if self.left is not None:
            left = self.left.sum()
        right = 0
        if self.right is not None:
            right = self.right.sum()
        return self.value + left + right
def sum_tree(x: Optional[Node]) -> int:
    if x is None:
        return 0
    return x.value + sum_tree(x.left) + sum_tree(x.right)
def build(n: int) -> Optional[Node]:
    if n == 0:
        return None
    x = Node(n)
    x.left = build(n - 1)
    x.right = x.left
    return x

def bench_sum(x: Optional[Node]) -> None:
    for i in range(1000000):
        sum_tree(x)
def bench_sum_method(x: Node) -> None:
    for i in range(1000000):
        x.sum()
[file driver.py]
from typing import Optional
import native
import interpreted
from timeit import timeit
from time import time
import os

def dumb_time(f):
    t0 = time()
    f()
    t1 = time()
    return t1 - t0

def basic_test(m):
    tree = m.build(5)
    assert(m.sum_tree(tree) == 57)
    assert(tree.sum() == 57)
    return tree

def test(m):
    tree = basic_test(m)

    g = {**globals(), **locals()}
    sum = timeit('m.sum_tree(tree)', globals=g)
    sum2 = timeit('tree.sum()', globals=g)
    fsum = dumb_time(lambda: m.bench_sum(tree))
    fsum2 = dumb_time(lambda: m.bench_sum_method(tree))
    build = timeit('m.build(5)', globals=g)
    return (sum, sum2, fsum, fsum2, build)

# Basic functionality test
basic_test(native)

# Benchmark if we are benchmarking
if os.environ.get('MYPYC_RUN_BENCH') == '1':
    nsum, nsum2, nfsum, nfsum2, nbuild = test(native)
    isum, isum2, ifsum, ifsum2, ibuild = test(interpreted)
    print(nsum, nsum2, nfsum, nbuild)
    print("Sum speedup:", isum/nsum)
    print("Sum method speedup:", isum2/nsum2)
    print("Sum (fast) speedup:", ifsum/nfsum)
    print("Sum (fast) method speedup:", ifsum2/nfsum2)
    print("Build speedup:", ibuild/nbuild)

[case testBenchmarkVisitorTree]
from mypy_extensions import trait
from typing import cast, Generic, TypeVar, Any

T = TypeVar('T')
class Tree:
    def accept(self, v: 'TreeVisitor[T]') -> T:
        pass
class Leaf(Tree):
    def accept(self, v: 'TreeVisitor[T]') -> T:
        return v.visit_leaf(self)
class Node(Tree):
    def __init__(self, value: int, left: Tree, right: Tree) -> None:
        self.value = value
        self.left = left
        self.right = right
    def accept(self, v: 'TreeVisitor[T]') -> T:
        return v.visit_node(self)

@trait
class TreeVisitor(Generic[T]):
    def visit_leaf(self, x: Leaf) -> T: return cast(T, None)
    def visit_node(self, x: Node) -> T: return cast(T, None)

class SumVisitor(TreeVisitor[int]):
    def sum(self, x: Tree) -> int:
        return x.accept(self)
    def visit_leaf(self, x: Leaf) -> int:
        return 0
    def visit_node(self, x: Node) -> int:
        return x.value + self.sum(x.left) + self.sum(x.right)

def equal(x: Tree, y: Tree) -> bool:
    return EqualVisitor(x).equal(y)

class EqualVisitor(TreeVisitor[bool]):
    def __init__(self, left: Tree) -> None:
        self.left = left
    def equal(self, right: Tree) -> bool:
        return right.accept(self)
    def visit_leaf(self, right: Leaf) -> bool:
        return isinstance(self.left, Leaf)
    def visit_node(self, right: Node) -> bool:
        if isinstance(self.left, Node):
            # our boolean stuff is crap
            if (self.left.value == right.value and equal(self.left.left, right.left)
                    and equal(self.left.right, right.right)):
                return True
        return False

def sum_tree(x: Tree) -> int:
    return SumVisitor().sum(x)

def build(n: int) -> Tree:
    if n == 0:
        return Leaf()
    return Node(n, build(n - 1), build(n - 1))

def bench_sum_tree(x: Tree) -> None:
    for i in range(100000):
        sum_tree(x)
def bench_equal_tree(x: Tree, y: Tree) -> None:
    for i in range(100000):
        equal(x, y)

[file driver.py]
from typing import Optional
import interpreted
import native
from timeit import timeit
from time import time
import os
import sys

# Side test: some stuff about MROs and generics
if sys.version_info[:3] > (3, 5, 2):
    assert tuple(x.__name__ for x in interpreted.SumVisitor.mro()) == ('SumVisitor', 'TreeVisitor', 'Generic', 'object')
    assert tuple(x.__name__ for x in native.SumVisitor.mro()) == ('SumVisitor', 'TreeVisitor', 'Generic', 'object')
    assert str(native.TreeVisitor[native.T]) == "native.TreeVisitor[~T]"

assert native.TreeVisitor.__name__ == "TreeVisitor"
assert native.SumVisitor.__name__ == "SumVisitor"

def dumb_time(f):
    t0 = time()
    f()
    t1 = time()
    return t1 - t0

def basic_test(m):
    tree = m.build(5)
    tree2 = m.build(5)
    tree2.right.right.right.value = 10
    assert m.sum_tree(tree) == 57
    assert m.equal(tree, tree)
    assert not m.equal(tree, tree2)

    assert isinstance(native.SumVisitor(), native.TreeVisitor)

    return tree

def test(m):
    tree = basic_test(m)

    g = {**globals(), **locals()}
    fsum = dumb_time(lambda: m.bench_sum_tree(tree))
    feq = dumb_time(lambda: m.bench_equal_tree(tree, tree))
    return fsum, feq

basic_test(native)

if os.environ.get('MYPYC_RUN_BENCH') == '1':
    nfsum, nfeq = test(native)
    ifsum, ifeq = test(interpreted)
    print(nfsum)
    print("Sum speedup:", ifsum/nfsum)
    print("Equal speedup:", ifeq/nfeq)