Travailler avec les clôtures lexicales
dans Powershell (2/2)

Retour décidé -en dépit d'une plume quelques fois timide- sur les différentes façons de transposer la technique de clôture lexicale dans PowerShell. Le précédent billet renseignait le lecteur sur la nature dynamique des portées au sein du langage. Arriver maintenant au dénouement de ces pérégrinations relève presque de la formalité.

PowerShell est chapeauté par des principes qui ne sont pas toujours habituels dans le monde des langages de script mais n'en demeure pas moins un outil digne d'intérêt. S'appuyant sur une étendue racine indépendante, un module PowerShell peut être utilisé à des fins de création d'une clôture lexicale, voici comment :

<# Powershell #>
$foo = New-Module -AsCustomObject -ReturnResult -ScriptBlock {
  [int32]$bar = 23;
  Return { set -scope 1 'bar' ($bar+1) ; $bar }
}
& $foo # retourne «24»
& $foo # retourne «25»

<# version condensée: #>
$foo = nmo -As -R -S {
  [int32]$bar = 23;
  Return { set -scope 1 'bar' ($bar+1) ; $bar }
}
& $foo # retourne «24»
& $foo # retourne «25»

Plus conventionnelle, la méthode GetNewClosure() (qui repose en interne sur la mécanique des modules) s'utilise de la façon suivante :

<# Powershell #>
$foo = & {
  [int32]$bar = 23;
  Return { set -scope 1 'bar' ($bar+1) ; $bar }.GetNewClosure()
}
& $foo # retourne «24»
& $foo # retourne «25»

En définitive, les modules dynamiques personnalisés contribuent très raisonnablement à compléter les possibilités du langage et offrent un tremplin naturel vers la préparation d'une clôture lexicale.

Travailler avec les clôtures lexicales
dans Powershell (1/2)

Certaines procédures inscrites au cœur de la création d'un jeu vidéo suggèrent souvent l'utilisation de langages de script. Qu'il s'agisse d'aménager un processus de compilation ou plus simplement de générer des Assets, ces langages apparaissent définitivement utiles.

Dans cette perspective, une approche intéressante (que d'aucuns qualifieront peut-être de marginale) consiste à se tourner vers Powershell, une solution développée et éditée par Microsoft. Construit par dessus l'écosystème .net, Powershell repose sur une bibliothèque riche en fonctionnalités. Il est bien entendu laissé à l'appréciation du développeur de le substituer à d'autres outils plus conventionnels tels que Node.Js ou Python.

Généralement comprise dans la boite à outils du développeur, la clôture lexicale (ou en anglais : function closure) est une technique à tonalité fonctionnelle souvent impliquée dans des pratiques de programmation originales. Transposer cette technique vers Powershell n'est cependant pas trivial et va demander une certaine gymnastique pour y parvenir. Un exercice simple consiste à prendre pour exemple ce code Javascript:

/* Javascript */
let $bar = 820;
label: { let $bar = 23; var $foo = () => ++$bar; }
$foo(); // affiche "24"
$foo(); // affiche "25"
$bar; // affiche "820"

Par deux fois dans le code, une variable $bar est déclarée. D'abord, à titre global et, enfin, au sein du bloc étiqueté label. Dans le bloc label, la variable est privée et a la durée de vie de la fonction $foo qui la capture. La portée d'une variable Javascript est dite lexicale. Une tentative inspirée mais erronée de transposer vers Powershell pourrait ressembler au code suivant:

<# Powershell #>
[int32]$bar = 820;
$foo = & {
  [int32]$bar = 23;
  Return { set -scope 1 'bar' ($bar+1) ; $bar }
}
& $foo; # affiche "821"
& $foo; # affiche "822"
$bar; # affiche "822"

Le code exécuté fait apparaître des différences immédiatement perceptibles. Powershell adopte la méthode de portée dynamique où la durée de vie d'une variable dépend de la position de sa création dans la pile d'appels. Dans l'exemple, la seconde variable $bar, à laquelle a été assignée la valeur 23, n'est plus disponible dans l'étendue dynamique au moment d'appeler le bloc d'instructions $foo. La portée appelante intervient dans un niveau parent de l'étendue où la liaison originelle a disparu. L'acheminement d'une variable dans la chaîne d'appels s'illustre simplement ci-dessous:

<# Powershell et portée dynamique de variable #>
$foo = { ('«',$bar,'»' -join '') }
& { $bar = 'Hello'; & $foo } # affiche "«Hello»"
& { $bar = 'World'; & $foo } # affiche "«World»"

Cette manière de composer, sans doute peu ordinaire, présente des perspectives de conception intéressantes lors d'un développement. Point d'ancrage utile qui permet de se diriger, à l'occasion du prochain billet, vers une mise en œuvre concrète de la clôture au sein du langage.