code: public Type.Callable selectLambda(Type target, Expr expr, Environment environment) {
  		Type.Callable type = asType(expr.getType(), Type.Callable.class);
  		// Construct the default case for matching against any
  		Type.Callable anyType = new Type.Function(type.getParameters(), TUPLE_ANY);
  		// Create the filter itself
  		AbstractTypeFilter<Type.Callable> filter = new AbstractTypeFilter<>(Type.Callable.class, anyType);
  		//
  		return selectCandidate(filter.apply(target), type, environment);
  	}
docs: <p>
  Given an arbitrary target type, filter out the target lambda types. For
  example, consider the following method:
  </p>
  
  
  <pre>
  type fun_t is function(int)->(int)
  
  method f(int x):
  fun_t|null xs = &(int y -> y+1)
  ...
  </pre>
  <p>
  When type checking the expression <code>&(int y -> y+1)</code> the flow type
  checker will attempt to determine an <i>expected</i> lambda type. In order to
  then determine the appropriate expected type for the lambda body
  <code>y+1</code> it filters <code>fun_t|null</code> down to just
  <code>fun_t</code>.
  </p>
  
  @param target
  Target type for this value
  @param expr
  Source expression for this value
  @author David J. Pearce