# Changes between Version 2 and Version 3 of DataParallel/Desugaring

Ignore:
Timestamp:
Apr 1, 2007 12:03:02 PM (7 years ago)
Comment:

--

Unmodified
Removed
Modified
• ## DataParallel/Desugaring

 v2 (4) [: e | let ds, qs :] = let ds in [: e | qs :] (5) [: e | qs | qss   :] = (6) [: e | (XS, XSS) <- zip [: XS | qs :] [: XSS | qss :] :] where XS & XSS are the bound variables in qs & qss [: e | (XS, XSS) <- zip [: XS | qs :] [: XSS | qss :] :] where XS & XSS are the bound variables in qs & qss }}} In particular, `concatMapP f a` essentially implies to apply the lifted version of `f` directly to `a` and then the concat strips of one level of segment descriptors; i.e., both the `concatP` and the `mapP` vanish due to vectorisation. == Modified rules == The idea is to flatten out the processing of comprehensions to some degree by defining a transformation function `<< . >>` that gets two arguments: a pattern `pa` and a desugared expression `ea`, where we are guaranteed that `ea` is array valued and all its elements match `pa`.  The semantics of the transformation function is given by {{{ <<[: e | qs :]>> pa ea = [: e | pa <- ea, qs :] = concatMap (\pa -> [: e | qs :]) ea }}} We have the second line by applying Rule (3). Using this definition of `<< . >>`, we can derive a new set of desugaring rules.  The derivation proceeds by unfold/fold transformations and some properties of the involved combinators.  The resulting rules are the following: {{{ (1') <<[: e |            :]>> pa ea = mapP (\pa -> e) ea (2') <<[: e | b, qs      :]>> pa ea = <<[: e | qs :]>> pa (filterP (\pa -> b) ea) (3') <<[: e | p <- a, qs :]>> pa ea = let ok p = True ok p = False in <<[: q | qs :]>> (pa, p) (crossMapP ea (\pa -> filterP ok a)) (4') <<[: e | let ds, qs :]>> pa ea = <<[: e | qs :]>> (pa, XS) (mapP (\v@pa -> let ds in (v, XS)) ea) where XS are the variables bound by ds (5') <<[: e | qs | qss   :]>> pa ea = <<[: e | qss :]>> (pa, XS) (zipP ea [: XS | qs :]) where XS are the variables bound by qs }}} The typical array processing comprehensions containing only generators, guards, and parallel comprehensions (but not cross-products and lets) are translated into a straight combination of `mapP`, `filterP`, and `zipP` by these rules, which is exactly what we want.