code: public Environment checkConditions(Tuple<Expr> conditions, boolean sign, Environment environment) {
  		for (Expr e : conditions) {
  			// Thread environment through from before
  			environment = checkCondition(e, sign, environment);
  		}
  		return environment;
  	}
docs: Type check a sequence of zero or more conditions, such as the requires clause
  of a function or method. The environment from each condition is fed into the
  following. This means that, in principle, type tests influence both
  subsequent conditions and the remainder. The following illustrates:
  
  <pre>
  function f(int|null x) -> (int r)
  requires x is int
  requires x >= 0:
  //
  return x
  </pre>
  
  This type checks because of the initial type test <code>x is int</code>.
  Observe that, if the order of <code>requires</code> clauses was reversed,
  this would not type check. Finally, it is an interesting question as to why
  the above ever make sense. In general, it's better to simply declare
  <code>x</code> as type <code>int</code>. However, in some cases we may be
  unable to do this (for example, to preserve binary compatibility with a
  previous interface).
  
  @param conditions
  @param sign
  @param environment
  @return