code: @Override
  	public Type.Callable bind(Decl.Binding<Type.Callable,Decl.Callable> binding, Tuple<? extends SemanticType> types,
  			LifetimeRelation environment) {
  		// Now attempt to bind the given candidate declarations against the concrete
  		// argument types.
  		Decl.Link<Decl.Callable> link = binding.getLink();
  		List<Decl.Callable> candidates = link.getCandidates();
  		Tuple<SyntacticItem> templateArguments = binding.getArguments();
  		// Bind candidate types to given argument types which, in particular, will
  		// produce bindings for template variables
  		List<Binding> bindings = bindCallableCandidates(candidates, types, templateArguments, environment);
  		// Sanity check bindings generated
  		if (!bindings.isEmpty()) {
  			// Select the most precise signature from the candidate bindings
  			Binding selected = selectCallableCandidate(link.getName(), bindings, environment);
  			// Check whether one was selected or not
  			if(selected != null) {
  				// Assign descriptor to this expression
  				link.resolve(selected.getCandidateDeclaration());
  				// Set inferred lifetime parameters as well
  				binding.setArguments(link.getHeap().allocate(selected.getArguments()));
  				//
  				return selected.getConcreteType();
  			}
  		}
  		return null;
  	}
docs: Determine appropriate lifetime bindings for a given set of candidate function
  or method declarations and concrete argument types. For example:
  
  <pre>
  method f<a>(&a:int ptr):
  ...
  
  method g() -> int:
  &this:int ptr = this::new(1)
  f(ptr)
  return *ptr
  </pre>
  
  Here, the invocation <code>f(ptr)</code> needs to bind the parameter type
  <code>&a:int</code> with the concrete argument type <code>&this:int</code> by
  mapping lifetime parameter <code>a</code> to lifetime argument
  <code>this</code>.
  
  @param link
  @param candidates
  @param arguments
  @param lifetimeArguments
  @param lifetimes
  @return