Un Goloiste peut il être plus fonctionnel qu’un Scalafiste?

Cédric Beust, dans le dernier podcast des CastCodeurs, explique le point de vue de la programmation fonctionnelle de cette façon: quand une fonction lance une exception elle ne retourne pas une valeur et ça casse le raisonnement fonctionnel, donc il faut pouvoir toujours retourner “quelque chose”, par exemple retourner un type T si tout va bien ou un type E (ou une variante du type T) si il y a une erreur. Ce qui permet de continuer le “raisonnement” fonctionnel dans votre code. Tout ça est mon interprétation des paroles de Cédric Beust bien sûr.

Ces concepts sont faciles à mettre en oeuvre avec le langage Golo. Pour rappel, Golo est un langage dynamique pour la JVM, il est tout petit (530kb) mais il peut déjà jouer dans la cour des grands. Ses multiples influences lui apportent de nombreuses possibilités et notamment dans sa capacité à être “augmenté”.

Nous allons donc voir comment mettre en oeuvre des fonctions qui en cas d’erreur retournent quand même quelque chose quoiqu’il se passe (je traiterais aussi la notion de valeur null).

Traiter “fontionnellement” mes exceptions, partie 1

Ma première spécification va donc être la suivante:

• Permettre à mes fonctions de pouvoir retourner un type T dont l’instance peut avoir une valeur ou une erreur.

En Golo, on a des structures, du coup mon type sera le suivant:

struct T = { 
  value,
  error
}

Et je peux ensuite l’instancier de cette manière:

let a = T()
a: value(5): error(null)
let b = T(42, null)
#  etc. ...

Gérer les valeurs null

Il se trouve qu’en Golo, il est possible de greffer des méthodes aux structures avec le mot clé augment. Je vais donc ajouter une méthode getOrElse à ma structure pour gérer les valeurs null:

augment T {
  function getOrElse = |this, replacementIfNull| {
    if this: value() is null {
      if replacementIfNull oftype java.lang.invoke.DirectMethodHandle.class {
        return replacementIfNull(this)
      }
      return replacementIfNull
    }
    return this: value()  
  } 
}

Cela signifie que je vais pouvoir écrire ceci:

let a = T(null, null)
let b = a: getOrElse("n/a") #  b == "n/a"

ou ceci en passant une fonction anonyme dont le paramètre est la référence à l’instance de type:

let a = T(null, null)
let b = a: getOrElse(|instanceOfT| {
  println("Argh! b is null")
  return 42
}) #  b == 42

Remarque: en Golo il existe le mot clé orIfNull qui permet de gérer ça facilement, mais j’ai fait comme cela pour introduire la suite.

Gérer les exceptions

Il est tout à fait possible de surcharger une méthode d’augmentation, donc on va augmenter encore plus notre structure en gérant un comportement en cas d’exception.

augment T {
  function getOrElse = |this, replacementIfNull| {
    if this: value() is null {
      if replacementIfNull oftype java.lang.invoke.DirectMethodHandle.class {
        return replacementIfNull(this)
      }
      return replacementIfNull
    }
    return this: value()  
  } 

  #  surcharge de getOrElse
  function getOrElse = |this, replacementIfNull, replacementIfError| {    
    if this: error() isnt null {
      if replacementIfError oftype java.lang.invoke.DirectMethodHandle.class {
        return replacementIfError(this)
      }
      return replacementIfError
    } else {
      if this: value() is null {
        if replacementIfNull oftype java.lang.invoke.DirectMethodHandle.class {
          return replacementIfNull(this)
        }
        return replacementIfNull
      }
      return this: value()
    }
  }
}

Cela s’utilisera dans le même principe que la gestion des valeurs null. Codons une méthode divide qui va faire une division:

function divide = |a, b| {
  let ret = T(null, null)
  try {
    ret: value(a/b)
  } catch (e) {
    ret: error(e)
  } finally {
    return ret
  }
}

Et je pourrais utiliser ma fonction de cette manière:

let d = divide(5,0): getOrElse("n/a", "Huston? We've got a problem!")
#  d == "Huston? We've got a problem!"

J’ai généré une exception car je fais une division par 0, mais je n’arrête pas mon programme et d a tout de même une valeur.

Comme précédemment je peux aussi faire ceci:

let d = divide(5,0): getOrElse("n/a", |instanceOfT| {
  println(instanceOfT: error()) #  display "java.lang.ArithmeticException: / by zero"
  return 42
}) #  d == 42

Là je commence à être fier de moi (un peu d’autosatisfaction ne fait pas de mal), mais je trouve que le try catch finally c’est laid à lire, je vais donc utiliser une nouveauté de Golo pour faire encore mieux.

Traiter “fontionnellement” mes exceptions, partie 2

Depuis peu, on trouve la notion de decorator (façon Python) dans Golo. Cela correspond à “décorer” une fonction avec une autre fonction, ce qui permet d’agir avant et après l’exécution d’une fonction (pas clair ? Avec un exemple ça ira (peut-être) mieux).

Mon objectif est de “virer” le try catch finally du corps de mes méthodes. Je vais donc faire un decorator:

function withGoloType = |decoratorArgs...| {
  return |func| { #  return decorated function
    return |functionArgs...| {
      let ret = T(null, null)
      try {
        ret: value(func: invokeWithArguments(functionArgs))
      } catch (e) {
        ret: error(e)
      } finally {
        return ret
      } 
    }
  }
}

Alors:

• withGoloType c’est ma fonction decorator
• funcdans return |func| c’est la fonction retournée

Globalement je fais des traitements et je peux invoquer ma fonction comme ceci: func: invokeWithArguments(functionArgs)

Dans mon cas,

• j’instancie un type T: let ret = T(null, null)
• ensuite “j’essaye” de renseigner la propriété value de ret avec le résultat de la fonction décorée: ret: value(func: invokeWithArguments(functionArgs))
• si ça se passe mal, je “stocke” l’exception: ret: error(e)
• et au final je retourne mon instance de type

Et cela s’utilise comme ceci:

#  implémentation de la méthode divide
#  décoration de la méthode divide

@withGoloType()
function divide = |a, b| {
  return a/b
}

function main = |args| {

  let d = divide(5,0): getOrElse("n/a", |instanceOfT| {
    println(instanceOfT: error())
    return 42
  })

}

Une fois décorée, divide ne retournera plus de valeur numérique, mais un type T qui permettra de fournir une valeur avac sa méthode getOrElse.

Voilà, vous venez de voir comment il est très facile d’apporter de nouveaux comportements à Golo et de faire du fonctionnel avec (c’est un moyen, il y en a beaucoup d’autres, mais ce sera pour de prochains articles).

@+ P.