TypeScript `is` 类型谓词（用户定义的类型保护函数）来实现幂等对象类型

Question

I am confused to take advantage of type predicates (user-defined type guard functions)

As addressed in my earlier questions: How to fix the broken code with idempotent (self flatten) types in TypeScript? , my final goal is to implement a mappable object that has the map method( mp in the sample code to avoid confusion) that should work similarly as pipeline-operator (such as F# |> ).

Since any objects and primitives in JavaScript are idempotent(self/auto flatten), Object(5) === Object(Object(5)) ; I try to implement idempotent object/ functor as P and mp at first.

I asked How to express idempotent (self flatten) types in TypeScript? ; : TTX = TX ; however, the approach in the answer, unfortunately failed:

the approach eventually failed

type p<A> = {
  map: <B>(R: (a: A) => B) => P<B>
};

type P<A> =  //-------------idempotence
  A extends p<unknown>
  ? A
  : p<A>;

I gave up this approach and now, and refactored my code to bind JS and TypeScript inference closely, and try to take advantage of is type predicates (user-defined type guard functions)

(Please note: This is the simplest code to fucus on the issue; the actual implementation should use Symbol for property to check self-type is instead of using mp property, also None needed )

Alse see: TS playground

Works fine inside of the implementation, but does not work in the test code

type P<A> = { mp: <B>(R: (a: A) => B) => P<B> };

const isP = <A,>(X: A | P<A>): X is A =>
  "mp" in X;
//is type predicates (user-defined type guard functions)

const P = <A,>(x: A) =>
  ((X: A | P<A>) =>
    isP(X)
      ? X // X: A //works fine as expected by isP
      : Object.defineProperty(X, //X: P<A> //works fine as expected
        "mp", { value: <B,>(f: (a: A) => B) => P(f(x)) })
  )(Object(x)); //idempotent

//--------------------------------
const f = (a: number) => a + 1;
//--------------------------------
const x = P(5); // 5 | P<5>  
                // P<5> expected or P<number> is ok
const xx = P(P(5)); // 5 | P<5> | P<5 | P<5>>
                    // P<5> expected  or P<number> is ok
const a = P(5).mp(f); //any
/* Property 'mp' does not exist on type '5 | P<5>'.
Property 'mp' does not exist on type '5'.ts(2339) */

---

---

---

---

No error version by disabling is

type P<A> = { mp: <B>(R: (a: A) => B) => P<B> };

const isP = <A,>(X: A | P<A>): X is A =>
  "mp" in X;

const P = <A,>(x: A) =>
  ((X: A | P<A>) =>
    isP(X)
      ? X as unknown as P<A> 
        //disabling isP by overriding as P<A> 
      : Object.defineProperty(X,
        "mp", { value: <B,>(f: (a: A) => B) => P(f(x)) })
  )(Object(x));

//--------------------------------
const f = (a: number) => a + 1;
//--------------------------------
const x = P(5); // P<number>
const xx = P(P(5)); // P<P<number>> 
// want this as P<number> as idempotence
const a = P(5).mp(f);// P<number>

Any ideas? I've been working on this more than a week. Thanks!

Answer 1

Ok, at least for this issue, I figured out...

The type inference of this kind is only available in the context of the definition, and for the outside of the context to react the input type, we need to write the conditional type:

  type P<A> = {
    mp: <B>(R: (a: A) => B) => P<B>
  };

  const P = <A>(x: A) =>
    ((X: object) =>
      ("mp" in X
        ? X
        : Object.defineProperty(X,
          "mp", { value: <B>(f: (a: A) => B) => P(f(x)) })
      ) as (A extends { mp: unknown } ? A : P<A>)
    )(Object(x));

  //--------------------------------
  const f = (a: number) => a + 1;
  //--------------------------------
  const x = P(5); // P<number>
  const xx = P(P(5)); // P<number>
  const a = P(5).mp(f);// P<number>

  //this still has problem with type-error
  const compose =
  <A, B, C>(g: (b: B) => C) =>
    (f: (a: A) => B) =>
      (a: A) =>// g(f(a))
        P(a).mp(f).mp(g);