INLINE_FUSED pragma in Haskell

Question

I am going over the vector library and noticed a {-# INLINE_FUSED transform #-} and I was wondering what it does? I see it defined in vector.h but nowhere else.

Answer 1

The definitions mean that INLINE_FUSED is the same as INLINE [1]; INLINE_INNER is the same as INLINE [0]. The [1] and [0] are standard ghc for ordering the phases of inlining. See the discussion under the heading 7.13.5.5. Phase control in http://www.haskell.org/ghc/docs/7.0.4/html/users_guide/pragmas.html

vector needs to control the stages at which ghc inlines various definitions. First it wants all uses of the functions stream and unstream to be exposed, so that (above all) stream.unstream can be replaced by id, and similarly in other cases, according to the (rewrite) RULE pragmas distributed throughout.

Typical vector to vector functions are written as unstream . f . stream, where f is a Stream to Stream function. unstream builds an actual vector in memory from a Stream; stream reads a real vector into a Stream. The object of the game is to reduce the number of actual vectors built. So the composition of three vector to vector functions

 f_vector . g_vector . h_vector

is really

 unstream . f_stream . stream . unstream . g_stream . stream . unstream . h_stream . stream

which his rewritten to

 unstream . f_stream . g_stream . h_stream . stream

and so on. So we write one new vector instead of three.

The rules for transform are a little fancier than this, but belong with the same subtle system of ordering:

 transform f g (unstream s) = unstream (Bundle.inplace f g s)
 transform f1 g1 (transform f2 g2 p) = transform (f1 . f2) (g1 . g2) p

in https://github.com/haskell/vector/blob/master/Data/Vector/Generic/New.hs#L76

so you can see how something inlined in the form:

unstream . h_stream . stream . transform f1 g1 . transform f2 g2 
                    . unstream . j_stream . stream $ input_vector

would be rewritten.