Liaisons

• let name = expr : nommer une sous-expression pour la réutiliser
• block scope : les liaisons atteignent les blocs imbriqués
• declaration order : une liaison ne voit que les liaisons antérieures
• Playground

let name = expr nomme une sous-expression au sein d'un bloc pour pouvoir la réutiliser — la version Typeflow du $x := ... de JSONata. Les liaisons sont immuables et n'apparaissent pas dans la sortie ; elles n'existent que pour éviter la répétition et clarifier l'intention.

Opérateur	Effet
let name = expr	nommer une sous-expression pour la réutiliser
block scope	les liaisons atteignent les blocs imbriqués
declaration order	une liaison ne voit que les liaisons antérieures

let name = expr : nommer une sous-expression pour la réutiliser

Une liaison let est visible par chaque propriété de son bloc. Elle est calculée une seule fois et se lit comme un identifiant ordinaire — total: base + tax au lieu de répéter les chemins sous-jacents.

let base = order.subtotal
let tax = base * 0.2
total: base + tax

block scope : les liaisons atteignent les blocs imbriqués

Une liaison a pour portée son bloc et chaque bloc imbriqué dedans, si bien qu'un corps de projection (ou un objet imbriqué) peut ajouter ses propres liaisons tout en voyant celles de l'extérieur.

lines: order.items -> {
  let net = price * qty,
  net: net,
  withTax: net * 1.2,
}

declaration order : une liaison ne voit que les liaisons antérieures

Toutes les propriétés d'un bloc peuvent utiliser n'importe laquelle de ses liaisons, mais une liaison ne peut référencer que les liaisons déclarées avant elle — les références en avant et les autoréférences sont rejetées (TF2001), ce qui garantit que les mappings terminent. Deux liaisons du même nom dans un bloc constituent une erreur (TF2018).

let base = order.subtotal
let withTax = base * 1.2

Playground

Mapping✔Playground ↗

input order: { subtotal: number, items: { price: number, qty: number }[] }

map {
  let base = order.subtotal,
  let tax = base * 0.2,
  subtotal: base,
  tax: tax,
  total: base + tax,
  lines: order.items -> {
    let net = price * qty,
    net: net,
    withTax: net * 1.2,
  },
}

input order: { subtotal: number, items: { price: number, qty: number }[] } map { let base = order.subtotal, let tax = base * 0.2, subtotal: base, tax: tax, total: base + tax, lines: order.items -> { let net = price * qty, net: net, withTax: net * 1.2, }, }

JSON d'entrée

{
  "subtotal": 100,
  "items": [{ "price": 10, "qty": 2 }, { "price": 5, "qty": 4 }]
}

{ "subtotal": 100, "items": [{ "price": 10, "qty": 2 }, { "price": 5, "qty": 4 }] }

Sortie

{
  "subtotal": 100,
  "tax": 20,
  "total": 120,
  "lines": [
    {
      "net": 20,
      "withTax": 24
    },
    {
      "net": 20,
      "withTax": 24
    }
  ]
}

type inféré{ subtotal: number; tax: number; total: number; lines: { net: number; withTax: number }[]; }

Pour de la logique à réutiliser entre plusieurs mappings — pas seulement au sein d'un bloc — préférer une fonction : fn pour les helpers purs du langage de mapping, use pour les fonctions hôtes typées.