Haskell Language
Flèches

Composition de fonction avec plusieurs canaux

Arrow est, en gros, la classe des morphismes qui composent des fonctions semblables, avec à la fois une composition en série et une «composition parallèle». Bien qu'il soit intéressant de généraliser les fonctions, l'instance Arrow (->) elle-même est déjà très utile. Par exemple, la fonction suivante:

spaceAround :: Double -> [Double] -> Double
spaceAround x ys = minimum greater - maximum smaller
 where (greater, smaller) = partition (>x) ys

peut aussi être écrit avec des combinateurs de flèches:

spaceAround x = partition (>x) >>> minimum *** maximum >>> uncurry (-)

Ce type de composition peut être visualisé avec un diagramme:

                       ──── minimum ────
                   ╱           *            ╲
──── partition (>x) >>>        *        >>>  uncurry (-) ───
                   ╲           *            ╱
                       ──── maximum ──── 

Ici,

• L' opérateur >>> n'est qu'une version inversée de l'ordinaire . opérateur de composition (il y a aussi une version <<< qui compose de droite à gauche). Il achemine les données d'une étape de traitement à l'autre.

• les going ╱ ╲ indiquent que le flux de données est divisé en deux «canaux». En termes de types Haskell, ceci est réalisé avec des tuples:

  partition (>x) :: [Double] -> ([Double], [Double])
  

  divise le flux en deux canaux [Double] , tandis que

  uncurry (-) :: (Double,Double) -> Double
  

  fusionne deux canaux Double .

• *** est l'opérateur de composition parallèle ^† . Il permet au maximum et au minimum fonctionner indépendamment sur différents canaux des données. Pour les fonctions, la signature de cet opérateur est

  (***) :: (b->c) -> (β->γ) -> (b,β)->(c,γ)
  

^† _{Au moins dans la catégorie Hask (c'est-à-dire dans l'instance Arrow (->) ), f***g ne calcule pas réellement f et g en parallèle comme dans, sur des threads différents. Cela serait théoriquement possible, cependant.}