Haskell: pourquoi la convention au nom d'une aide de la fonction “go”?

Hmm! Certains l'archéologie!

Depuis 2004, j'ai utilisé go comme le nom générique de la queue-récursive travailleur boucles, dans le cas d'un travailleur/wrapper transformation d'une fonction récursive. J'ai commencé à l'utiliser largement dans bytestring, par exemple

foldr :: (Word8 -> a -> a) -> a -> ByteString -> a
foldr k v (PS x s l) = inlinePerformIO $ withForeignPtr x $ \ptr ->
        go v (ptr `plusPtr` (s+l-1)) (ptr `plusPtr` (s-1))
    where
        STRICT3(go)
        go z p q | p == q    = return z
                 | otherwise = do c  <- peek p
                                  go (c `k` z) (p `plusPtr` (-1)) q -- tail recursive
{ -# INLINE foldr #- }

était de bytestring en août 2005.

C'est écrit dans RWH, et a probablement été popularisée à partir de là. Aussi, dans le flux de fusion bibliothèque, Duncan Coutts et j'ai commencé à faire beaucoup.

Du GHC sources

L'idiome remonte plus loin cependant. foldr dans GHC.La Base de est donnée sous la forme:

foldr k z = go
      where
         go []     = z
         go (y:ys) = y `k` go ys

qui est probablement là où j'ai pris le truc (je pensais que c'était de Andy Gill de la thèse, mais ne peut pas trouver toute utilisation de go là). Il n'est pas donné dans cette forme, en bonne à tout faire, donc je pense que c'est d'abord apparu dans le GHC base de code.

En 2001, Simon Marlow a l'aide de go dans certains des systèmes de code de niveau, de sorte que nous pourrions placer le blâme quelque part dans GHC, et cette idée nous conduit à le GHC source, où go est largement utilisé dans les travailleur fonctions:

myCollectBinders expr
  = go [] expr
  where
    go bs (Lam b e)          = go (b:bs) e
    go bs e@(Note (SCC _) _) = (reverse bs, e)
    go bs (Cast e _)         = go bs e
    go bs (Note _ e)         = go bs e
    go bs e                  = (reverse bs, e)

GHC 3.02 et Glasgow

Déterrer de vieilles versions de GHC, nous voyons que dans GHC 0.29 cet idiome n'apparaît pas, mais par GHC 3.02 de la série (1998), la go idiome s'affiche partout. Un exemple, dans Numeric.lhs, dans la définition de showInt, daté de 1996-1997:

showInt n r
  | n < 0     = error "Numeric.showInt: can't show negative numbers"
  | otherwise = go n r
    where
     go n r =
      case quotRem n 10 of                 { (n', d) ->
      case chr (ord_0 + fromIntegral d) of { C# c# -> -- stricter than necessary
      let
    r' = C# c# : r
      in
      if n' == 0 then r' else go n' r'
      }}

c'est une mise en œuvre différente de celle donné dans le rapport H98. Creuser dans la mise en œuvre de "Numérique.lhs", cependant, nous trouvons que ce n'est pas la même que la version qui a été ajouté à GHC 2,06 en 1997, et un très intéressant patch de Sigbjorne Finne apparaît, en avril 1998, ajouter aller de la boucle Numérique.de gauche.

Ce dit que, au moins, en 1998, Sigbjorne a été l'ajout d' go boucles pour le GHC "std" de la bibliothèque, tandis que, simultanément, de nombreux les modules dans le GHC compilateur de base avait go boucles. En creusant un peu, ce très intéressant s'engager dans Partain, en juillet 1996, ajoute un "go" en boucle dans GHC -- le code provient de Simon PJ si!

Donc je vais l'appeler ce que un Glasgow idiome inventé par des gens à Glasgow qui a travaillé sur le GHC dans le milieu des années 90, tels que Simon Marlow, Sigbjorn Finne, Va Partain et Simon Peyton Jones.

Je m'attends à ce langage pour être applicable non seulement aux structures linéaires (et donc des "boucles"), mais aussi à la ramification (arbre) des structures.

Je me demande combien de fois le go modèle correspond à l'accumulation de paramètres et, plus généralement, avec la poursuite de codage strategites que Mitch Baguette explorées dans l'étude Poursuite Programme en Fonction des Stratégies de Transformation (un de mes préféré de tous les temps les papiers).
Dans ces cas, la go fonction a un sens particulier, qui peut ensuite être utilisé pour dériver un code efficace, à partir d'un élégant spécification.