Assigning to a unwrapped type doesn't work on Generics but works with Interface

[pikax]

TypeScript Version: 3.7.0-dev.20191009

Search Terms:

Code

// Types
export interface Ref<T = any> {
  value: UnwrapRef<T>
}
export function ref<T>(raw: T): Ref<T>{
    return null as any;
}

type BailTypes =
  | Function
  | Map<any, any>
  | Set<any>
  | WeakMap<any, any>
  | WeakSet<any>
  
export type UnwrapRef<T> = {
  ref: T extends Ref<infer V> ? UnwrapRef<V> : T
  array: T extends Array<infer V> ? Array<UnwrapRef<V>> : T
  object: { [K in keyof T]: UnwrapRef<T[K]> }
  stop: T
}[T extends Ref
  ? 'ref'
  : T extends Array<any>
    ? 'array'
    : T extends BailTypes
      ? 'stop' // bail out on types that shouldn't be unwrapped
      : T extends object ? 'object' : 'stop']

// /types

type Supa = {
    xx: number,
    x1: number
}
function setup(d: Supa, fn: () => Supa) {
  const r = ref(d);
  // assigning the value
  r.value = fn(); // works as expected
}

function setup2<T>(d: T, fn: () => T) {
  const r = ref(d)
  r.value = fn(); // ERROR
}

with simpler recursion

export interface Ref<T = any> {
  value: UnwrapRef<T>
}
export type UnwrapRef<T> = T extends Ref<infer V>
  ? UnwrapRefProp<V>
  : UnwrapRefProp<T>
export type UnwrapRefProp<T> = { [K in keyof T]: UnwrapRefPropValue<T[K]> }

type BailTypes =
  | Function
  | Map<any, any>
  | Set<any>
  | WeakMap<any, any>
  | WeakSet<any>

// NOTE not fully tested
export type UnwrapRefPropValue<T> = T extends BailTypes
  ? T
  : T extends Array<infer V>
    ? UnwrapRef<V>[]
    : T extends Ref<infer VR> ? UnwrapRef<VR> : UnwrapRef<T> // we might need to return T at some point

export function ref<T>(raw: T): Ref<T>{
    return null as any;
}


type Supa = {
    xx: number,
    x1: number
}
function setup(d: Supa, fn: () => Supa) {
    const r = ref(d);
    r.value = fn(); // works as expected
}

function setup2<T>(d: T, fn: () => T) {
    const r = ref(d)
    r.value = fn(); // error `Type 'T' is not assignable to type 'UnwrapRef<T>'`
}

Expected behavior:
Both should be assignable to value, the generic should be able to infer the type.

Actual behavior:
When using inside of generics it doesn't work, on the first example show an huge error log, the second one is error "Type 'T' is not assignable to type 'UnwrapRef<T>'"

Playground Link:
example1
example2

The first example the code comes from vue-next

[RyanCavanaugh]

I'm reading the definition of UnwrapRef<T> and can't convince myself that an arbitrary T should be assignable to it. Things that are true at zero-order might not be true at higher-order and TypeScript doesn't have the necessary higher-order logic to prove that all Ts going in to UnwrapRef eventually produce something assignable from another T.

[kaigregliu]

You may wanna try

function setup2<T>(d: T, fn: () => UnwrapRef<T>) { // ++
  const r = ref(d)
  r.value = fn(); 

and inside your fn function

function fn(){
  ...
  // return data              // --
  return reactive(data) // ++
}