ValidPath without const assertion?

[asgerhallas]

🤔 Question

I'm new to this library, and am still trying to get my head around it. It's very impressive! :)

In this sample https://pirix-gh.github.io/ts-toolbelt/modules/_object_pathvalid_.html there's the following code:

const test0 = getAt(state,          ['case', 'name'] as const) // {c: number}

Why is const needed? And is there a way to make it work without the const assertion?

Hope you can help.

[millsp]

Hi there,

Without a const assertion, the type of ['case', 'name'] would be narrowed to string[] that's all. Depending on your type safety needs, you would choose as const or not.

[asgerhallas]

I somehow missed your answer, sorry! What I meant was that, I'd like the type safety to be enforced by the function signature, so the caller does not have to add as const, but still only be able to pass expected strings in the array. It's easy for a caller to forget as const and thus we will not catch errors now or when the allowed string values change in the future.

[millsp]

It's a TypeScript limitation, I know how inconvenient this is. To work around that, the only solution is to take rest parameters instead. Or you could have this Maybe this can help you:

• Support dotted path notation #154
• Suggestion: Const contexts for generic type inference microsoft/TypeScript#30680

[asgerhallas]

Thanks a lot for your swift reply :)

I'll look into those links right away!

[millsp]

I posted a solution to this problem here in microsoft/TypeScript#30680. It will land soon in ts-toolbelt.

[asgerhallas]

This is amazing, thank you for doing this! I look forward to it landing is ts-toolbelt too.

[millsp]

This has been shipped in the latest release https://millsp.github.io/ts-toolbelt/modules/function_narrow.html

[schtauffen]

Is it possible to have the completion work on the path AND have the Narrow function?

declare function getAt<
  T extends object,
  P extends L.List<A.Key>
>(lens: Narrow<P>, target: T): O.Path<T, P>;

getAt(["foo"], { foo: 3 }); // ✓ number
getAt(["bar"], { foo: 3 }); // ✓ never

declare function get<
  T extends object,
  P extends O.Paths<T>
>(lens: Narrow<P>, target: T): O.Path<T, P>;

get(["bar"], { foo: 3 }); // ✓ error
get(["foo"], { foo: 3 }); // X { foo: number } :(

[schtauffen]

I feel like a tried a million combinations and hit on this almost immediately after posting:

declare function getB<
  T extends object,
  P extends L.List<A.Key>
>(lens: A.Cast<Narrow<P>, O.Paths<T>>, target: T): O.Path<T, P>;

getB(["bar"], { foo: 3 }); // ✓ error
getB(["foo"], { foo: 3 }); // ✓ number