イベントループと TypeScript の型から理解する非同期処理

let handlers = new Set();

function wait(ms: number) {
  // ...与えられた ms 待機する
}

// 簡略化のために timeoutId は略
function setTimeout(fn, ms) {
  const now = Date.now();
  const handler = () => {
    if (now - timer >= ms) {
      fn();
      handlers.delete(handler);
    }
  }
  handlers.add(handler);
}

function mainloop(){
  while(true) {
    wait(16);
    handlers.forEach(fn => fn());
  }
}

mainloop();

  // ...与えられた ms 待機する
function wait(ms: number) {
  const start = Date.now();
  while (true) {
    if (Date.now() - start >= ms) {
      return;
    }
  }
}

const p = new Promise<number>((resolve, reject) => {
  setTimeout(() => {
    const n = Math.random()
    if (n > 0.5) {
      resolve(n);
    } else {
      reject();
    }
  }, 1000);
});

p.then((n) => {
  console.log('over 0.5', n);
});

p.catch((err) => {
  console.log(err)
});

interface PromiseConstructor {
    /**
     * A reference to the prototype.
     */
    readonly prototype: Promise<any>;

    /**
     * Creates a new Promise.
     * @param executor A callback used to initialize the promise. This callback is passed two arguments:
     * a resolve callback used to resolve the promise with a value or the result of another promise,
     * and a reject callback used to reject the promise with a provided reason or error.
     */
    new <T>(executor: (resolve: (value: T | PromiseLike<T>) => void, reject: (reason?: any) => void) => void): Promise<T>;

    /**
     * Creates a Promise that is resolved with an array of results when all of the provided Promises
     * resolve, or rejected when any Promise is rejected.
     * @param values An array of Promises.
     * @returns A new Promise.
     */
    all<T extends readonly unknown[] | []>(values: T): Promise<{ -readonly [P in keyof T]: Awaited<T[P]> }>;

    // see: lib.es2015.iterable.d.ts
    // all<T>(values: Iterable<T | PromiseLike<T>>): Promise<T[]>;

    /**
     * Creates a Promise that is resolved or rejected when any of the provided Promises are resolved
     * or rejected.
     * @param values An array of Promises.
     * @returns A new Promise.
     */
    race<T extends readonly unknown[] | []>(values: T): Promise<Awaited<T[number]>>;

    // see: lib.es2015.iterable.d.ts
    // race<T>(values: Iterable<T>): Promise<T extends PromiseLike<infer U> ? U : T>;

    /**
     * Creates a new rejected promise for the provided reason.
     * @param reason The reason the promise was rejected.
     * @returns A new rejected Promise.
     */
    reject<T = never>(reason?: any): Promise<T>;

    /**
     * Creates a new resolved promise.
     * @returns A resolved promise.
     */
    resolve(): Promise<void>;

    /**
     * Creates a new resolved promise for the provided value.
     * @param value A promise.
     * @returns A promise whose internal state matches the provided promise.
     */
    resolve<T>(value: T | PromiseLike<T>): Promise<T>;
}

new <T>(executor: (resolve: (value: T | PromiseLike<T>) => void, reject: (reason?: any) => void) => void): Promise<T>;

/**
 * Represents the completion of an asynchronous operation
 */
interface Promise<T> {
    /**
     * Attaches callbacks for the resolution and/or rejection of the Promise.
     * @param onfulfilled The callback to execute when the Promise is resolved.
     * @param onrejected The callback to execute when the Promise is rejected.
     * @returns A Promise for the completion of which ever callback is executed.
     */
    then<TResult1 = T, TResult2 = never>(onfulfilled?: ((value: T) => TResult1 | PromiseLike<TResult1>) | undefined | null, onrejected?: ((reason: any) => TResult2 | PromiseLike<TResult2>) | undefined | null): Promise<TResult1 | TResult2>;

    /**
     * Attaches a callback for only the rejection of the Promise.
     * @param onrejected The callback to execute when the Promise is rejected.
     * @returns A Promise for the completion of the callback.
     */
    catch<TResult = never>(onrejected?: ((reason: any) => TResult | PromiseLike<TResult>) | undefined | null): Promise<T | TResult>;
}

const p = new Promise<number>((resolve, reject) => {
  (null as any).foo = 1;
  return resolve(Math.random());
});
p.catch((err) => {
  console.error('catched', err);
});

$ npx ts-node -T promise.ts
catched TypeError: Cannot set properties of null (setting 'foo')
    at promise.ts:21:20
    at new Promise (<anonymous>)
    at Object.<anonymous> (promise.ts:20:11)
    at Module._compile (node:internal/modules/cjs/loader:1101:14)
    at Module.m._compile (...node_modules/ts-node/src/index.ts:1043:23)
    at Module._extensions..js (node:internal/modules/cjs/loader:1153:10)
    at Object.require.extensions.<computed> [as .ts] (...node_modules/ts-node/src/index.ts:1046:12)
    at Module.load (node:internal/modules/cjs/loader:981:32)
    at Function.Module._load (node:internal/modules/cjs/loader:822:12)
    at Function.executeUserEntryPoint [as runMain] (node:internal/modules/run_main:81:12)

