Relégué au second plan avec l'apparition de WebAssembly, Asm.js apparait pourtant encore comme une avancée technique bardée de bonnes idées. La technologie ancre les avantages du bas niveau dans le navigateur tout en conservant la rétrocompatibilité avec Javascript.

Assez criante aujourd'hui, l'absence de solution pour générer du code en conformité avec Asm.js rend difficile l'accès à cette technologie. Les optimisations Asm.js sont toutefois parfaitement prises en charge dans de nombreux navigateurs tels que Chromium (>=61) ou Firefox (>=34).

L'entrée en scène de Wasm2Asmjs

En interne, coffeetales.net s'appuie un outil de transpilation Wasm vers Asm.js développé avec Node.js. Les sources sont disponibles à l'adresse : https://github.com/COFFEETALES/wasm2asmjs. Une utilisation de wasm2asmjs peut aboutir à ce code exemple:

var asmjs_func = function(stdlib, foreign, buffer) {
  'use asm';
  function $iiiSub($iiiSub_aa, $iiiSub_ab) {
    $iiiSub_aa = $iiiSub_aa | 0;
    $iiiSub_ab = $iiiSub_ab | 0;
    var $iiiSub_ac = 0;
    $iiiSub_ac = $iiiSub_aa - $iiiSub_ab | 0;
    return $iiiSub_ac | 0;
  }
  return {
    export_iiiSub: $iiiSub
  };
};

Avec ce levier prévu par la spécification pour une exploitation en Javascript:

var l = asmjs_func(self, void 0, new ArrayBuffer(0x10000));
// ^ indispensable pour embrayer correctement sur les optimisations asm.js
console.log(l.export_iiiSub(10, 5));

Pour le développeur, il ne s'agit pas de se détourner de WebAssembly qui présente d'importantes innovations mais bien de rester attentif aux autres possibilités non moins intéressantes.

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.