src/Tools/code/code_target.ML

 (** SML/OCaml serializer **)
 
 datatype ml_def =
     MLFuns of (string * (typscheme * (iterm list * iterm) list)) list
   | MLDatas of (string * ((vname * sort) list * (string * itype list) list)) list
-  | MLClass of string * ((class * string) list * (vname * (string * itype) list))
+  | MLClass of string * (vname * ((class * string) list * (string * itype) list))
   | MLClassinst of string * ((class * (string * (vname * sort) list))
         * ((class * (string * (string * dict list list))) list
       * (string * const) list));
 
 fun pr_sml allows_exception tyco_syntax const_syntax labelled_name init_syms deresolv is_cons ml_def =

                     :: str "="
                     :: separate (str "|") (map pr_co cos)
                   );
             val (ps, p) = split_last (pr_data "datatype" data :: map (pr_data "and") datas');
           in Pretty.chunks (ps @ [Pretty.block ([p, str ";"])]) end
-     | pr_def (MLClass (class, (superclasses, (v, classops)))) =
+     | pr_def (MLClass (class, (v, (superclasses, classops)))) =
           let
             val w = first_upper v ^ "_";
             fun pr_superclass_field (class, classrel) =
               (concat o map str) [
                 pr_label_classrel classrel, ":", "'" ^ v, deresolv class

                     :: str "="
                     :: separate (str "|") (map pr_co cos)
                   );
             val (ps, p) = split_last (pr_data "type" data :: map (pr_data "and") datas');
           in Pretty.chunks (ps @ [Pretty.block ([p, str ";;"])]) end
-     | pr_def (MLClass (class, (superclasses, (v, classops)))) =
+     | pr_def (MLClass (class, (v, (superclasses, classops)))) =
           let
             val w = "_" ^ first_upper v;
             fun pr_superclass_field (class, classrel) =
               (concat o map str) [
                 deresolv classrel, ":", "'" ^ v, deresolv class

           |> fold (fold (insert (op =)) o Graph.imm_succs code) names
           |> subtract (op =) names;
         val (modls, _) = (split_list o map dest_name) names;
         val modl' = (the_single o distinct (op =) o map name_modl) modls
           handle Empty =>
-            error ("Illegal mutual dependencies: " ^ commas (map labelled_name names));
+            error ("Different namespace prefixes for mutual dependencies:\n"
+              ^ commas (map labelled_name names)
+              ^ "\n"
+              ^ commas (map (NameSpace.qualifier o NameSpace.qualifier) names));
         val modl_explode = NameSpace.explode modl';
         fun add_dep name name'' =
           let
             val modl'' = (name_modl o fst o dest_name) name'';
           in if modl' = modl'' then

               :: pr_co co
               :: map ((fn p => Pretty.block [str "| ", p]) o pr_co) cos
               @ (if deriving_show name then [str "deriving (Read, Show)"] else [])
             )
           end
-      | pr_def (name, CodeThingol.Class (superclasss, (v, classops))) =
+      | pr_def (name, CodeThingol.Class (v, (superclasses, classops))) =
           let
             val tyvars = CodeName.intro_vars [v] init_syms;
             fun pr_classop (classop, ty) =
               semicolon [
                 (str o classop_name name) classop,

               ]
           in
             Pretty.block_enclose (
               Pretty.block [
                 str "class ",
-                pr_typparms tyvars [(v, map fst superclasss)],
+                pr_typparms tyvars [(v, map fst superclasses)],
                 str (deresolv_here name ^ " " ^ CodeName.lookup_var tyvars v),
                 str " where {"
               ],
               str "};"
             ) (map pr_classop classops)