GFElementFuture ops should sometimes return sharefuture

[amiller]

This logic for gfelement future is too conservative:
https://github.com/initc3/HoneyBadgerMPC/blob/dev/honeybadgermpc/progs/mixins/dataflow.py#L15

    def __binop_field(self, other, op):
        assert callable(op)

        if isinstance(other, int):
            other = self.context.field(other)

        res = GFElementFuture()
        ...

Since it always returns a GFElementFuture.
But it should be possible to multiply a GFElementFuture by a Share, which should result in a ShareFuture. This is how beaver multiplication works in mpc.py:test_prog1:

    e = (y - b).open()
    await d
    await e

    # This is a random share of x*y
    logging.info(f'type(d): {type(d)}')  # GFElementFuture
    logging.info(f'type(b): {type(b)}')  # Share
    xy = d*e + d*b + e*a + ab

    logging.info(f'type(x): {type(x)}')  # Share
    logging.info(f'type(y): {type(y)}')  # Share
    logging.info(f'type(xy): {type(xy)}')  # GFElementFuture, but should be Share
    x_, y_, xy_ = await x.open(), await y.open(), await xy.open()

The solution would be:

• add Share and ShareFuture to the typecheck options for GFElementFuture, and
• have the return object for this be ShareFuture if the arg type is Share or ShareFuture

[Drake-Eidukas]

I think we can actually accomplish this by modifying the type-checking.
If a special built-in method (__add__, for example) returns NotImplemented instead of raising an AssertionError, then it will call __radd__ on the other operand. Thus, we would be able to call code like fut + share and it will call share.__radd__(fut) and we don't have to have duplicate logic to handle this.

We can achieve this logic by using if __debug__ to see if we're not running with -O, as this will completely strip out the contents of the if statement.

[Drake-Eidukas]

Example:

class TypeC:
    def __init__(self, val):
        self.val = val    

    def __add__(self, other):
        if not isinstance(other, TypeC):
            return NotImplemented           

        return TypeC(self.val + other.val)

class TypeD:
    def __init__(self, val):
        self.val = val

    def __add__(self, other):
        if not isinstance(other, (TypeC, TypeD)):
            return NotImplemented

        return TypeD(self.val + other.val)

    def __radd__(self, other):
        if not isinstance(other, (TypeC, TypeD)):
            return NotImplemented

        return TypeD(self.val + other.val)

c = TypeC(4)
d = TypeD(5)

Then, calling c+d will return a TypeD.