[BUG] Imperfect shape query propagation in the presence of dead code about accelerate HOT 2 OPEN

Another example of similar behaviour, except now there is no dead code, but there is a more complicated scalar expression to reason about.

let a = use (fromList (Z :. (1 :: Int)) [(1::Float,2::Float)])
    b = map fst a
in generate (I1 (let I1 n1 = shape b ; I1 n2 = shape a in min n1 n2))
            (\(I1 i) -> b ! I1 i)

This shows as:

let
  a0 = use (Vector (Z :. 1) [(((), 1.0), 2.0)])
  a1 = map (\(T2 x0 _) -> x0) a0
in
generate (min (let T1 x0 = shape a1 in x0) (let T1 x0 = shape a0 in x0)) (\(T1 x0) -> a1 ! x0)

whereas an optimal fusion result would have been map fst (use (Vector ...)).

Notable is that if fst is replaced by (*2) (and the type of a with Vector Float), then the map does fuse. Is this an instance of the thing I ran into earlier, where nodes like map fst in the fused AST are not actually compiled as manifest arrays but rather reduce to manipulation of SoA-form arrays?

from accelerate.

Two more programs that produce (somewhat) unexpected results:

zipWith (+)
  (zipWith (\x y -> x * 2 * y) a a)
  (map (\x -> x * x) a)

which shows as:

\a0 ->
  transform
    (let T1 x0 = shape a0 ; T1 x1 = shape a0 ; T1 x2 = shape a0 in (min (min x1 x0) x2))
    (\(T1 x0) -> x0)
    (\x0 -> 2.0 * x0 * x0 + x0 * x0)
    a0

which could have been \a -> map (\x -> 2 * x * x + x * x) a.

Program 2:

zipWith (+) a (map (\x -> x) a)

which shows as:

\a0 ->
  let a1 = map (\x0 -> x0) a0
  in
  generate
    (let T1 x0 = shape a1 ; T1 x1 = shape a0 in (min x1 x0))
    (\(T1 x0) -> a0 ! x0 + a1 ! x0)

which could have been \a -> map (\x -> x * x) a, or indeed \a -> generate (shape a) (\(T1 x) -> a ! x + a ! x).

I'm just collecting these for future reference at this point.

from accelerate.