def add(a: int, b: float):
    return a + b

assrt.ok(add.__annotations__)
assrt.equal(add.__annotations__['a'], int)
assrt.equal(add.__annotations__['b'], float)
assrt.equal(add.__annotations__['return'], undefined)

def sum(ls: list) -> int:
    pass

assrt.ok(not (sum.__annotations__ == undefined))
assrt.deepEqual(sum.__annotations__, {
    'ls': list,
    'return': int
})

def optional(a:int=10):
    return a

assrt.ok(not (optional.__annotations__ == undefined))
assrt.equal(optional.__annotations__.a, int)
assrt.equal(optional.__defaults__.a, 10)

def otherexpr(a:3+4) -> [1, 2]:
    pass

assrt.ok(not (otherexpr.__annotations__ == undefined))
assrt.equal(otherexpr.__annotations__['a'], 7)
assrt.deepEqual(otherexpr.__annotations__['return'], [1, 2])

def basic(x:float):
    pass

assrt.deepEqual(basic.__annotations__, {
    'x': float
})

def kwstarargs(*args:list, **kwargs:dict) -> int:
    pass

assrt.equal(kwstarargs.__annotations__['return'], int)

def nothing():
    pass

assrt.ok(nothing.__annotations__ == undefined)
assrt.throws(def():
    nothing.__annotations__['return']
)

test = def(x: int):
    pass

assrt.deepEqual(test.__annotations__, {
    'x': int
})

anonreturn = def() -> 'test':
    pass

assrt.equal(anonreturn.__annotations__['return'], 'test')

assrt.equal(def asexpr(a: int):
    a
.__annotations__['a'], int)

assrt.deepEqual(def(a: int) -> float:
    a + 10.0
.__annotations__, {
    'a': int,
    'return': float
})

class A:

    def f(self, a : int, b: 'x') -> float:
        pass

assrt.deepEqual(A.prototype.f.__annotations__, {'a':int, 'b':'x', 'return': float})