4 Commits

Author	SHA1	Message	Date
Simon Taylor	46a8da81cb	Implement builtin tuple types, similar to those in Haskell. ... Estimated hours taken: 30 Implement builtin tuple types, similar to those in Haskell. Tuples are constructed and deconstructed using the syntax X = {Arg1, Arg2, ...}. Tuples have type `{Arg1, Arg2, ...}'. Unary tuples (X = {Arg}) do work, unlike in Haskell. The rationale for this is that it is useful to be able to construct unary tuples to be passed to a polymorphic predicate which uses std_util__deconstruct to deal with a tuple of any arity. Since this is probably the only use for unary tuples, it's not really worth the effort of treating them as no_tag types, so we don't. The type-infos for tuples have the same structure as for higher-order types. There is a single type_ctor_info for tuples, and the arity is placed before the argument type_infos. library/parser.m: Change the way '{}/N' terms are parsed, so that the parsed representation is consistent with the way other functors are represented (previously the arguments were left as unparsed ','/2 terms). This avoids special case code in prog_io__parse_qualified_term, term__term_to_type and term__type_to_term. compiler/prog_io_dcg.m: compiler/prog_io_util.m: Handle the new structure of '{}/N' terms when parsing DCG escapes by converting the argument list back into a single ','/2 term. compiler/module_qual.m: Treat tuples as a builtin type. compiler/typecheck.m: Typecheck tuple constructors. compiler/mode_util.m: Propagate types into tuple bound insts. compiler/type_util.m: Add type_is_tuple/2 and type_id_is_tuple/1 to identify tuple types. Add tuples to the list of types which are not atomic types. Handle tuple types in `type_constructors' and `get_cons_id_arg_types' and `switch_type_num_functors'. compiler/tabling.m: Handle tabling of tuples. compiler/term_util.m: Handle tuples in the code to compute functor norms. compiler/magic_util.m: compiler/rl.m: compiler/rl_key.m: Handle tuple types in the Aditi back end. compiler/mercury_to_mercury.m: library/io.m: library/term_io.m: Handle output of '{}/N' terms. compiler/higher_order.m: compiler/simplify.m: Don't specialize complicated unifications of tuple types into calls to a specific unification procedure -- even if the procedure were implemented, it probably wouldn't be that much more efficient. compiler/unify_proc.m: Generate unification procedures for complicated unifications of tuples (other than in-in unifications). These are generated lazily as required. compiler/make_hlds.m: Export add_special_pred for use by unify_proc.m. compiler/polymorphism.m: Export polymorphism__process_pred for use by unify_proc.m. compiler/bytecode_gen.m: compiler/code_util.m: compiler/ml_code_util.m: Handle unify procedure names and tags for tuple types. compiler/mlds_to_c.m: Output tuple types as MR_Tuple. compiler/ml_unify_gen.m: Compute the field types for tuples. compiler/polymorphism.m: compiler/pseudo_type_info.m: Treat tuple type_infos in a similar way to higher-order type_infos. compiler/hlds_data.m: Document how cons_ids for tuple types are represented. compiler/switch_gen.m: compiler/table_gen.m: Add tuple types to switches on type_util__builtin_type. compiler/llds_out.m: util/mdemangle.c: profiler/demangle.m: Transform items named "{}" to "f_tuple" when mangling symbols. library/builtin.m: Define the type_ctor_info used for tuples. library/private_builtin.m: Add `builtin_unify_tuple/2' and `builtin_compare_tuple/3', both of which abort. All comparisons and in-in unifications of tuples are performed by the generic unification functions in runtime/mercury_ho_call.c and runtime/mercury.c. library/std_util.m: Implement the various RTTI functions for tuples. Encode tuple `TypeCtorDesc's in a similar way to that used for higher-order types. This has the consequence that the limit on the arity of higher-order types is now MAX_VIRTUAL_REG, rather than 2*MAX_VIRTUAL_REG. Avoid calling MR_GC_free for the type-info vector returned from ML_expand() for tuples because unlike the vectors for du types, it is not copied. runtime/mercury_type_info.h: Add macros for extracting fields from tuple type-infos. These just call the macros for extracting fields from higher-order type-infos. Add a macro MR_type_ctor_rep_is_variable_arity(), which returns TRUE for tuples and higher-order types. The distinction between higher-order and first-order types is now misnamed -- the distinction is really between fixed arity types and builtin variable arity types. I'm not sure whether it's worth renaming everything. runtime/mercury.h: runtime/mercury.c: Define unification and comparison of tuples in high-level code grades. runtime/mercury_deep_copy_body.h: runtime/mercury_make_type_info_body.h: runtime/mercury_tabling.c: runtime/mercury_unify_compare_body.h: Handle tuple types in code which traverses data using RTTI. tests/hard_coded/construct.{m,exp}: tests/hard_coded/expand.{m,exp}: Test RTTI functions from std_util.m applied to tuples. tests/hard_coded/tuple_test.{m,exp}: Test unification, comparison, term_to_type etc. applied to tuples. tests/hard_coded/deep_copy.{m,exp}: Test deep copy of tuples. tests/hard_coded/typeclasses/tuple_instance.{m,exp}: Test instance declarations for tuples. tests/tabling/expand_tuple.{m,exp}: Test tabling of tuples. tests/hard_coded/write.m: Add some module qualifications for code which uses `{}/1' constructors which are not tuples. tests/invalid/errors2.{m,err_exp,err_exp2}: Test handling of tuples in type errors messages. NEWS: doc/reference_manual.texi: w3/news/newsdb.inc: Document tuples. doc/transition_guide.texi: Document the change to the parsing of '{}/N' terms.	2000-09-18 11:53:19 +00:00
Zoltan Somogyi	c2a696d8b6	Clean up the runtime system's handling of type_infos and pseudo_type_infos. ... Estimated hours taken: 40 Clean up the runtime system's handling of type_infos and pseudo_type_infos. This cleanup has two major aspects. First, it represents type_infos and pseudo_type_infos with distinct C types, and reducing the use of casts to the minimum. These casts are in two kinds of places: in a few macros defined in runtime/mercury_type_info.h, and at the interfaces between C code and Mercury code (since Mercury code represents (pseudo-)type_infos, like everything else, as Words). Part of this aspect is the separation of the type "MR_TypeInfo" from the type "MR_TypeInfoParams"; a MR_TypeInfo can be used as a source of type parameters directly only when it is first order. Second, it removes the confusion between the types named "type_info" and "type_ctor_info" defined by the modules private_builtin.m and std_util.m, by renaming the types defined in std_util.m to "type_desc" and "type_ctor_desc". To avoid doing this cleanup twice, this diff also removes support for the old type_ctor_info representation. This in turn makes it feasible to provide conditionally enabled code to support unification and comparison by RTTI. runtime/mercury_grade.h: Increment the binary compatibility version number. This is required by the dropping of support for old type_ctor_info representations. runtime/mercury_type_info.h: Define the types MR_TypeInfo, MR_PseudoTypeInfo and MR_TypeInfoParams, and macros that operate on them. Remove the types and macros that were useful only with the old RTTI representation. Move the section that deals with initializing code addresses in type_ctor_info structure for grades without static code addresses to the logical place. Add a const qualifier to the MR_sectag_alternatives field in MR_DuPtagLayout, since this simplifies code manipulating du types. Convert the whole file to 4 space indentation, since it is a nuisance if only part of it is so indented. runtime/mercury_deep_copy.h: runtime/mercury_deep_copy_body.h: runtime/mercury_tabling.h: runtime/mercury_tabling.c: Clean up the implementation as described above. runtime/mercury_type_info.c: runtime/mercury_make_type_info_body.h: Clean up the implementation as described above. Eliminate the code duplication between the function MR_make_type_info and MR_create_type_info, and their helpers, which do the same thing except for how they allocate memory, by putting the common code into the new file mercury_make_type_info_body.h, and including it twice in two different #define contexts. Move the (updated) documentation of those functions to mercury_type_info.h, where it belongs. runtime/mercury_ho_call.c: runtime/mercury_unify_compare_body.h: Clean up the implementation as described above. Eliminate the code duplication between the implementation of unify and compare, which do very similar jobs, by putting the common code into the new file mercury_unify_compare_body.h, and including it three times in two different #define contexts. The third time is for defining the body of a C function which does the same thing as compare. This is necessary for unification and comparison by RTTI, since the unification or comparison of two structured terms requires comparing their subterms. (There is no need for a separate C function for unification; the C comparison function is sufficient.) mercury_unify_compare_body.h has conditional support for unification and comparison by RTTI. Although this has been tested and is known to work, it is turned off for the moment. This may change after benchmarking. runtime/Mmakefile: Add the new include files to the list. library/std_util.m: Rename type_info to type_desc and type_ctor_info to type_info_desc. Keep the old names as equivalence types, for the time being. Document the representations. Move the macros that refer to type_descs and type_ctor_descs here from runtime/mercury_type_info.h, since this is the only place where they are used. Rename them to conform to the new names of the types. Clean up the implementation of the RTTI predicates and functions as described above. In the process, fix some bugs where type variables were expanded twice, with the second expansion's code being incorrect. Also factor out some common code, and unfactor some uncommon code (where a function had two uses, but its implementation was inefficient overkill for one of them). library/builtin.m: library/private_builtin.m: library/io.m: library/store.m: runtime/mercury_layout_util.[ch]: trace/mercury_trace_declarative.c: trace/mercury_trace_external.c: trace/mercury_trace_vars.[ch]: When calling C functions involving type_infos, cast them to the new types. runtime/mercury_stack_layout.h: Fix a bug that was masked by casts in its client code. compiler/rtti_out.m: Delete from the output a cast made unnecessary by the new const qualifier on MR_sectag_alternatives. browser/browse.m: browser/help.m: library/io.m: library/term.m: tests/hard_coded/construct.m; tests/hard_coded/existential_types_test.m: tests/hard_coded/higher_order_type_manip.{m,exp}: Refer to the types defined in std_util.m by their new names. tests/hard_coded/existential_rtti.{m,exp}: Make the test tougher by printing out not just one deconstructed term, but deconstructed versions of all the terms created by this test.	2000-03-24 10:28:07 +00:00
Fergus Henderson	52767a5481	Update the test cases to reflect recent changes to io__write. ... Estimated hours taken: 1 Update the test cases to reflect recent changes to io__write. test/hard_coded/construct.m: test/hard_coded/expand.m: Use `io__print' rather than `io__write' for univs, so that it doesn't output the `univ(... : type)' wrappers. tests/hard_coded/deep_copy_bug.exp: tests/hard_coded/construct.exp: tests/hard_coded/expand.exp: tests/hard_coded/write.exp: tests/hard_coded/write_reg1.exp: Change the expected output to use proper list notation rather than prefix `.', and to properly quote strings and atoms, but also to improperly quote equivalences types. tests/hard_coded/Mmake: Add a comment explaining that deep_copy_bug.exp, write.exp, and write_reg1.exp are wrong, due to a bug in io__write.	1997-04-28 15:52:30 +00:00
Tyson Dowd	39bdac4517	Add the type `type_info', which represents the type of a variable. ... Estimated hours taken: 50 Add the type `type_info', which represents the type of a variable. Implement functions and predicates to deal with type_infos, including finding what functors they have, getting the arity and type_infos of their the arguments of a functor, and constructing types. compiler/base_type_layout.m: Document the constant used to represent the type 'void'. Make sure enumeration vectors are output in the same order for base_type_layouts and base_type_functors, so that we can refer to functors by the same functor number. library/mercury_builtin.m: Add base_type_* for 'void'. 'void' is the type_info used for unbound type_variables. library/std_util.m: Add function type_of/1 function num_functors/1 predicate get_functor/5 function construct/3 Use MR_DECLARE_STRUCT to declare base_type_* structs for handwritten code, so less code needs to be changed if this changes. Rename `mercury_expand_info' as `Mercury_Expand_Info' (C coding standard for typedefs). runtime/type_info.h: Add a bunch of macros to deal with the various type information data structures. Eventually all the code that uses these data strcutures should use these macros. tests/hard_coded/Mmake: Add `construct' to the test suite. hard_coded/construct.m: hard_coded/construct.exp: Test of type_of, num_functors, get_functor and construct.	1997-04-21 08:33:00 +00:00