HKT在fp-ts中是如何运作的？

问：

查看下面的代码。我还将其添加到打字稿游乐场的此链接中。我把部分 fp-ts 收集在一个地方，以测试和了解 HKT 的工作原理并在那里进行模拟。

type Identity<A> = { _tag: 'Identity', a: A }

// --------------------

type Option<A> = Some<A> | None

interface Some<A> {
  _tag: 'Some'
  value: A
}

interface None {
  _tag: 'None'
}

const some = <A,>(x: A): Option<A> => 
  ({ _tag: 'Some', value: x })

const none: Option<never> = 
  { _tag: 'None' }

const isNone = <A,>(x: Option<A>): x is None => 
  x._tag === 'None'

// --------------------

type Either<E, A> = Left<E> | Right<A>

interface Left<E> {
  _tag: 'Left'
  left: E
}

interface Right<A> {
  _tag: 'Right'
  right: A
}

const left = <E,A=never>(x: E):  Either<E, A> => ({ _tag: 'Left', left: x})
const right = <A,E=never>(x: A):  Either<E, A> => ({ _tag: 'Right', right: x})

const isLeft = <E, A>(a: Either<E, A>): a is Left<E> => 
  a._tag === 'Left'


// --------------------

interface URItoKind1<A> {
    'Identity': Identity<A>
    'Option': Option<A>
}

interface URItoKind2<E,A> {
    'Either': Either<E,A>
}

type URIS1 = keyof URItoKind1<any>
type URIS2 = keyof URItoKind2<any, any>

type Kind1<URI extends URIS1, A> = URItoKind1<A>[URI]
type Kind2<URI extends URIS2, E, A> = URItoKind2<E,A>[URI]

// type HKT1<URI, A> = { URI: URI; a: A };              // FROM FP-TS
type HKT1<URI, A> = { What: string }                    // HERE IS CONFUSING TO ME. THIS COMPILES
// type HKT2<URI, A, B> = { URI: URI; a: A; b: B };     // FROM FP-TS
type HKT2<URI, A, B> = { Hello: number }                // HERE IS CONFUSING TO ME. THIS COMPILES

interface Functor1<F extends URIS1> {
    map: <A, B>(fa: Kind1<F, A>, f: (a: A) => B) => Kind1<F, B>
}

interface Functor2<F extends URIS2> {
    map: <E, A, B>(fa: Kind2<F, E, A>, f: (a: A) => B) => Kind2<F, E, B>
}

interface Functor<F> {
    map: <A, B>(fa: HKT1<F, A>, f: (a: A) => B) => HKT1<F, B>
}

// --------------------------

const optionFunctor: Functor1<'Option'> = {
  map: <A,B>(fa: Option<A>, f: (x: A) => B): Option<B> => 
    isNone(fa) ? none : some(f(fa.value))
}

const eitherFunctor: Functor2<'Either'> = {
  map: <E,A,B>(fa: Either<E, A>, f: (x: A) => B): Either<E, B> => 
    isLeft(fa) ? fa : right(f(fa.right))
}

// ---------------------------

function lift<F extends URIS2>(F: Functor2<F>): <A, B>(f: (a: A) => B) => <E>(fa: Kind2<F, E, A>) => Kind2<F, E, B>
function lift<F extends URIS1>(F: Functor1<F>): <A, B>(f: (a: A) => B) => (fa: Kind1<F, A>) => Kind1<F, B>
function lift<F>(F: Functor<F>): <A, B>(f: (a: A) => B) => (fa: HKT1<F, A>) => HKT1<F, B>       // IF YOU COMMENT THIS TYPESCRIPT WILL NOT BE HAPPY, BUT WHY IT WORKS IN THE FIRST PLACE!
{
  return (f) => (fa) => F.map(fa, f)
}

const liftOption = lift(optionFunctor)
const liftEither = lift(eitherFunctor)

const increment = (x: number) => x+1

console.log(liftOption(increment)(some(12)))
console.log(liftEither(increment)(right(12)))

这编译正常，运行正常。

我把 和 改成完全无稽之谈的东西HKT1HKT2

type HKT1<URI, A> = { URI: URI; a: A };
type HKT2<URI, A, B> = { URI: URI; a: A; b: B };

自

type HKT1<URI, A> = { What: string }
type HKT2<URI, A, B> = { Hello: number }

但是代码编译正常。为什么？

更奇怪的是，如果我们评论这句话......

function lift<F>(F: Functor<F>): <A, B>(f: (a: A) => B) => (fa: HKT1<F, A>) => HKT1<F, B>

...这是重载和默认情况。代码停止编译！

香港电讯在这里如何运作？这些类型如何在 Functor 下将 Functor1 和 Functor2 粘合在一起？HKT1