anchor.diff:      Dom = lists:nth(random:uniform(Length), DomList),
       pick(Dom, SampleSize).
   
  -%% @doc Returns the doamin of Val.
  --spec return(Val::Type) -> domain(Type).
  +%% @doc Returns the domain containing exactly `Value'.  
  +%% Triq uses internally records of type `@'; and so to avoid
  +%% interpretation of such values you can wrap it with this.  This would
  +%% be the case if you have constants in your domains contain the atom `@'.
  +%% I.e., the following would break because Triq tries to interpret the `@':
  +%%<pre>?FORALL(X, [int(), {'@', 4}], 
  +%%   [IntVal, {'@', 4}] = X
  +%%)</pre>
  +%%To fix it, do like this:
  +%%<pre>?FORALL(X, [int(), return({'@', 4})], 
  +%%   [IntVal, {'@', 4}] = X
  +%%)</pre>
  +%% @spec return(Value::Type) -> domain(Type)
  +-spec return(Value::Type) -> domain(Type).
   return(Val) -> 
       #?DOM{kind=#return{value=Val},
   	 pick  = fun(#?DOM{kind=#return{value=V}}=Dom,_) -> {Dom,V} end,
   	 shrink  = fun(Dom,V) -> {Dom,V} end
   	}.
   
  +%% @doc Support function for the ?SIZED macro.
  +%% @spec sized( fun((integer()) -> domain(T)) ) -> domain(T)
   -spec(sized( fun((integer()) -> domain(T)) ) -> domain(T)).	     
   sized(Fun) ->
       #?DOM{kind=#sized{body=Fun},
  
positive.code: 
  -define(BOX,'@box').
  -record(?BOX, {dom :: domain(T), value :: T}).
  -type box(T) :: {?BOX, domain(T), T}.
  
  
  %% @type domain(T). 
  %% 
  -type domain(T) :: domrec(T) |  T.
  		     
  
negative.code: %% How many times we try pick a value in order to satisfy a ?SUCHTHAT property.
  -define(SUCHTHAT_LOOPS,100).
  
  %% @type pick_fun(T). Picks members of the `domain(T)'.
  %% Return pair of `{domain(T),T}'; the "output domain" is what will
  %% be used for shrinking the value.
  -type pick_fun(T)   :: fun( (domain(T),integer()) -> {domain(T),T} | no_return() ).
  
  %% @type shrink_fun(T). Shrinks members of the `domain(T)'.
  %% Return pair of `{domain(T),T}'; the "output domain" is what will
  %% be used for further shrinking the value.
  -type shrink_fun(T) :: fun( (domain(T),T)         -> {domain(T),T} | no_return() ).
  -type domrec(T) :: {?DOM, 
  		    atom() | tuple(),
  