Let type identifiers co-exist with import namespace identifiers #36704

Activity

1. jonaskello commented on Feb 9, 2020

   

   Jonas Kello (jonaskello)

   on Feb 9, 2020

   Last edited by jonaskello

   Author

   More actions

   Note that the solution does not necessarily need to use import *. Some other way to allow a namespace to co-exist with a type would also cover it. In simple cases like the Result example above where the module export a single type it is actually possible to make it work today by using an intermediate file like this:

   index.ts

   import * as ResultNs from "./result";
   export const Result = ResultNs;
   export type Result<T1, T2> = ResultNs.Result<T1, T2>;

   And in the consuming module you can use it like this:

   import { Result } from "./index";
   
   export function itsOk(): Result<string, string> {
     const ok: Result<string, string> = Result.Ok("hello");
     const err: Result<string, string> = Result.Err("hello");
     return ok;
   }

   Notice how the consumer can use Result when referring to the type. This is really nice, however it breaks down if the result module would export a second type as referring to other types like Result.OtherType will not work (since Result now is a const and not a namespace).

   In this case it would be nice if we could do something like this in the intermediate file:

   index.ts

   export * as Result from "./result";
   export type { Result } from "./result";
2. Ryan Cavanaugh (RyanCavanaugh)

   added

   In DiscussionNot yet reached consensusNot yet reached consensus

   SuggestionAn idea for TypeScriptAn idea for TypeScript

   on Feb 21, 2020
3. Conaclos commented on Jun 30, 2021

   

   Victorien Elvinger (Conaclos)

   on Jun 30, 2021

   Last edited by Conaclos

   More actions

   Some additions and a workaround :)

   TypeScript already accepts some form of co-existance.

   For example, the next code is valid :

   export type Result<TError, TValue> =
     | { readonly type: "Ok"; readonly value: TValue }
     | { readonly type: "Err"; readonly error: TError }
   
   export const Result = {
       Ok<TValue>(value: TValue): Result<never, TValue> {
           return { type: "Ok", value }
       },
       Err<TError>(error: TError): Result<TError, never> {
           return { type: "Err", error }
       }
   }

   import { Result } from "./result"
   
   const x: Result<string, string> = Result.Ok("")

   However, the code cannot be tree-shaked.

   Curiously, TypeScript also accept this code:

   export type Result<TError, TValue> =
     | { readonly type: "Ok"; readonly value: TValue }
     | { readonly type: "Err"; readonly error: TError }
   
   export { Ok, Err } from "./result-functions"

   But import only the type :

   import { Result } from "./result"
   
   const x: Result<string, string> = Result.Ok("")
   // 'Result' only refers to a type, but is being used as a value here.

   To resolve this issue, we can create an indirection:

   export type Result<TError, TValue> =
     | { readonly type: "Ok"; readonly value: TValue }
     | { readonly type: "Err"; readonly error: TError }
   
   import * as ResultFunctions from "./result-functions"
   export const Result = ResultFunctions

   I discover this workaround several years ago. However I am still afraid of a regression in a next version of TypeScript. It could be great whether the design team could clarify the situation and provide a full support for co-existance.