Real-world hotscript use cases?

[gvergnaud]

Hey everyone!

Here is a thread to collect real-world use cases for hotscript :)

As we stabilize the API, we are very curious about the problems you are solving with this library, and if/how it simplifies your type-level logic.

Even if you are not using hotscript yet, what is the most complex type you have ever written?

[markerikson]

"Most complex types":

• The MergeParameters type in Reselect 4.1.5: https://github.com/reduxjs/reselect/blob/v4.1.5/src/types.ts#L100-L148 (which later broke in TS 4.9, and Anders Hjelsberg himself provided a simpler implementation that only works with TS4.7+: https://github.com/reduxjs/reselect/blob/v4.1.7/src/versionedTypes/ts47-mergeParameters.ts )
• The connect types in React-Redux v8 (which admittedly were ported from the v7 @types/react-redux package): https://github.com/reduxjs/react-redux/blob/v8.0.2/src/components/connect.tsx#L251-L407
• And then while I didn't write them, basically everything in Redux Toolkit :) createAction.ts, createSlice.ts, apiTypes.ts, endpointDefinitions.ts, etc

[gvergnaud]

Thanks for sharing @markerikson! Do you have some type-level unit tests for this MergeParameters function? I'd like to try reimplementing it with hotscript, but it would be much easier with a few test cases to make sure edge cases are covered

[gvergnaud]

Thanks!

I didn't test this against your suite of unit tests, but I gave this a quick try and here is what I came up with:

import * as H from "hotscript";

type res = MergeParameters<
  // ^? [21, 2, symbol, { a: number } & { b: string }]
  [
    (a: number, b: number) => boolean,
    (a: 21, b: number) => string,
    (a: number | string, b: 2, c: symbol, d: { a: number }) => string,
    (a: number | string, b: 2, c: symbol, d: { b: string }) => string
  ]
>;

type MergeParameters<T extends readonly UnknownFunction[]> = H.Pipe<
  T,
  [
    H.Tuples.Map<H.Functions.Parameters>,
    PadWithUnknown,
    Transpose,
    H.Tuples.Map<H.Tuples.ToIntersection>
  ]
>;

/** 
 * `Call<Transpose, [[1, 2], ['a', 'b']]>` // [[1, 'a'], [2, 'b']]
 */
interface Transpose extends H.Fn {
  return: H.Apply<H.Tuples.Zip, this['arg0']>
}


/**
 * Make sure all lists of arguments have the same length by 
 * adding unknown arguments at the end of the shorter ones.
 * @example
 * ```ts
 * type T = Call<PadWithUnknown, [[], [1], [1, 2]]>>
 * // [[unknown, unknown], [1, unknown], [1, 2]]
 * ```
 */
interface PadWithUnknown extends H.Fn {
  return: this["args"] extends [infer argsList extends any[][]]
    ? H.Pipe<argsList, [
        GetMaxLength,
        GetUnknownPadding<argsList>,
        H.Tuples.ZipWith<H.Tuples.Concat, argsList, H._>
      ]>
    : never
}


type GetMaxLength = H.ComposeLeft<[
  H.Tuples.Map<H.Tuples.Length>,
  H.Tuples.Reduce<H.Numbers.Max, 0>
]>

/**
 * Returns a list of `unknown` to pad the argsList
 * to make them all have the same length.
 * @example
 * ```ts
 * type T = Call<GetUnknownPadding<[[], [1], [1, 2]]>, 2>
 * // [[unknown, unknown], [unknown], []]
 * ```
 */
interface GetUnknownPadding<argsList extends any[][]> extends H.Fn {
  return: H.Eval<
    H.Tuples.Map<
      H.ComposeLeft<
        [
          H.Tuples.Length,
          H.Numbers.Sub<this['arg0'], H._>,
          H.Tuples.Range<0>,
          H.Tuples.Map<H.Constant<unknown>>,
          H.Tuples.Tail
        ]
      >,
      argsList
    >
  >
}

/** Any function with arguments */
type UnknownFunction = (...args: any[]) => any;

Playground

Curious to know what you think!

[markerikson]

Looks plausible at first glance :) I'll have to look at it later.

Out of curiosity, what sort of TS version range support does hotscript have overall? How far back does any of this stuff work?

[gvergnaud]

We haven't thought too much about retro compatibility yet. It looks like the current version of the code is only compatible with TSv4.8 or above but I don't see why we couldn't make it compatible with 4.5+ (tail call optimization is a hard requirement)

[markerikson]

Gotcha. Yeah, as a point of comparison I'm currently trying to support TS 4.2+ in Reselect.

[markerikson]

@gvergnaud Had a follow-up question on this.

Right now one of the limitations in Reselect is that we apparently can't carry a generic type through our internal mapped types:

• createSelector can't handle generic state reduxjs/reselect#571

According to @phryneas , this is a TS limitation - https://stackoverflow.com/questions/74841157/preserving-generics-in-typescript-mapped-types is probably the same kind of thing.

Any chance Hotscript makes something like that feasible?

[audunolsen]

On the more trivial side, but…

APIs w/ either inconsistent or undesirable casing in their responses.

I usually put hotscript's pipe w/ a recursive camelise function in my zod schema's last transform call to enforce camelcase w/ correct typings.

[boyum]

The Infer* types in h5p-types

• https://github.com/boyum/h5p-types/blob/main/src/types/InferParamsFromSemantics.ts
• https://github.com/boyum/h5p-types/blob/main/src/types/InferParamTypeFromFieldType.ts
• https://github.com/boyum/h5p-types/blob/main/src/types/InferGroupParams.ts

I haven't had a real look, but I'm sure that these could be simplified by HotScript, especially since deep semantics easily breaks TS' max recursion. These tests are not too far away from the limit: https://github.com/boyum/h5p-types/blob/main/test/InferParamsFromSemantics.test.ts