MLCompiler/ParseTree/TYPECHECK_PARSETREE.sml

132         (* Returns a function which can be passed to unify or apply to
264                 let  (* Make arg->'a, and unify with the function. *)
284               Handlers: the handling patterns are unified against a function from exn -> the result type of the
375            This is used for lists, function values (fn .. => ...),
457         (* Get the current overload set for the function and return a new
464           (* Look up the current overloading for this function. *)
569                     (* Apply the function to the argument and return the result. *)
759                 (* Apply the function to the argument and return the result. *)
766                    polymorphic and wrap a function round it. *)
771                 (* Test to see if we have a function. *)
785                                     (* It's not a function. *)
786                                     typeMismatch("Type error in function application.",
789                                         PrettyString "Value being applied does not have a function type",
797                     NONE => badType (* Not a function *)
803                                 typeMismatch("Type error in function application.",
1321                 (* Unify the handler with a function from exn -> expType *)
1354                 (* The matches constitute a function from the test type to
1422               (* A match is a function from the pattern to the expression *)
1436                  body of the function. *)
1461               (* Result is a function from the type of the pattern to the type
1618             val funLevel = level + 1; (* Level for function names. *)
1640             (* Since this is a recursive declaration we must get the function
1642                as applications of the function to one or more patterns. There
1643                may be more than one clause in a function binding but each
1644                should declare the same function and have the same number of
1646                function name in the third pass so we save them in the
1647                function binding. *)
1662                         (* Put the results onto the function binding. *)
1665                                 "Clausal function does not have any parameters.")
1684                    of the function names and using the information about
1685                    function name and number of patterns we have saved. *)
1690                        clauses. Each must have the same function name, the same
1694                        Build a type to be used for the function.  This will later be unified
1695                        with the type that we've already created for the function variable. *)
1741                         (* This list is used for the type of the helper function. *)
1749                            body of the function. Since it is recursive the function
1809                         (* The type of this clause is a function type. *)
1831                     (* If this function makes any recursive references move those references from the
1833                        function is actually referenced we'll only include it if it's referenced outside
1834                        or from another referenced function. *)
1839                             val callerName = valName functVar (* Name of referring function. *)
1847                     (* Finally unify the function type with the type of the function variable.  If the
1875                             typeMismatch("Type of function does not match type of recursive application.",
2107                        "Abs" function defined in section 4.9 of the ML Definition.
2146        type for a value, typically a function, but it is frequently used in
2150        function. *)