Thanks Rust!

result.py

#!/usr/bin/env python
# -*- coding: utf-8 -*-

import sys
import copy

PY2 = sys.version_info[0] == 2


class Result(object):
    def __new__(cls, *args, **kwargs):
        if cls is Result:
            raise RuntimeError("Please do not use Result directly.")
        return object.__new__(cls)

    def __init__(self, data=None):
        if isinstance(data, Result):
            data = data.unwrap()
        self.data = data

    def unwrap(self):
        if hasattr(self.data, "__call__"):
            return self.data()
        else:
            return self.data


    """ Proxying, bring from werkzeug's LocalProxy.
    """
    @property
    def __dict__(self):
        try:
            return self.data.__dict__
        except RuntimeError:
            raise AttributeError('__dict__')

    def __repr__(self):
        try:
            obj = self.data
        except RuntimeError:
            return '<%s unbound>' % self.__class__.__name__
        return repr(obj)

    def __unicode__(self):
        try:
            return unicode(self.data)  # noqa
        except RuntimeError:
            return repr(self)

    def __dir__(self):
        try:
            return dir(self.data)
        except RuntimeError:
            return []

    if PY2:
        __getslice__ = lambda x, i, j: x.data[i:j]

        def __setslice__(self, i, j, seq):
            self.data[i:j] = seq

        def __delslice__(self, i, j):
            del self.data[i:j]

    __getattr__ = lambda x, n: getattr(x.data, n)
    __str__ = lambda x: str(x.data)
    __lt__ = lambda x, o: x.data < o
    __le__ = lambda x, o: x.data <= o
    __eq__ = lambda x, o: x.data == o
    __ne__ = lambda x, o: x.data != o
    __gt__ = lambda x, o: x.data > o
    __ge__ = lambda x, o: x.data >= o
    __cmp__ = lambda x, o: cmp(x.data, o)  # noqa
    __hash__ = lambda x: hash(x.data)
    __call__ = lambda x, *a, **kw: x.data(*a, **kw)
    __len__ = lambda x: len(x.data)
    __getitem__ = lambda x, i: x.data[i]
    __iter__ = lambda x: iter(x.data)
    __contains__ = lambda x, i: i in x.data
    __add__ = lambda x, o: x.data + o
    __sub__ = lambda x, o: x.data - o
    __mul__ = lambda x, o: x.data * o
    __floordiv__ = lambda x, o: x.data // o
    __mod__ = lambda x, o: x.data % o
    __divmod__ = lambda x, o: x.data.__divmod__(o)
    __pow__ = lambda x, o: x.data ** o
    __lshift__ = lambda x, o: x.data << o
    __rshift__ = lambda x, o: x.data >> o
    __and__ = lambda x, o: x.data & o
    __xor__ = lambda x, o: x.data ^ o
    __or__ = lambda x, o: x.data | o
    __div__ = lambda x, o: x.data.__div__(o)
    __truediv__ = lambda x, o: x.data.__truediv__(o)
    __neg__ = lambda x: -(x.data)
    __pos__ = lambda x: +(x.data)
    __abs__ = lambda x: abs(x.data)
    __invert__ = lambda x: ~(x.data)
    __complex__ = lambda x: complex(x.data)
    __int__ = lambda x: int(x.data)
    __long__ = lambda x: long(x.data)  # noqa
    __float__ = lambda x: float(x.data)
    __oct__ = lambda x: oct(x.data)
    __hex__ = lambda x: hex(x.data)
    __index__ = lambda x: x.data.__index__()
    __coerce__ = lambda x, o: x.data.__coerce__(x, o)
    __enter__ = lambda x: x.data.__enter__()
    __exit__ = lambda x, *a, **kw: x.data.__exit__(*a, **kw)
    __aenter__ = lambda x: x.data.__aenter__()
    __aexit__ = lambda x, *a, **kw: x.data.__aexit__(*a, **kw)
    __radd__ = lambda x, o: o + x.data
    __rsub__ = lambda x, o: o - x.data
    __rmul__ = lambda x, o: o * x.data
    __rdiv__ = lambda x, o: o / x.data
    if PY2:
        __rtruediv__ = lambda x, o: x.data.__rtruediv__(o)
    else:
        __rtruediv__ = __rdiv__
    __rfloordiv__ = lambda x, o: o // x.data
    __rmod__ = lambda x, o: o % x.data
    __rdivmod__ = lambda x, o: x.data.__rdivmod__(o)
    __copy__ = lambda x: copy.copy(x.data)
    __deepcopy__ = lambda x, memo: copy.deepcopy(x.data, memo)


    """ From Rust lang, maybe useless.
    """

    def isOk(self):
        return bool(self)

    def isErr(self):
        return not bool(self)

    def ok(self):
        if self.isOk():
            return self.unwrap()
        else:
            return None

    def err(self):
        if self.isErr():
            return self.unwrap()
        else:
            return None

    def and_then(self, fn):
        assert(hasattr(fn, "__call__"))
        if self.isOk():
            return self.__class__(fn())
        else:
            return self

    def or_else(self, fn):
        assert(hasattr(fn, "__call__"))
        if self.isErr():
            return self.__class__(fn())
        else:
            return self


class Ok(Result):
    def __nonzero__(self):
        return True

    def __bool__(self):
        return True


class Err(Result):
    def __nonzero__(self):
        return False

    def __bool__(self):
        return False


Result.Ok = Ok
Result.Err = Err