const p = new Promise<number>((resolve, reject) => {
  (null as any).foo = 1;
  return resolve(Math.random());
});
p.catch((err) => {
  if (err instanceof TypeError) {
    console.error('TypeError', err);
  } else {
    // 例外に関するミームでとりあえず全部みたいな意味
    console.error('Pokemon Catching', err);
  }
});

Promise.resolve(1)
  .then((n) => n + 1)
  .then((n) => n + 1)
  .then((n) => n + 1)
  .then(console.log)

    then<TResult1 = T, TResult2 = never>(
      onfulfilled?: ((value: T) => TResult1 | PromiseLike<TResult1>) | undefined | null, onrejected?: ((reason: any) => TResult2 | PromiseLike<TResult2>) | undefined | null
    ): Promise<TResult1 | TResult2>;

Promise.resolve<number>(3)
  .then<string>((n) => `x`.repeat(n)) // xxx
  .then<number>((str) => str.length) // xxx.length
  .then<void>(console.log) // console.log の返り値は void

Promise.resolve<number>(3)
  .then<string>((n) => `x`.repeat(n))
  .then<void>(console.log)
  // @ts-expect-error
  .then<number>((str) => str.length)
  .catch(console.error);

xxx
TypeError: Cannot read properties of undefined (reading 'length')
    at promise.ts:28:30

Promise.reject(new Error('foo'))
  .then<string>((n) => `x`.repeat(n))
  .then<void>(console.log)
  // @ts-expect-error
  .then<number>((str) => str.length)
  .catch(console.error);

Error: foo
    at Object.<anonymous> (...promise.ts:25:16)
    at Module._compile (node:internal/modules/cjs/loader:1101:14)
    at Module.m._compile (...node_modules/ts-node/src/index.ts:1043:23)
    at Module._extensions..js (node:internal/modules/cjs/loader:1153:10)
    at Object.require.extensions.<computed> [as .ts] (...node_modules/ts-node/src/index.ts:1046:12)
    at Module.load (node:internal/modules/cjs/loader:981:32)
    at Function.Module._load (node:internal/modules/cjs/loader:822:12)
    at Function.executeUserEntryPoint [as runMain] (node:internal/modules/run_main:81:12)
    at main (...node_modules/ts-node/src/bin.ts:225:14)
    at Object.<anonymous> (...node_modules/ts-node/src/bin.ts:512:3)

Promise.resolve<number>(3)
  .then(() => Promise.reject(new Error('fail')))
  .then(() => 1)
  .catch(console.error);

Promise.resolve<number>(3)
  .then<string>((n) => `x`.repeat(n)) // xxx
  .then<number>((str) => str.length) // xxx.length
  .then<void>(console.log) // console.log の返り値は void

const n = await Promise.resolve(3);
const text = await `x`.repeat(n);
const len = await text.length;
console.log(len);

const n = await Promise.resolve(3);
const text = `x`.repeat(n);
const len = text.length;
console.log(len);

(async () => {
  const n = await Promise.resolve(3);
  const text = `x`.repeat(n);
  const len = text.length;
  console.log(len);
})();

(async () => {
  const response = await fetch('https://api.github.com/zen');
  const text = await resposne.text();
  consle.log(text);
})();

let n = 0;
setInterval(() => {
  n++;
}, 16);

(async () => {
  console.log(n);
  const response = await fetch('https://api.github.com/zen');
  console.log(n);
  const text = await resposne.text();
  console.log(n);
  consle.log(text);
})();

function foo(): number {
  return 1;
}

async function foo(): Promise<number> {
  return 1;
}

const p: Promise<number> = foo();
p.then(console.log) // ここでやっと 1 が手に入る

function foo(): Promise<number> {
  return Promise.resolve(1);
}

async function bar(): Promise<number> {
  // ...実体は不明だが数値を返すとする
}

async function foo(): Promise<number> {
  const bar = await bar();
  return bar + 1;
}

function foo(): Promise<number> {
  return Promise.resolve()
    .then(() => bar())
    .then(n => n + 1);
}

const f = async () => {
  // ...
};
const p: Promise<void> = f();

const f = async () => {
  return 1;
};

const main = async () => {
  const p = f(); // await しないで promise をとる
  // p の型が解決された型、をここで取り出す
  const x: Awaited<typeof p> = await p;
  // @ts-expect-error
  const n: string = x;
};
main();

  all<T extends readonly unknown[] | []>(
    values: T
  ): Promise<{ -readonly [P in keyof T]: Awaited<T[P]> }>;

const results = await Promise.all([
  await p1(),
  await p2()
]);

const results = await Promise.all([
  p1(),
  p2()
]);

const p = (async () => {
  // ...
})();
p.catch(console.error);

async function main() {
  try {
    await Promise.reject(new Error('err'));
    console.log('unreachable!')
  } catch (err) {
    console.warn(err instanceof Error);
  }
}

main();

async function main() {
  try {
    throw new Error('err');
    console.log('unreachable!')
  } catch (err) {
    console.warn(err instanceof Error);
  }
}

main();

async function main() {
  try {
    await Promise.reject(new Error('err'));
    console.log('unreachable!')
  } catch (err) {
    console.warn(err instanceof Error);
  } finally {
    console.log("always")
  }
}
main();

let x = do {
  let tmp = f();
  tmp * tmp + 1
};