Difference between revisions of "Forget / Keep Mechanism"

Revision as of 17:29, 19 February 2007

Warning: Warning: Article under development

Example

The following classes will be used for illustration:

class ANIMAL
 
feature
 
  eat (f: FOOD)
 
end

class CAT
 
inherit
 
  ANIMAL
    redefine
      eat
    end
 
feature
 
  eat (f: CAT_FOOD)
 
end

class FOOD
end
 
class CAT_FOOD
 
inherit
 
  FOOD
 
end

class SET [G] 
 
feature
 
  has (g: G): BOOLEAN
 
  put (g: G)
 
  item: G
 
end

class LIST [G]
 
inherit 
 
  SET [G]
 
end

covariant feature redefinition

cat-call

local
  a: ANIMAL
  c: CAT
do
 
  a := c
  a.eat (food)
 
end

forget-mechanism

Types which have covariant redefined features will not be conform. A feature which is covariantly redefined changes its inherit clause implicitly to inherit from a parent class which has the redefined feature in a forget clause.

class CAT
 
inherit
 
  ANIMAL
    redefine
      eat
    end
 
feature
 
  eat (f: CAT_FOOD)
 
end

class CAT
 
inherit
 
  ANIMAL
    forget 
      eat
    redefine
      eat
    end
 
feature
 
  eat (f: CAT_FOOD)
 
end

The conformance between ANIMAL and ANIMAL forget eat and ANIMAL forget all is as follows:

local
  normal_animal: ANIMAL
  forget_eat_animal: ANIMAL forget eat end
  forget_all_animal: ANIMAL forget all end
do
    -- this assignment is legal since all features present in the
    -- forget types are also present in the normal type
  forget_eat_animal := normal_animal
  forget_all_animal := normal_animal
 
    -- this assignment is illegal since the forget_animal lacks
    -- the eat feature and thus cannot be used as an ANIMAL
  normal_animal := forget_eat_animal
  normal_animal := forget_all_animal
 
    -- this assignment is legal since the forget all type
    -- has fewer or equal features than the forget eat type
  forget_all_animal := forget_eat_animal
 
    -- this assignment is only legal if only the feature `eat'
    -- is covariantly redefined in the type ANIMAL and thus
    -- forget eat is equivalent to forget all
  forget_eat_animal := forget_all_animal
 
end

Now the cat-call example with the new forget types:

local
  a: ANIMAL
  c: CAT
do
    -- illegal assignment, ANIMAL and CAT don't conform
    -- since CAT implicitly inherits from ANIMAL forget eat
  a := c
  a.eat (food)
 
end

local
  a: ANIMAL forget all end
  c: CAT
do
    -- legal, CAT conforms to ANIMAL forget all
  a := c
 
    -- illegal, ANIMAL forget all doesn't have a feature eat
  a.eat (food)
 
end

like

A declaration like Current is a covariant redefinition for all subtypes. Since this occurs in ANY.is_equal and ANY.copy, every class has a covariantly redefined fetaures.

class ANY
 
feature
 
  is_equal (other: like Current): BOOLEAN
 
  copy (other: like Current)
 
end

generics

...

syntax

The first variant has the default on NOT forgetting features, thus breaking conformance between the type and its subclasses which use covariant redefinition.

-- normal declaration is an object with all features and no
  -- subtype which has a covariantly redefined feature conforms to this type
a1: ANIMAL
 
  -- a type marked as `poly' will loose all covarianlty redefined features
  -- and all subtypes conform to this type
a2: poly ANIMAL
 
  -- a type which only forgets the features `eat' and `drink' but not other
  -- covarianlty redefined features. all subtypes which only redefine `eat' or
  -- `drink' will conform to this type
a3: ANIMAL forget eat, drink end
 
  -- a type which forgets all covariantly redefined features. equivalent to `poly'
a4: ANIMAL forget all end

The second variant has the default on forgetting all features which are covariantly redefined, thus keeping conformance with subtypes.

-- normal declaration is an object which forgets all covariantly
  -- redefined features. all subtypes conform to this type
b1: ANIMAL
 
  -- a type which keeps all features and looses conformance from subtypes which
  -- covariantly redefine features
b2: mono ANIMAL
 
  -- a type where all subtypes conform except those who covariantly redefine
  -- feature `eat'
b3: ANIMAL keep eat end
 
  -- a type which keeps all features. equivalent to `mono'
b4: ANIMAL keep all end

consequences

...