Transitividad de la especialización automática en GHC

De los documentos para GHC 7.6:

[Y] a menudo ni siquiera necesitas el pragma SPECIALIZE en primer lugar. Al compilar un módulo M, el optimizador de GHC (con -O) considera automáticamente cada función sobrecargada de nivel superior declarada en M, y la especializa para los diferentes tipos a los que se llama en M. El optimizador también considera cada función sobrecargada INLINABLE importada, y lo especializa para los diferentes tipos en los que se llama en M.

y

Además, dado un pragma SPECIALIZE para una función f, GHC creará automáticamente especializaciones para cualquier función sobrecargada de tipo-clase llamada por f, si están en el mismo módulo que el pragma SPECIALIZE, o si son INLINABLES; y así sucesivamente.

Por lo tanto, GHC debería especializar automáticamente algunas / más / todas (?) Funciones marcadas INLINABLE sin un pragma, y ​​si uso un pragma explícito, la especialización es transitiva. Mi pregunta es: ¿la transespecialización automática es transitiva?

Específicamente, aquí hay un pequeño ejemplo:

Main.hs:

import Data.Vector.Unboxed as U
import Foo

main =
    let y = Bar $ Qux $ U.replicate 11221184 0 :: Foo (Qux Int)
        (Bar (Qux ans)) = iterate (plus y) y !! 100
    in putStr $ show $ foldl1' (*) ans

Foo.hs:

module Foo (Qux(..), Foo(..), plus) where

import Data.Vector.Unboxed as U

newtype Qux r = Qux (Vector r)
-- GHC inlines `plus` if I remove the bangs or the Baz constructor
data Foo t = Bar !t
           | Baz !t

instance (Num r, Unbox r) => Num (Qux r) where
    {-# INLINABLE (+) #-}
    (Qux x) + (Qux y) = Qux $ U.zipWith (+) x y

{-# INLINABLE plus #-}
plus :: (Num t) => (Foo t) -> (Foo t) -> (Foo t)
plus (Bar v1) (Bar v2) = Bar $ v1 + v2

GHC se especializa en la llamada a plus, pero no se especializa (+)en la Qux Numinstancia que mata el rendimiento.

Sin embargo, un pragma explícito

{-# SPECIALIZE plus :: Foo (Qux Int) -> Foo (Qux Int) -> Foo (Qux Int) #-}

da como resultado la especialización transitiva como indican los documentos, por lo que (+)está especializado y el código es 30 veces más rápido (ambos compilados con -O2). ¿Es este comportamiento esperado? ¿Debería esperar solo (+)estar especializado transitivamente con un pragma explícito?

ACTUALIZAR

Los documentos para 7.8.2 no han cambiado, y el comportamiento es el mismo, por lo que esta pregunta sigue siendo relevante.

Respuestas cortas:

Los puntos clave de la pregunta, según tengo entendido, son los siguientes:

• "¿es transitiva la especialización automática?"
• ¿Debo esperar que (+) se especialice transitivamente con un pragma explícito?
• (aparentemente previsto) ¿Es esto un error de GHC? ¿Es inconsistente con la documentación?

AFAIK, las respuestas son No, principalmente sí, pero hay otros medios, y No.

La especialización de código en línea y tipo de aplicación es una compensación entre la velocidad (tiempo de ejecución) y el tamaño del código. El nivel predeterminado se acelera sin hinchar el código. La elección de un nivel más exhaustivo se deja a discreción del programador a través de SPECIALISEpragma.

Explicación:

El optimizador también considera cada función sobrecargada INLINABLE importada y la especializa para los diferentes tipos a los que se llama en M.

Supongamos que fes una función cuyo tipo incluye una variable de tipo arestringida por una clase de tipo C a. GHC por defecto se especializa fcon respecto a una aplicación de tipo (sustituyendo apara t) si fse llama con ese tipo de aplicación en el código fuente de (a) cualquier función en el mismo módulo, o (b) si festá marcado INLINABLE, entonces cualquier otro módulo que importaciones f de B. Por lo tanto, la especialización automática no es transitiva, solo toca las INLINABLEfunciones importadas y solicitadas en el código fuente de A.

En su ejemplo, si reescribe la instancia de la Numsiguiente manera:

instance (Num r, Unbox r) => Num (Qux r) where
    (+) = quxAdd

quxAdd (Qux x) (Qux y) = Qux $ U.zipWith (+) x y

• quxAddno es específicamente importado por Main. Mainimporta el diccionario de instancias de Num (Qux Int), y este diccionario contiene quxAdden el registro de (+). Sin embargo, aunque el diccionario se importa, los contenidos utilizados en el diccionario no lo son.
• plusno llama quxAdd, utiliza la función almacenada para el (+)registro en el diccionario de instancias de Num t. Este diccionario se establece en el sitio de la llamada (en Main) por el compilador.