/** * @version Last modified on Fri May 24 10:10:14 2002 by hak * @author Hassan Aït-Kaci * @copyright © 2002 ILOG, S.A. This directory contains the Javadoc'ed source code for the files comprising the package ilog.language.design.types. This documentation file (READ_ME_types.java) acts as an additional repository of comments in addition to the more specific ones in the individual files. It should best contain generic information or yet-to-be sorted out specifications of planned, or to-be-completed, designs. It also may outline, and/or add to, on-going documentation of implemented features. */ /** The type system consists of two complementary parts: a static and a dynamic part. The former takes care of verifying all type constraints that are statically decidable (i.e., before actually running the program). The latter pertains to type constraints that must wait until execution time to decide whether those (involving runtime values) may be decided. This is called dynamic type-checking and is best seen (and conceived) as an incremental extension of the static part. The complete outline of the type system as it exists at this writing is as follows.

  1. The static type system

    1. primitive types

      1. Boxable types

        1. void
        2. int
        3. real
        4. char
        5. boolean

      2. Boxed types

        1. string
        2. built-in type constants

    2. type constructors

      1. function types
      2. tuple types

        1. position tuple types
        2. named tuple types

      3. array types

        1. 0--int-indexed arrays
        2. int-range-indexed arrays
        3. set-indexed arrays
        4. multidimensional arrays

      4. set types
      5. class types

    3. Polymorphic types
    4. Type aliasing
    5. Type hiding

  2. The dynamic type system

    1. Dynamically constrained type
    2. Extensional types (contract-based types)

      1. Set types
      2. Int range types
      3. Float range types
      4. Enum types

    3. Boolean-assserted types

*/ /**

The static type system

primitive types

Boxable types

  • void
  • int
  • real
  • char
  • boolean

    Boxed types

    string
    built-in type constants

    type constructors

    function types

    tuple types

    position tuple types
    named tuple types

    array types

    0--int-indexed arrays
    int-range-indexed arrays
    set-indexed arrays
    multidimensional arrays

    set types

    class types

    Polymorphic types

    Type aliasing

    Type hiding

    */ /**

    The dynamic type system

    Dynamic types are to be checked, if possible statically (at least their static part is), at least in two particular places of an expression. Namely,
    1. at assignment time; and,
    2. at (function) parameter-binding time.
    This will ensure that the actual value places in the slot expecting a certain type does respects additionnal constraints that may only be verified with some runtime values. Typically, such dynamic parts will be so-called dependent types (such as - e.g., array types whose size depends on a fixed size value that may be only computed at runtime).

    From this, we require that a class implementing the DynamicType interface provides a method public boolean verifyCondition() that is invoked systematically by code generated for dynamically typed function parameters and for locations that are the target of updates (i.e, array slot update, object field update, tuple field update) at compilation of abstractions and various assignment constructs. Of this class, three subclasses derive their properties:

    We shall consider here a few such dynamic types (motivated esssentially by the need expressed by OPL types). Namely,

    An extensional type is a type whose elements are determined to be members of a predetermined and fixed extension (i.e., any runtime value that denotes a collection - such as a set, an int range, a float range, or an enumeration). Such types pose the additional problem of being usable at compile-time to restrict the domains of other variables. However, some of those variables' values may only fully be determined at runtime. These particular dynamic types have therefore a simple verifyCondition() method that is automatically run as soon as the extension is known. It just verifies that the element is a bona fide member of the extension), otherwise it relies on a more complicated scheme based on the notion of contract. Basically, a contract-based type is an extensional type that does not have an extension (as yet) but already carries the obligation that some particular individual constants be part of their extensions. Those elements consitute ``contracts'' that must be honored as soon as the type's extension becomes known (either positively - eliminating the contract, or negatively - causing a type error).

    The notion of dynamically constrained type (int+, float+,...)

    The notion of extensional type

    Set types
    Int range types
    Float range types
    Enum types

    The notion of boolean-assserted type

    */