Changes between Version 53 and Version 54 of DataParallel/ClosureConversion/ClassLess


Ignore:
Timestamp:
May 1, 2007 8:04:56 AM (8 years ago)
Author:
chak
Comment:

--

Legend:

Unmodified
Added
Removed
Modified
  • DataParallel/ClosureConversion/ClassLess

    v53 v54  
    113113    toArr f        = const (tob . f . fra) :$ ()
    114114    frArr (f :$ e) = frb . f e . toa
     115}}}
     116
     117=== Conversions ===
     118
     119To perform the actual conversion of values of a type `t::*`, we generate a conversion `iso<t>` of type `t :<->: t^` as follows:
     120{{{
     121iso<T>          = isoT           , if T_CC exists
     122                = idIso<*>       , otherwise
     123iso<a::k>       = idIso<k>
     124iso<t1 -> t2>   = idIso<*>       , if kindOf t1 == #
     125                                   or kindOf t2 == #
     126                = isoArr         , otherwise
     127                    iso<t1> iso<t2>
     128iso<t1 t2>      = iso<t1> iso<t2>
     129iso<forall a.t> = iso<t>
     130}}}
     131where
     132{{{
     133idIso<*>      = id :<->: id
     134idIso<k1->k2> = \_ -> (idIso<k2>)
    115135}}}
    116136
     
    255275 * We come across a dfun: If its `idCC` field is `NoCC`, we keep the selection as is, but apply `convert t e` from it, where `t` is the type of the selected method and `e` the selection expression.  If `idCC` is `ConvCC d_CC`, and the dfun's class is converted, `d_CC` is fully converted.  If it's class is not converted, we also keep the selection unconverted, but have a bit less to do in `convert t e`.  '''TODO:''' This needs to be fully worked out.
    256276
    257 === Generating conversions ===
    258 
    259 Whenever we had `convert t e` above, where `t` is an unconverted type and `e` a converted expression, we need to generate some conversion code.  This works roughly as follows in a type directed manner:
    260 {{{
    261 convert T          = id   , if tyConCC T == NoCC or AsIsCC
    262                    = to_T , otherwise
    263 convert a          = id
    264 convert (t1 t2)    = convert t1 (convert t2)
    265 convert (t1 -> t2) = createClosure using (trevnoc t1)
    266                      and (convert t2) on argument and result resp.
    267 }}}
    268 where `trevnoc` is the same as `convert`, but using `from_T` instead of `to_T`.
    269 
    270 The idea is that conversions for parametrised types are parametrised over conversions of their parameter types.  Wherever we call a function using parametrised types, we will know these type parameters (and hence can use `convert`) to compute their conversions.  This fits well, because it is at occurences of `Id`s that have `idCC == NoCC` where we have to perform conversion.
    271 
    272 The only remaining problem is that a type parameter to a function may itself be a type parameter got from a calling function; so similar to classes, we need to pass conversion functions with every type parameter.  So, maybe we want to stick `fr` and `to` into a class after all and requires that all functions used in converted contexts have the appropriate contexts in their signatures.
    273277
    274278=== TODO ===