Changes between Version 1 and Version 2 of DataParallel/ClosureConversion/ClassLess

Apr 20, 2007 1:15:20 PM (11 years ago)



  • DataParallel/ClosureConversion/ClassLess

    v1 v2  
    1414=== Class declarations ===
     16If we come across a class declaration for a class `C` during conversion, we convert it generating `C_CC`.  Like with type constructors, `Class.Class` gets a `classCC :: Maybe Class` field that is `Just C_CC` for classes that have a conversion.  We also ensure that the `classTyCon` of `C`, let's call it `T_C`, refers to `T_C_CC` and `fr_T_C` and `to_T_C` in its `tyConCC` field, and that the `classTyCon` of `C_CC` is `T_C_CC`.
    1618=== Instance declarations ===
     20If we encounter an instance declaration for `C tau` during conversion, there are two alternatives: we have a conversion for `C` or not:
     21 * if we do not have a conversion, we generate an instance (and hence dfun) for `C tau^`, where `tau^` is the closure converted `tau`;
     22 * if we have a conversion, we generate an instance for `C_CC tau^`.
     23In any case, we add a field `is_CC :: Just Instance` to `InstEnv.Instance` that contains the additionally generated instance.  And in both cases, we should be able to derive the required code for the dfun from the definition of `C tau`.
     25=== Type terms ===
     27We determine the converted type `t^` of `t` as follows:
     29T^            = T_CC , if available
     30                T    , otherwise
     31a^            = a
     32(t1 t2)^      = t1^ t2^
     33(t1 -> t2)^   = Clo t1 t2
     34(forall a.t)^ = forall a.t^
     35(C t1 => t2)^ = C_CC t1^ => t2^ , if available
     36                C t1^ => t2^    , otherwise
     39=== Value bindings ===
     41When converting a toplevel binding for `f :: t`, we generate `f_CC :: t^`.  The alternatives `GlobalId` and `LocalId` of `Var.Var` get a new field `idCC :: Maybe Id` and the `Id` for `f` contains `Just f_CC` in that field.