anchor.diff:    let module_name = fst module_name @ [ snd module_name ] in
     let program = match modul with
       | Some (_signature, decls) ->
  -        List.filter_map (translate_decl (empty module_name)) decls
  +        List.collect (translate_decl (empty module_name)) decls
       | _ ->
           failwith "Unexpected standalone interface or nested modules"
     in
  
positive.code:         if List.length tvars = 0 then
            Some (DExternal (None, name, translate_type env t0))
          else
            None
        else begin
          try
            let body = translate_expr env body in
            Some (DFunction (None, flags, List.length tvars, t, name, binders, body))
          with e ->
            let msg = BU.print_exn e in
            BU.print2_warning "Writing a stub for %s (%s)\n" (snd name) msg;
            let msg = "This function was not extracted:\n" ^ msg in
            Some (DFunction (None, flags, List.length tvars, t, name, binders, EAbortS msg))
        end
  
    | MLM_Let (flavor, flags, [ {
        mllb_name = name;
        mllb_tysc = Some ([], t);
        mllb_def = expr
      } ]) ->
        let flags = translate_flags flags in
        let t = translate_type env t in
        let name = env.module_name, name in
  
negative.code:     | _ -> None // is this all of them?
    ) flags
  
  and translate_decl env d: list<decl> =
    match d with
    | MLM_Let (flavor, flags, lbs) ->
        // We don't care about mutual recursion, since every C file will include
        // its own header with the forward declarations.
        List.choose (translate_let env flavor flags) lbs
  
    | MLM_Loc _ ->
        // JP: TODO: use this to reconstruct location information
        []
  
    | MLM_Ty tys ->
        // We don't care about mutual recursion, since KreMLin will insert forward
        // declarations exactly as needed, as part of its monomorphization phase
        List.choose (translate_type_decl env) tys
  
    | MLM_Top _ ->
        failwith "todo: translate_decl [MLM_Top]"
  
    | MLM_Exn _ ->
        failwith "todo: translate_decl [MLM_Exn]"
  
  and translate_let env flavor flags lb: option<decl> =
    match lb with
    | {
        mllb_name = name;
        mllb_tysc = Some (tvars, t0);
        mllb_def = { expr = MLE_Fun (args, body) }
      }
    | {
        mllb_name = name;
        mllb_tysc = Some (tvars, t0);
        mllb_def = { expr = MLE_Coerce ({ expr = MLE_Fun (args, body) }, _, _) }
      } ->
        // Case 1: a possibly-polymorphic function.
        let assumed = BU.for_some (function Syntax.Assumed -> true | _ -> false) flags in
        let env = if flavor = Rec then extend env name false else env in
        let env = List.fold_left (fun env name -> extend_t env name) env tvars in
  