generic-value-bindings.ts:6:5 - error SC1090: generic function values in reassigned bindings (calls of 'flip' resolve statically against this initializer, so the binding must provably hold it — a const, or a let/var nothing in its declaring file writes) are not supported yet

  5 | // a structurally identical function with a different body.
  6 | let flip = <T>(x: T): T => x;
    |     ^~~~
  7 | flip = <T>(x: T): T => x;

generic-value-bindings.ts:7:1 - error SC2004: uses of 'flip' inherit the blocker on its declaration

  6 | let flip = <T>(x: T): T => x;
  7 | flip = <T>(x: T): T => x;
    | ^~~~
  8 | console.log(flip(1));

  hint: the declaration of 'flip' did not compile — fix the diagnostic reported there and these sites clear with it

generic-value-bindings.ts:8:13 - error SC2004: uses of 'flip' inherit the blocker on its declaration

  7 | flip = <T>(x: T): T => x;
  8 | console.log(flip(1));
    |             ^~~~
  9 | 

  hint: the declaration of 'flip' did not compile — fix the diagnostic reported there and these sites clear with it

generic-value-bindings.ts:15:20 - error SC1090: generic functions as values without a pinned concrete signature (annotate the destination — e.g. 'const f: (x: number) => number = id' — instantiate explicitly ('id<number>'), or call 'id' directly) is not supported yet

  14 | const stored = id;
  15 | console.log(typeof stored);
     |                    ^~~~~~
  16 | 

generic-value-bindings.ts:19:7 - error SC2005: values of type '<T>(x: T) => T' cannot be compiled: the signature keeps its type parameters, and a compiled function is always one concrete signature (generic functions monomorphize per pinned signature — declarations, methods, and never-reassigned bindings holding a generic arrow/function expression, an alias of a registered generic function, or a function initializer under a generic-signature annotation)

  18 | // fence reports, and the alias falls back to the ordinary binding story.
  19 | const flipAlias = flip;
     |       ^~~~~~~~~
  20 | console.log(flipAlias(5));

  hint: annotate the destination with a concrete signature (e.g. '(x: number) => number'), instantiate explicitly ('f<number>'), or call the generic function directly

generic-value-bindings.ts:19:19 - error SC2004: uses of 'flip' inherit the blocker on its declaration

  18 | // fence reports, and the alias falls back to the ordinary binding story.
  19 | const flipAlias = flip;
     |                   ^~~~
  20 | console.log(flipAlias(5));

  hint: the declaration of 'flip' did not compile — fix the diagnostic reported there and these sites clear with it

generic-value-bindings.ts:20:13 - error SC2004: uses of 'flipAlias' inherit the blocker on its declaration

  19 | const flipAlias = flip;
  20 | console.log(flipAlias(5));
     |             ^~~~~~~~~
  21 | 

  hint: the declaration of 'flipAlias' did not compile — fix the diagnostic reported there and these sites clear with it

generic-value-bindings.ts:25:17 - error SC1090: generic arrow/function-expression bindings that use the frames of their enclosing functions (the compiled instantiations of 'inner' are module functions and cannot capture its locals, parameters, type parameters or 'this' — pass them as arguments, or declare the binding at module scope) are not supported yet

  24 | function outer(base: number): number {
  25 |   const inner = <T>(x: T): [T, number] => [x, base];
     |                 ^~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~
  26 |   return inner(3)[1];

generic-value-bindings.ts:26:10 - error SC2004: uses of 'inner' inherit the blocker on its declaration

  25 |   const inner = <T>(x: T): [T, number] => [x, base];
  26 |   return inner(3)[1];
     |          ^~~~~
  27 | }

  hint: the declaration of 'inner' did not compile — fix the diagnostic reported there and these sites clear with it

generic-value-bindings.ts:35:10 - error SC1090: generic arrow/function-expression bindings declared inside functions as values (each call of the enclosing function makes a new 'same' function object, while its compiled instances are shared module functions — call 'same' directly, or declare it at module scope) are not supported yet

  34 |   const same = <T>(x: T): T => x;
  35 |   return same<number>;
     |          ^~~~~~~~~~~~
  36 | }

generic-value-bindings.ts:48:13 - error SC1090: results that are themselves generic functions ('<U>(y: U) => string' keeps its type parameters — no call-site instantiation pins them, and the returned value would need the producing call's frame; restructure to one generic function taking all arguments) are not supported yet

  47 | const curried = <T>(x: T) => <U>(y: U): string => `${x}|${y}`;
  48 | console.log(curried(1)("a"));
     |             ^~~~~~~~~~
  49 | 

generic-value-bindings.ts:60:15 - error SC1090: calls of the generic method 'm' through this receiver (no compiled declaration with a body resolves statically here — ambient 'declare class' and interface-only methods are signature-only, and only class, static, and object-literal generic methods with bodies monomorphize) is not supported yet

  59 | function throughParam(a: Amb): void {
  60 |   console.log(a.m(4));
     |               ^~~~~~
  61 | }

generic-value-bindings.ts:71:32 - error SC1090: generic arrow/function-expression bindings declared inside functions that code can call before their declaration runs (the binding 'picked' is a 'var' in a branch or block, or is called from a place that can run first — declare it with const before its uses) are not supported yet

  70 |   }
  71 |   const invoke = (): number => picked(1);
     |                                ^~~~~~
  72 |   return invoke();