Hello,


ghc-4.02-i386-unknown-linux  binary taken from  ftp.dcs.gla.ac.uk

says    `EVACUATED object entered!'

after   ghc -c Bug.hs      

for the program enclosed below.

Slight modifications of this program (commenting out its small parts)
cause various effects:
  * hsc: fatal error: evacuate: strange closure type

  * warnings on  `static closure ... such and such closure'
    - at the stage of C compilation.

  * compiler may take an unnaturally large piece of memory for this 
    module and does not seem to finish compilation


As to  ghc-4.01, 

it worked with this module, - which in reality is slightly more 
complex and 1.5 times larger, - but needed somewhat strangely large
space and time.
Comparing it to other modules, this one contains more of data 
declarations with many constructors and records. Though the source 
volum itself is small.
Could you explain the  ghc  behaviour on this point?

------------------
Sergey Mechveliani
[EMAIL PROTECTED]






--------------------------------------------------------------------
module Bug where

type Z        = Integer       
type Natural  = Z 
data InfUnn a = Fin a | Infinity | UnknownV  deriving(Eq,Show,Read)

type CompValue    = Ordering     
type Comparison a = a -> a -> CompValue
type MMaybe a     = Maybe (Maybe a)
data PropValue    = Yes | No| Unknown  deriving (Eq,Ord,Enum,Show,Read)

newtype Vector a = Vec [a]  deriving(Read,Eq)
type PPInt        = Z
type PowerProduct = Vector PPInt
type PPComp       = Comparison PowerProduct

type Domains1 a   = [(CategoryName, Domain1 a)]
data CategoryName = 
         Set | AddSemigroup | AddGroup | MulSemigroup | MulGroup | Ring 
         deriving(Eq,Ord,Enum,Show,Read)

data Domain1 a =    Dom1Set         (OSet            a)   
                  | Dom1Semigroup   (Subsemigroup    a)  
                  | Dom1Group       (Subgroup        a)  
                  | Dom1Ring        (Subring         a)  
                  | Dom1GCDRing     (GCDRingTerm     a)  
                  | Dom1FactrRing   (FactrRingTerm   a)
                  deriving(Show) 

data OSet a =
     OSet {typeSample  :: a, 
           membership  :: a -> Bool,
           osetCard    :: InfUnn Natural,
           osetPointed :: MMaybe a,      
           osetList    :: Maybe [a],
           osetProps   :: Properties_OSet,
           osetConstrs :: [Construction_OSet a]
          }
          deriving(Show)

type Properties_OSet = [(Property_OSet,PropValue)]
data Property_OSet   = Finite | FullType | IsBaseSet
                       | OrderIsTrivial | OrderIsTotal | OrderIsNoether
                       deriving(Eq,Ord,Enum,Show,Read)

data Construction_OSet a = 

    Interval      (Maybe a) Bool (Maybe a) Bool
    | Union         [OSet a]
    | Intersection  [OSet a]
    deriving(Show)


data Subsemigroup a =
     Subsemigroup {subsmgType    :: AddOrMul,  
                   subsmgUnity   :: MMaybe a,
                   subsmgGens    :: Maybe [a],
                   subsmgProps   :: Properties_Subsemigroup,
                   subsmgConstrs :: [Construction_Subsemigroup a],
                   subsmgOpers   :: Operations_Subsemigroup a
                  }
                  deriving(Show)

data AddOrMul = Add | Mul  deriving(Eq,Show,Read,Ord,Enum)

type Properties_Subsemigroup = [(Property_Subsemigroup,PropValue)]
data Property_Subsemigroup =
      Commutative | IsCyclicSemigroup | IsGroup | IsMaxSubsemigroup
    | IsOrderedSubsemigroup
    deriving(Eq,Ord,Enum,Show,Read)

data Construction_Subsemigroup a =
                        Intersection_Subsemigroup [Subsemigroup a]
                      | GenBySet_Subsemigroup     (OSet a)
                      deriving(Show)

type Operations_Subsemigroup a =
                 [(OpName_Subsemigroup, Operation_Subsemigroup a)]
data OpName_Subsemigroup = Op_Subsemigroup_DUMMY
                                   deriving(Eq,Ord,Enum,Show,Read)
data  Operation_Subsemigroup a = Op_Subsemigroup_DUMMY' Int Int
                                               deriving(Show,Read)
data Subgroup a =
  Subgroup {subgrType    :: AddOrMul,
            subgrGens    :: Maybe [a],
            subgrCanonic :: Maybe (a -> a),
            subgrProps   :: Properties_Subgroup,
            subgrConstrs :: [Construction_Subgroup a],
            subgrOpers   :: Operations_Subgroup a
           }
           deriving(Show)

type Properties_Subgroup = [(Property_Subgroup,PropValue)]
data Property_Subgroup   =
              IsCyclicGroup | IsPrimeGroup | IsNormalSubgroup
            | IsMaxSubgroup | IsOrderedSubgroup
            deriving(Eq,Ord,Enum,Show,Read)

data Construction_Subgroup a =
                              Intersection_Subgroup [Subgroup a]
                            | GenBySet_Subgroup     (OSet a)
                            deriving(Show)
type Operations_Subgroup a =
                         [(OpName_Subgroup, Operation_Subgroup a)]
data OpName_Subgroup = Op_Subgroup_DUMMY
                                   deriving(Eq,Ord,Enum,Show,Read)
data Operation_Subgroup a =
                        Op_Subgroup_DUMMY' Int Int  deriving(Show)

data Subring a =  
              Subring {subringChar    :: Maybe Natural,
                       subringGens    :: Maybe [a],
                       subringProps   :: Properties_Subring,
                       subringConstrs :: [Construction_Subring a],
                       subringOpers   :: Operations_Subring a
                      }
                      deriving(Show)

type Properties_Subring = [(Property_Subring,PropValue)]
data Property_Subring   =  
     IsField | HasZeroDiv | HasNilp | IsPrimaryRing | Factorial
   | PIR | IsOrderedRing | IsRealField | IsGradedRing
    deriving(Eq,Ord,Enum,Show,Read)

data Construction_Subring a =   
        Intersection_Subring [Subring a]
      | GenBySet_Subring     (OSet a)
      | DirectSum_Subring    [Subring a]
      deriving(Show)

type Operations_Subring a = [(OpName_Subring,Operation_Subring a)]
data OpName_Subring = DimOverPrimeField
                                   deriving(Eq,Ord,Enum,Show,Read)

data Operation_Subring a = DimOverPrimeField' (InfUnn Natural)
                               deriving(Show)


data GCDRingTerm a = 
                  GCDRingTerm {gcdRingProps :: Properties_GCDRing}
                              deriving(Show)

type Properties_GCDRing = [(Property_GCDRing,PropValue)]
data Property_GCDRing   = WithCanAssoc | WithGCD
                                   deriving(Eq,Ord,Enum,Show,Read)

data FactrRingTerm a =
             FactrRingTerm {factrRingProps :: Properties_FactrRing}
                   deriving(Show)

type Properties_FactrRing = [(Property_FactrRing,PropValue)]
data Property_FactrRing  =  WithIsPrime | WithFactor | WithPrimeList
                             deriving
                                     (Eq,Ord,Enum,Show,Read)

Reply via email to