> def foo(a: t1, b: t2) -> t3:
>     ...

> @typechecking(a=t1, b=t2, __return__=t3)
> def foo(a, b):
>     ...

def typecheck(signature):
    def maketypecheckedfunction(fn):
        ...look up __typecheck__...
        ...make wrapper...
        return __typecheck__(fn, signature)
    return maketypecheckedfunction

O = VoodooType()

# assumes syntax for "signature" literals: def() -> type
# the rest uses operator overloading hacks
readable = (O.read == def() -> str) & (O.readlines == def() -> iter[str])
writeable = O.write == def(str) -> None
printf = def(str, *any) -> str

from some_type_system import *
O = VoodooType()

# no special syntax.  
readable = (O.read() == IStr) & (O.readlines() == IIter[IStr])
writeable = O.write(IStr) == INone
# star would wrap IAny for the code inside O.__call__ to detect
printf = O(str, *star(IAny)) == None

def foo(a, b): # Typechecking wrapper
    a = __typecheck__(a, t1)
    b = __typecheck__(b, t2)
    r = foo__(a, b)
    r = __typecheck__(r, t3)  ## <-- instead of r = __typecheck__(t3)
    return r

def MyType(type):
    def __typecheck__(a,T):
        "typechecking code here"

def driveSomeCar(car):
    car.drive()

interface worker:
  work(time: number):
    """Work for an amount of time"""
  wage -> number:
    """How much do we pay this fellow?"""
  write_resume(resumefile: file_like):
    """Prepare for a new job"""
  complain() -> iterator_of_strings:
    """Complaints"""
  pay(paycheck: number):
    """Actually pay the worker!"""

class human_employee(person) implements worker:
  def work(self,time: number):
    ...

  def complain(self) -> iterator_of_strings:
    while 1:
      yield "pay me more"

  def write_resume(self,resumefile: file_like):
    resumefile.write(self._resume)
    return two_weeks_notice(self)

  def pay(self,paycheck: number):
    ...

def routine(w: worker):
  w.work()
  pay(w,w.wage())

class robot(person):
  def work(self,time):
    ...

  def wage(self):
    return 0

  def pay(self,paycheck):
    pass

  def write_resume(self,resumefile):
    resumefile.write(self._manufacturers_brochure)

  def complain():
    return iter( () )

# Note the following syntax, this allows much easier 
# integration in post
implement worker with robot

magic_implement_list = [ (number, int), (number, float), ]

for iface,datatype in magic_implement_list:
  implement iface with datatype

def f(a, b:t1) -> t2:
    ...

def f(a:object, b:t1) -> t2:
    ...