@neocompose/cli 0.33.2 → 0.34.0

package/CHANGELOG.md

@@ -1,5 +1,19 @@
 # Changelog
 
+## [0.34.0] - 2026-08-19
+
+### Added
+
+- P71 `List.Repeat`: call `List.Repeat(value, count)` from any NeoScript body
+  to build a list of `count` copies of `value`. The entry type is inferred
+  from the value and joined with the assignment context, so
+  `List<float> w = List.Repeat(0, 4)` widens; `count` must be an `int`, a
+  negative count is a runtime error, and materialization is charged to the
+  shared collection-entries budget.
+- Unity export schema version 25, so an SDK that predates `listRepeat` refuses
+  the export with the standard upgrade message instead of failing
+  mid-deserialize.
+
 ## [0.33.2] - 2026-08-19
 
 ### Fixed

package/dist/neo.mjs

@@ -1336,7 +1336,7 @@ function vectorTypes() {
     members: structuredLeafFieldProperties(name)
   }));
 }
-var NEO_PROJECT_IGNORED_DIRECTORY_NAMES, NEOSCRIPT_KEYWORDS, NEOSCRIPT_INFERRED_LOCAL_KEYWORD, NEOSCRIPT_CONSTRUCTOR_KEYWORD, NEOSCRIPT_PRIMITIVE_TYPES, NEOSCRIPT_BUILTIN_ANNOTATION_TYPES, NEOSCRIPT_BUILTIN_NAMESPACES, NEOSCRIPT_BUILTIN_TYPES, NEO_VARIANT_TYPE_NAME, NEO_VARIANT_FOLDER_TYPE_NAME, NEO_LOOKUP_VARIANT_TYPE_NAME, NEO_LOOKUP_VARIANT_FOLDER_TYPE_NAME, NEO_VARIANT_SCOPE_NAME, NEO_VARIANT_RESERVED_NAME, NEO_VARIANT_FOLDER_PATH_SEPARATOR, NEOSCRIPT_OPERATORS, NEOSCRIPT_STATEMENT_SNIPPETS, STRING_TYPE, INT_TYPE, FLOAT_TYPE, BOOL_TYPE, IMAGE_REF_TYPE, SPRITE_INFO_TYPE, FLOAT_OPTIONAL_TYPE, NEOSCRIPT_STRUCTURED_LEAF_FIELDS, NEOSCRIPT_IMAGE_REGISTRY_TYPE, NEOSCRIPT_AUDIO_CLIP_REGISTRY_TYPE, NEOSCRIPT_PENDING_SYMBOL_ID_PREFIX, REGISTRY_ENTRY_TYPES, NEOSCRIPT_GLOBALS, NEOSCRIPT_SPRITE_INFO_EMPTY_MEMBER_ID, NEOSCRIPT_SPRITE_INFO_EMPTY_VALUE, NEOSCRIPT_MATH_TYPE_ID, MATH_INFERENCE_RULE, MATH_INTEGRAL_RULE, NEOSCRIPT_BUILTIN_TYPE_SYMBOLS;
+var NEO_PROJECT_IGNORED_DIRECTORY_NAMES, NEOSCRIPT_KEYWORDS, NEOSCRIPT_INFERRED_LOCAL_KEYWORD, NEOSCRIPT_CONSTRUCTOR_KEYWORD, NEOSCRIPT_PRIMITIVE_TYPES, NEOSCRIPT_BUILTIN_ANNOTATION_TYPES, NEOSCRIPT_BUILTIN_NAMESPACES, NEOSCRIPT_BUILTIN_TYPES, NEO_VARIANT_TYPE_NAME, NEO_VARIANT_FOLDER_TYPE_NAME, NEO_LOOKUP_VARIANT_TYPE_NAME, NEO_LOOKUP_VARIANT_FOLDER_TYPE_NAME, NEO_VARIANT_SCOPE_NAME, NEO_VARIANT_RESERVED_NAME, NEO_VARIANT_FOLDER_PATH_SEPARATOR, NEOSCRIPT_OPERATORS, NEOSCRIPT_STATEMENT_SNIPPETS, STRING_TYPE, INT_TYPE, FLOAT_TYPE, BOOL_TYPE, IMAGE_REF_TYPE, SPRITE_INFO_TYPE, FLOAT_OPTIONAL_TYPE, NEOSCRIPT_STRUCTURED_LEAF_FIELDS, NEOSCRIPT_IMAGE_REGISTRY_TYPE, NEOSCRIPT_AUDIO_CLIP_REGISTRY_TYPE, NEOSCRIPT_PENDING_SYMBOL_ID_PREFIX, REGISTRY_ENTRY_TYPES, NEOSCRIPT_GLOBALS, NEOSCRIPT_SPRITE_INFO_EMPTY_MEMBER_ID, NEOSCRIPT_SPRITE_INFO_EMPTY_VALUE, NEOSCRIPT_MATH_TYPE_ID, MATH_INFERENCE_RULE, MATH_INTEGRAL_RULE, NEOSCRIPT_LIST_TYPE_NAME, NEOSCRIPT_LIST_TYPE_ID, NEOSCRIPT_LIST_REPEAT_NAME, LIST_ENTRY_TYPE, NEOSCRIPT_BUILTIN_TYPE_SYMBOLS;
 var init_language_spec = __esm({
   "../packages/neoscript-language/src/language-spec.ts"() {
     "use strict";
@@ -1680,6 +1680,14 @@ var init_language_spec = __esm({
     NEOSCRIPT_MATH_TYPE_ID = "builtin:Math";
     MATH_INFERENCE_RULE = "Accepts int, float, or decimal; the result mirrors the widest argument type.";
     MATH_INTEGRAL_RULE = "Accepts int, float, or decimal; int and float return int, decimal returns decimal.";
+    NEOSCRIPT_LIST_TYPE_NAME = "List";
+    NEOSCRIPT_LIST_TYPE_ID = "builtin:List";
+    NEOSCRIPT_LIST_REPEAT_NAME = "Repeat";
+    LIST_ENTRY_TYPE = {
+      kind: "typeParameter",
+      id: `${NEOSCRIPT_LIST_TYPE_ID}:entry`,
+      name: "T"
+    };
     NEOSCRIPT_BUILTIN_TYPE_SYMBOLS = [
       {
         id: "builtin:SpriteInfo",
@@ -1833,6 +1841,27 @@ var init_language_spec = __esm({
             static: true
           }
         ]
+      },
+      {
+        id: NEOSCRIPT_LIST_TYPE_ID,
+        name: NEOSCRIPT_LIST_TYPE_NAME,
+        kind: "builtin",
+        documentation: "The ordered collection type. Write List<T> to annotate, and bare List to reach its static factories.",
+        members: [
+          {
+            id: `${NEOSCRIPT_LIST_TYPE_ID}:function:${NEOSCRIPT_LIST_REPEAT_NAME}`,
+            name: NEOSCRIPT_LIST_REPEAT_NAME,
+            kind: "function",
+            type: { kind: "list", elementType: LIST_ENTRY_TYPE },
+            returnType: { kind: "list", elementType: LIST_ENTRY_TYPE },
+            parameters: [
+              parameter("value", LIST_ENTRY_TYPE),
+              parameter("count", INT_TYPE)
+            ],
+            documentation: "Returns a list of count copies of value. The entry type is inferred from value and the assignment context \u2014 never spell it. value is evaluated exactly once, then count exactly once, so a reference-typed value is the same reference in every entry; count must be a non-negative int, and 0 produces an empty list.",
+            static: true
+          }
+        ]
       }
     ];
   }
@@ -6975,6 +7004,9 @@ var init_strict_parser = __esm({
         if (t.kind === "keyword" && t.text === "Dictionary") {
           return true;
         }
+        if (t.kind === "keyword" && (t.text === "List" || t.text === "Set") && this.peek(1).kind === "op" && this.peek(1).text === "<") {
+          return true;
+        }
         if (t.kind !== "ident") return false;
         let j = this.i + 1;
         const tk = (k) => this.tokens[k];
@@ -7233,6 +7265,15 @@ var init_strict_parser = __esm({
         let expr = this.parsePrimary();
         while (true) {
           const t = this.peek();
+          if (t.kind === "op" && t.text === "<" && expr.kind === "ident" && expr.name === NEOSCRIPT_LIST_TYPE_NAME) {
+            const member = this.genericStaticMemberName();
+            if (member !== null) {
+              throw new CompileError(
+                `Do not spell type arguments on '${NEOSCRIPT_LIST_TYPE_NAME}.${member}'; the entry type is inferred from the value.`,
+                t.pos
+              );
+            }
+          }
           if (t.kind === "op" && t.text === "<" && this.looksLikeGenericCall()) {
             this.next();
             const typeArguments = [this.parseType()];
@@ -7322,6 +7363,28 @@ var init_strict_parser = __esm({
           return expr;
         }
       }
+      /**
+       * The member name in a `<T, …>.Member` spelling at the cursor, or `null`
+       * when the `<` is an ordinary comparison. Type arguments never precede a
+       * member access in NeoScript, so this shape is always an author mistake and
+       * the name is what a diagnostic needs to describe it.
+       */
+      genericStaticMemberName() {
+        const open = this.tokens[this.i];
+        if (open?.kind !== "op" || open.text !== "<") return null;
+        let index = this.scanType(this.i + 1);
+        if (index === null) return null;
+        while (this.tokens[index]?.kind === "punct" && this.tokens[index]?.text === ",") {
+          index = this.scanType(index + 1);
+          if (index === null) return null;
+        }
+        const close = this.tokens[index];
+        const dot = this.tokens[index + 1];
+        const member = this.tokens[index + 2];
+        if (close?.kind !== "op" || close.text !== ">") return null;
+        if (dot?.kind !== "punct" || dot.text !== ".") return null;
+        return member?.kind === "ident" ? member.text : null;
+      }
       looksLikeGenericCall() {
         const open = this.tokens[this.i];
         if (open?.kind !== "op" || open.text !== "<") return false;
@@ -9431,7 +9494,7 @@ function switchValueKey(value) {
   const enumId = value.typeInfo.type === 8 /* Enum */ ? value.typeInfo.enumId : null;
   return JSON.stringify([value.typeInfo.type, enumId, value.value]);
 }
-var CONSTRUCTING_FUNCTION_KINDS, VARIANT_INITIALIZE_NAME, VARIANT_APPLY_NAME, MATH_NAMESPACE_NAME, MATH_FUNCTIONS, MATH_CONSTANTS, WRITE_TARGET_DESCRIPTIONS, FALLTHROUGH_LABELS, Scope, StrictNeoScriptResolver, SPRITE_DERIVED_MEMBERS;
+var CONSTRUCTING_FUNCTION_KINDS, VARIANT_INITIALIZE_NAME, VARIANT_APPLY_NAME, MATH_NAMESPACE_NAME, MATH_FUNCTIONS, MATH_CONSTANTS, LIST_STATIC_FUNCTIONS, WRITE_TARGET_DESCRIPTIONS, FALLTHROUGH_LABELS, Scope, StrictNeoScriptResolver, SPRITE_DERIVED_MEMBERS;
 var init_strict_resolver = __esm({
   "../packages/neoscript-language/src/strict-resolver.ts"() {
     "use strict";
@@ -9472,6 +9535,9 @@ var init_strict_resolver = __esm({
       ["PI", 3.141592653589793],
       ["E", 2.718281828459045]
     ]);
+    LIST_STATIC_FUNCTIONS = /* @__PURE__ */ new Map([
+      [NEOSCRIPT_LIST_REPEAT_NAME, { arity: 2 }]
+    ]);
     WRITE_TARGET_DESCRIPTIONS = {
       this: "`this`",
       local: "a local",
@@ -11123,7 +11189,8 @@ var init_strict_resolver = __esm({
               expression.callee,
               expression.args,
               scope,
-              expression.pos
+              expression.pos,
+              expected
             );
           case "new": {
             const vector = this.targetTypedVectorKind(expression, expected);
@@ -11770,6 +11837,12 @@ var init_strict_resolver = __esm({
             pos
           );
         }
+        if (name === NEOSCRIPT_LIST_TYPE_NAME) {
+          throw new CompileError(
+            `'${NEOSCRIPT_LIST_TYPE_NAME}' is a type and cannot be used as a value.`,
+            pos
+          );
+        }
         const type = this.project.typeByName.get(name);
         if (type?.kind === "enum") {
           return {
@@ -12222,6 +12295,15 @@ var init_strict_resolver = __esm({
             }
             return this.resolveMathMemberRead(name, pos);
           }
+          if (receiverAst.name === NEOSCRIPT_LIST_TYPE_NAME) {
+            if (optional) {
+              throw new CompileError(
+                `Optional chaining is not valid on type '${NEOSCRIPT_LIST_TYPE_NAME}'.`,
+                pos
+              );
+            }
+            return this.resolveListStaticMemberRead(name, pos);
+          }
           const staticType = this.project.typeByName.get(receiverAst.name);
           if (staticType && staticType.kind !== "enum") {
             if (optional) {
@@ -12851,7 +12933,97 @@ var init_strict_resolver = __esm({
           )
         };
       }
-      resolveCall(callee, argumentsList2, scope, pos) {
+      /**
+       * P71 §1.2. A member read on the `List` qualifier. Nothing on `List` is
+       * readable as a value: the statics are functions, and there are no
+       * constants.
+       */
+      resolveListStaticMemberRead(name, pos) {
+        if (LIST_STATIC_FUNCTIONS.has(name)) {
+          throw new CompileError(
+            `'${NEOSCRIPT_LIST_TYPE_NAME}.${name}' must be called with \`()\`; it cannot be read as a value.`,
+            pos
+          );
+        }
+        throw new CompileError(
+          `'${NEOSCRIPT_LIST_TYPE_NAME}' has no static member '${name}'.`,
+          pos
+        );
+      }
+      /** P71 §1.1. A static-factory call on the bare `List` qualifier. */
+      resolveListStaticCall(name, args, scope, expected, pos) {
+        const fn = LIST_STATIC_FUNCTIONS.get(name);
+        if (!fn) {
+          throw new CompileError(
+            `'${NEOSCRIPT_LIST_TYPE_NAME}' has no static member '${name}'.`,
+            pos
+          );
+        }
+        requireArgCount(`${NEOSCRIPT_LIST_TYPE_NAME}.${name}`, args, fn.arity, pos);
+        return this.resolveListRepeat(args, scope, expected);
+      }
+      /**
+       * P71 §2/§3. `List.Repeat(value, count)`: the entry type is the value's
+       * type joined with the contextual entry type — the list-literal join,
+       * numeric widening included — and the count is an `int` with no implicit
+       * narrowing. Lowers to a `listRepeat` intrinsic carrying the value pointer,
+       * the count pointer, and the joined entry type the evaluators must not
+       * re-derive.
+       */
+      resolveListRepeat(args, scope, expected) {
+        const label = `${NEOSCRIPT_LIST_TYPE_NAME}.${NEOSCRIPT_LIST_REPEAT_NAME}`;
+        const expectedEntry = expected?.kind === "list" ? expected.elementType : void 0;
+        const valueAst = requiredAt(args, 0);
+        const countAst = requiredAt(args, 1);
+        const value = this.resolveExpression(valueAst, scope, expectedEntry);
+        const count = this.resolveExpression(countAst, scope, {
+          kind: "primitive",
+          name: "int"
+        });
+        if (isNullable(count.type)) {
+          throw new CompileError(
+            `${label} count must be a non-optional int; got ${this.describe(count.type)}.`,
+            countAst.pos
+          );
+        }
+        if (!isPrimitive(count.type, "int")) {
+          throw new CompileError(
+            `${label} count must be an int; got ${this.describe(count.type)}.`,
+            countAst.pos
+          );
+        }
+        const entryType = commonNeoScriptAssignableType(
+          expectedEntry ?? value.type,
+          value.type,
+          this.project
+        );
+        if (entryType === null) {
+          throw new CompileError(
+            `${label} value ${this.describe(value.type)} is not a ${this.describe(expectedEntry ?? value.type)} entry.`,
+            valueAst.pos
+          );
+        }
+        const type = {
+          kind: "list",
+          elementType: entryType
+        };
+        const wire = toWireType(type, this.project);
+        if (wire.type !== 6 /* List */) {
+          throw new Error(
+            "NeoScript strict compiler produced a non-list wire type for List.Repeat."
+          );
+        }
+        return intrinsic(
+          "listRepeat" /* ListRepeat */,
+          {
+            valuePointer: value.pointer,
+            countPointer: count.pointer,
+            entryTypeInfo: wire.entryTypeInfo
+          },
+          type
+        );
+      }
+      resolveCall(callee, argumentsList2, scope, pos, expected) {
         const variantCall = this.resolveVariantCall(
           callee,
           argumentsList2,
@@ -12953,6 +13125,21 @@ var init_strict_resolver = __esm({
             }
             return this.resolveMathCall(callee.name, argumentsList2, scope, pos);
           }
+          if (callee.receiver.name === NEOSCRIPT_LIST_TYPE_NAME) {
+            if (callee.optional) {
+              throw new CompileError(
+                `Optional chaining is not valid on type '${NEOSCRIPT_LIST_TYPE_NAME}'.`,
+                pos
+              );
+            }
+            return this.resolveListStaticCall(
+              callee.name,
+              argumentsList2,
+              scope,
+              expected,
+              pos
+            );
+          }
           const staticType = this.project.typeByName.get(callee.receiver.name);
           if (staticType && staticType.kind !== "enum") {
             if (callee.optional) {
@@ -42486,6 +42673,19 @@ function isNSFunctionMathOp(value) {
   const decimal2 = info.decimal;
   return decimal2 === void 0 || decimal2 === true;
 }
+function isNSFunctionListRepeat(value) {
+  const v = value;
+  if (v?.type !== "listRepeat" /* listRepeat */) return false;
+  const info = v.info;
+  if (typeof info !== "object" || info === null) return false;
+  if (!isNSPointer(info.valuePointer)) {
+    return false;
+  }
+  if (!isNSPointer(info.countPointer)) {
+    return false;
+  }
+  return isNSTypeInfo(info.entryTypeInfo);
+}
 function isNSFunctionCount(value) {
   const v = value;
   if (v?.type !== "count" /* count */) return false;
@@ -42533,7 +42733,7 @@ function isNSFunction(value) {
   return isNSFunctionClassConstructor(value) || isNSFunctionClassClone(value) || isNSFunctionListIndex(value) || isNSFunctionSelect(value) || isNSFunctionFirst(value) || isNSFunctionFirstOrDefault(value) || isNSFunctionWhere(value) || isNSFunctionContains(value) || // stringOp was missing from this chain since its introduction — a
   // compiled getter using ToLower()/StartsWith() would fail pointer
   // validation anywhere isNSFunction gates. Fixed alongside decimalOp.
-  isNSFunctionStringOp(value) || isNSFunctionDecimalOp(value) || isNSFunctionMathOp(value) || isNSFunctionCount(value) || isNSFunctionVisitCount(value) || isNSFunctionHasVisited(value) || isNSFunctionVectorConstructor(value) || isNSFunctionImageSlice(value) || isNSFunctionVariantInitialize(value) || isNSFunctionVariantApply(value) || isNSFunctionDeclaredConstructor(value);
+  isNSFunctionStringOp(value) || isNSFunctionDecimalOp(value) || isNSFunctionMathOp(value) || isNSFunctionListRepeat(value) || isNSFunctionCount(value) || isNSFunctionVisitCount(value) || isNSFunctionHasVisited(value) || isNSFunctionVectorConstructor(value) || isNSFunctionImageSlice(value) || isNSFunctionVariantInitialize(value) || isNSFunctionVariantApply(value) || isNSFunctionDeclaredConstructor(value);
 }
 function isNSInstructionVariable(value) {
   const v = value;
@@ -69347,6 +69547,25 @@ function evalDecimalMathOp(info, fn, scope, ctx) {
     rethrowDecimalError(error);
   }
 }
+function evalListRepeat(info, scope, ctx) {
+  const value = evalPointer(info.valuePointer, scope, ctx);
+  const count = numberArg(
+    evalPointer(info.countPointer, scope, ctx),
+    "List.Repeat count"
+  );
+  if (count < 0) {
+    throw new NSGetterRuntimeError(
+      `List.Repeat count must be non-negative; got ${count}.`
+    );
+  }
+  consumeBudget(
+    ctx,
+    "producedCollectionEntries",
+    count,
+    "produced collection entry"
+  );
+  return new Array(count).fill(value);
+}
 function stringifyForInterp(v) {
   if (v === null || v === void 0) return "";
   if (typeof v === "string") return v;
@@ -69868,6 +70087,8 @@ function evalFunction(fn, scope, ctx) {
     }
     case "mathOp" /* mathOp */:
       return evalMathOp(fn.info, scope, ctx);
+    case "listRepeat" /* listRepeat */:
+      return evalListRepeat(fn.info, scope, ctx);
     case "stringOp" /* stringOp */: {
       const receiver = evalPointer(fn.info.receiverPointer, scope, ctx);
       if (typeof receiver !== "string") {
@@ -112944,7 +113165,7 @@ var init_registry2 = __esm({
     PROJECT_SCHEMA_CONTRACT = Object.freeze({
       formatVersion: 3,
       contractVersion: "3.13",
-      cliVersion: "0.33.2",
+      cliVersion: "0.34.0",
       projectFileUploadBatchSize: 32,
       documentRecords: {
         member: {
@@ -119543,7 +119764,7 @@ There is no --keep-current: preserving current semantic state defines flatten.
 async function main() {
   const args = parseArgs(process.argv.slice(2));
   if (args.command === "--version") {
-    console.log("0.33.2");
+    console.log("0.34.0");
     return;
   }
   if (args.command === null || args.command === "help" || args.command === "--help" || args.command === "-h") {

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "@neocompose/cli",
-  "version": "0.33.2",
+  "version": "0.34.0",
   "description": "Neo Compose native project-source CLI with bidirectional sync.",
   "license": "MIT",
   "type": "module",

package/skills/neocompose-cli/SKILL.md

@@ -9,7 +9,7 @@ description: >-
   `@neocompose/cli` or `node cli/bin/neo.mjs` in the neo-compose repository.
 ---
 
-<!-- reviewed-through-cli: 0.33.2 -->
+<!-- reviewed-through-cli: 0.34.0 -->
 
 # Neo Compose CLI
 
@@ -138,8 +138,8 @@ completely before editing:
   variant folders, partial animation overrides, segments, tracks, and NeoFlow
   dialogues.
 - [NeoScript](references/neoscript.md): inline bodies, snippets, nullability,
-  numeric builtins, loops, switch, try/catch, ownership, evaluation, and
-  migrations.
+  numeric and list builtins, loops, switch, try/catch, ownership, evaluation,
+  and migrations.
 - [Commands and synchronization](references/commands-and-sync.md): pull/push,
   conflicts, low-level repair, branches, releases, and history.
 - [CLI development](references/cli-development.md): implementation source of

package/skills/neocompose-cli/references/cli-development.md

@@ -83,7 +83,7 @@ wrappers.
 The marker near the top of `SKILL.md` must exactly match the package version:
 
 ```html
-<!-- reviewed-through-cli: 0.33.2 -->
+<!-- reviewed-through-cli: 0.34.0 -->
 ```
 
 The quoted version above is checked too, so this instruction cannot go stale

package/skills/neocompose-cli/references/neoscript.md

@@ -8,6 +8,7 @@ runtime ownership, evaluation, and migrations.
 - Inline bodies and snippets
 - Nullability and ownership
 - Numeric builtins
+- List builtins
 - Conditional and logical operators
 - Loops and transfer
 - Switch
@@ -127,6 +128,31 @@ enum, parameter, or local may shadow it. Qualified members use their owner's
 namespace and may be named `Math`; access one as `this.Math` or
 `SomeValue.Math` without colliding with the builtin qualifier.
 
+## List builtins
+
+Use `List.Repeat(value, count)` to build a list of `count` copies of a value
+instead of hand-counting a literal or looping around `Add`:
+
+```neo
+List<int> scores = List.Repeat(0, 10);
+```
+
+The entry type is inferred from the value and joined with the assignment
+context, exactly like a list literal, so assigning `List.Repeat(0, 4)` to a
+`List<float>` widens the entries to `float`. Never spell type arguments on the
+qualifier: `List<int>.Repeat(0, 3)` is an error, and bare `List` is a
+qualifier, not a value.
+
+`count` must be an `int` — a `float` count is a compile error, and a negative
+count fails at runtime with `List.Repeat count must be non-negative; got
+{count}.`. A count of `0` produces an empty `List<T>` whose entry type is
+still known. The value is evaluated exactly once, then the count exactly once,
+so side effects happen once regardless of `count`, and every entry is that one
+value: for a reference-typed entry the same reference repeats `count` times.
+Materializing the list charges `count` to the shared collection-entries
+execution budget, so a runaway count fails with the existing budget error
+before allocating.
+
 ## Conditional and logical operators
 
 Use `condition ? whenTrue : whenFalse` for a value chosen by a condition: