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:13:7 - error SC2001: 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 module-scope bindings initialized with a generic arrow/function expression)

  12 | const id = <T>(x: T): T => x;
  13 | const stored = id;
     |       ^~~~~~
  14 | console.log(stored(2));

  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:13:16 - 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

  12 | const id = <T>(x: T): T => x;
  13 | const stored = id;
     |                ^~
  14 | console.log(stored(2));

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

  13 | const stored = id;
  14 | console.log(stored(2));
     |             ^~~~~~
  15 | 

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

generic-value-bindings.ts:19:17 - error SC1090: generic arrow/function-expression bindings declared inside functions (the compiled instantiations of 'inner' are module functions and cannot capture the enclosing frame — declare the binding at module scope) are not supported yet

  18 | function outer(): number {
  19 |   const inner = <T>(x: T): T => x;
     |                 ^~~~~~~~~~~~~~~~~
  20 |   return inner(3);

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

  19 |   const inner = <T>(x: T): T => x;
  20 |   return inner(3);
     |          ^~~~~
  21 | }

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

generic-value-bindings.ts:26:13 - error SC1030: the generic-signature binding 'ambient' (its type keeps type parameters and the declaration has no initializer — no function body exists to monomorphize, so nothing can pin a concrete signature) is not supported yet

  25 | declare const ambient: undefined | (<T>(f: (a: T) => T) => T);
  26 | console.log(ambient?.((n: number) => n) === undefined);
     |             ^~~~~~~
  27 | 

generic-value-bindings.ts:31: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

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

generic-value-bindings.ts:43: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

  42 | function throughParam(a: Amb): void {
  43 |   console.log(a.m(4));
     |               ^~~~~~
  44 | }

generic-value-bindings.ts:48:14 - error SC1090: generic arrow/function expressions outside a never-reassigned module-scope binding (only `const f = <T>(x: T) => ...` bindings and top-level generic function declarations monomorphize) is not supported yet

  47 | // A generic lambda outside any monomorphizable home (an IIFE).
  48 | console.log((<T>(x: T): T => x)(5));
     |              ^~~~~~~~~~~~~~~~~
  49 | 