Projection

• -> : transformer chaque élément d'un tableau en une nouvelle forme d'objet
• $ : l'élément courant (requis pour les tableaux de scalaires)
• -> alias : nommer l'élément courant
• -> alias, index : nommer l'élément et sa position (base 0)
• $root, $parent : atteindre l'entrée ou l'élément englobant
• Playground

array -> { ... } transforme chaque élément d'un tableau en une nouvelle forme d'objet. C'est le remplaçant de Array.prototype.map en Typeflow.

Opérateur	Effet
->	transformer chaque élément d'un tableau en une nouvelle forme d'objet
$	l'élément courant (requis pour les tableaux de scalaires)
-> alias	nommer l'élément courant
-> alias, index	nommer l'élément et sa position (base 0)
$root, $parent	atteindre l'entrée ou l'élément englobant

-> : transformer chaque élément d'un tableau en une nouvelle forme d'objet

Dans le corps de la projection, les identifiants nus se résolvent sur l'élément courant, et $ est l'élément lui-même. Les constructions postfixes s'enchaînent — filtrer d'abord (arr[bool] -> { ... }), puis remodeler les survivants.

views: user.labels -> {
  label: upper(name),
  active: active,
  original: $,
}

$ : l'élément courant (requis pour les tableaux de scalaires)

Pour les tableaux de scalaires, $ est le seul moyen de référencer l'élément.

detailed: stats.scores -> {
  value: $,
  doubled: $ * 2,
  passed: $ >= 12,
}

-> alias : nommer l'élément courant

Comme les identifiants nus se résolvent sur l'élément courant, un champ d'élément masque une variable externe du même nom — y compris l'entrée. Donner à l'élément un alias explicite avec -> alias { ... } et référencer ses champs via l'alias ; les noms nus, l'alias et $ restent tous disponibles, et la portée parente n'est jamais masquée.

views: user.labels -> l {
  label: upper(l.name),
  active: l.active,
  original: $,
}

-> alias, index : nommer l'élément et sa position (base 0)

Un second binder capture l'index base 0 de l'élément dans le tableau, en number — utile pour des ordinaux ou des identifiants séquentiels. Les deux binders se nomment : -> el, i { ... }. L'élément reste accessible via $ et les champs nus ; nommer l'élément _ quand seul l'index est utile.

ranked: board.scores -> s, i {
  rank: i + 1,
  score: s,
}

$root, $parent : atteindre l'entrée ou l'élément englobant

En restant dans le style des champs nus, $root atteint l'entrée à travers n'importe quel niveau d'imbrication — même au-delà d'un champ qui la masque — et $parent atteint l'élément de la projection ou du filtre englobant. On peut l'enchaîner — $parent.$parent remonte de deux niveaux, $parent.$parent.$parent de trois — et une chaîne qui dépasse tous les éléments englobants atterrit sur l'entrée. Au premier niveau (un seul ->), l'élément n'a pas d'élément englobant, donc $parent est déjà l'entrée, comme $root.

regions: doc.regions -> {
  code: code,
  cities: cities -> {
    districts: districts -> {
      name: name,
      city: $parent.name,
      region: $parent.$parent.code,
    },
  },
}

Playground

Mapping✔Playground ↗

input user: { org: string, labels: { name: string, active: boolean }[] }

map {
  activeViews: user.labels[active] -> l {
    label: upper(l.name),
    slug: lower(l.name),
    org: $root.org,
  },
}

input user: { org: string, labels: { name: string, active: boolean }[] } map { activeViews: user.labels[active] -> l { label: upper(l.name), slug: lower(l.name), org: $root.org, }, }

JSON d'entrée

{
  "org": "acme",
  "labels": [
    { "name": "Founder", "active": true },
    { "name": "Legacy", "active": false },
    { "name": "Math", "active": true }
  ]
}

{ "org": "acme", "labels": [ { "name": "Founder", "active": true }, { "name": "Legacy", "active": false }, { "name": "Math", "active": true } ] }

Sortie

{
  "activeViews": [
    {
      "label": "FOUNDER",
      "slug": "founder",
      "org": "acme"
    },
    {
      "label": "MATH",
      "slug": "math",
      "org": "acme"
    }
  ]
}

type inféré{ activeViews: { label: string; slug: string; org: string }[]; }

Les corps de projection sont des corps de map à part entière : ils peuvent imbriquer des objets, utiliser des conditionnelles, appeler des fonctions — tout ce qu'un champ de premier niveau peut faire. Utiliser un alias (-> l { ... }) dès qu'un champ d'élément masquerait un nom encore nécessaire, et $root / $parent pour atteindre l'extérieur depuis le corps.