## Reinstate VECTORISE pragmas with expressions as right-hand sides

The current vectoriser depends in a very fragile way on the order in which the constraint solver generates constraints. This ticket is just to track this known problem.

Manifestation:

```
*** Vectorisation error ***
Type mismatch in vectorisation pragma for Data.Array.Parallel.unzipP
Expected type forall a_a1SF b_a1SG.
(Data.Array.Parallel.PArray.PRepr.PA a_a1SF,
Data.Array.Parallel.PArray.PRepr.PA b_a1SG) =>
Data.Array.Parallel.PArray.Base.PArray (a_a1SF, b_a1SG)
Data.Array.Parallel.Lifted.Closure.:-> (Data.Array.Parallel.PArray.Base.PArray
a_a1SF,
Data.Array.Parallel.PArray.Base.PArray
b_a1SG)
Inferred type forall a_a21g b_a21h.
(Data.Array.Parallel.PArray.PRepr.PA b_a21h,
Data.Array.Parallel.PArray.PRepr.PA a_a21g) =>
Data.Array.Parallel.PArray.Base.PArray (a_a21g, b_a21h)
Data.Array.Parallel.Lifted.Closure.:-> (Data.Array.Parallel.PArray.Base.PArray
a_a21g,
Data.Array.Parallel.PArray.Base.PArray
b_a21h)
```

Reason: the compilation of VECTORISE pragmas depends on the order of constraints in an inferred type. This isn't trivial to fix. As Manuel writes, the problem here is that we do not know what wrapper w we need *until* the vectoriser runs. Why is that? Given

```
f :: ty
f = e
{-# VECTORISE f = e_v #-}
```

where the type *inferred* for `e_v`

is `ty_v`

, we need to mediate between `ty_v`

and `V[[ty]]`

. (Here `V[[ty]]`

is the transformation that maps a regular type to a vectorised type.)

It is `V[[ty]]`

that we cannot determine until the vectoriser runs. If we could compute `V[ty]]`

in the type checker, we could use it together with `ty_v`

to compute a wrapper w as you propose.

Alas, given the current implementation of `V[[..]]`

in the vectoriser (it is implemented in `Vectorise.Type.vectType`

), we cannot call it in the type checker, because it runs in the `VM`

monad, which is a variant of the 'DsM' monad. In particular, 'VM' uses some tables of names of types and functions defined in the DPH library that are not available during type checking. (I briefly considered duplicating the code for `vectType`

as a stop gap measure in `TcM`

, but that didn't seem to be so easy.)

I believe that the Right Thing to do is to change the 'VM' monad and the implementation of `vectType`

, so that it is more flexible and can be called from `TcM`

. The changes that I am making at the moment (i.e., cutting down these tables of magic, built-in things) will make it easier to improve `vectType`

.

## Trac metadata

Trac field | Value |
---|---|

Version | 7.0.4 |

Type | Bug |

TypeOfFailure | OtherFailure |

Priority | normal |

Resolution | Unresolved |

Component | Compiler |

Test case | |

Differential revisions | |

BlockedBy | |

Related | |

Blocking | |

CC | |

Operating system | |

Architecture |