C[omp]ute

From: andrew cooke <andrew@...>

Date: Sat, 23 Apr 2011 10:26:05 -0300

It's common to use callbacks to adapt some behaviour.  But they don't play so
well with error conditions:

  def some_function(callback):
      if condition:
          return callback(data)
      else:
          raise Exception

In the code above there's no way for the callback to handle the error
condition.  We can avoid this with a callback object:

  def some_function(callback):
      if condition:
          return callback.data(data)
      else:
          return callback.error()

but that becomes tedious to use in a language like Python where defining a
class is quite verbose (there's no class equivalent of lambda functions).

A better solution is to use a generator:

  def some_function(callback):
      def invert():
	  if condition:
              yield data
	  else:
	      raise Exception
      return callback(invert())

because this lets the callback access both the data and the exception.

A more concrete example is in pytyp - I have general code to recurse over data
and types (a kind of fold) and I want to use that to perform a structural
check of type safety.  But that means that my callback must handle both normal
values and type errors.

[Next version of pytyp is still in development, but will be much more centred
around types in Python - the functionality will be similar to what exists now,
but the implementation is much better integrated into the language.  I am also
working on a paper that describes the ideas and design.]

Andrew