anchor.diff:  
     (** Creates an instantiation of a sub module with generics and inouts.  Not supported for simulation. *)
     let instgio name generics inouts inputs outputs = 
  -    check_ok (map snd inputs);
  -    check_ok (map snd outputs);
  +    check_ok (List.map snd inputs);
  +    check_ok (List.map snd outputs);
       let inst = { su = Signal_inst(signal_incr_uid(), name, ref "", generics, inouts, inputs, outputs) } in
  -    iter (fun (x : string * Signal) -> 
  +    List.iter (fun (x : string * Signal) -> 
         if not (snd x).IsWire 
         then failwith "Output signals of instantions must be wires"
         else assign (snd x) inst) (outputs@inouts)
  
positive.code: 
    (** Apply the given operator between each element of the given list. Requires at least two signals. *)
    let reduce op s = 
      match length s with
      | 0 | 1 -> failwith ("Cant reduce 0 or 1 bits")
      | _ -> fold_left (fun acc x -> op acc x) (hd s) (tl s)
  
    (** Lets the single reduce case pass by just returning the data. *)
    let reduce_1 op s = 
      match length s with
      | 1 -> hd s 
      | _ -> reduce op s
  
    (* ------------------------------------------------------------------------ *)
  
negative.code:   (** Takes a list of signals and returns a list of where each signal is unique based on it's uid *)
    let unique_signal_list signals = 
      let map = (List.fold (fun set (signal : Signal) -> Map.add (signal.uid) signal set) Map.empty signals) in
      let l = Map.foldBack (fun k d l -> d :: l) map [] in
      l
  
    (** Get the connection for this wire, or empty *)
  