3 replies

Type Inference Issue with ParseResult and Effect.all in Schema.transformOrFail

Type inference issue with ParseResult.decodeUnknown and Effect.all in Schema.transformOrFail

I'm experiencing a Requirements channel widening issue when composing ParseResult operations in Schema.transformOrFail.

Individual ParseResult.decodeUnknown calls correctly return R = never:

const decodeUser = (input: unknown) => {
  return ParseResult.decodeUnknown(UserSchema)(input)
  // Type: Effect<{ name: string; age: number }, ParseIssue, never>
}

const decodeUser = (input: unknown) => {
  return ParseResult.decodeUnknown(UserSchema)(input)
  // Type: Effect<{ name: string; age: number }, ParseIssue, never>
}

const decodeUser = (input: unknown) => {
  return ParseResult.decodeUnknown(UserSchema)(input)
  // Type: Effect<{ name: string; age: number }, ParseIssue, never>
}

const decodeUser = (input: unknown) => {
  return ParseResult.decodeUnknown(UserSchema)(input)
  // Type: Effect<{ name: string; age: number }, ParseIssue, never>
}

Simple Effect.all compositions preserve R = never:

const pipeline = (data: unknown[]) => {
  return pipe(
    Effect.all(data.map((item) => decodeUser(item))),
    Effect.map((users) => {
      console.log(`Decoded ${users.length} users`)
      return users
    })
  )
  // Type: Effect<User[], ParseIssue, never> ✓
}

const pipeline = (data: unknown[]) => {
  return pipe(
    Effect.all(data.map((item) => decodeUser(item))),
    Effect.map((users) => {
      console.log(`Decoded ${users.length} users`)
      return users
    })
  )
  // Type: Effect<User[], ParseIssue, never> ✓
}

const pipeline = (data: unknown[]) => {
  return pipe(
    Effect.all(data.map((item) => decodeUser(item))),
    Effect.map((users) => {
      console.log(`Decoded ${users.length} users`)
      return users
    })
  )
  // Type: Effect<User[], ParseIssue, never> ✓
}

const pipeline = (data: unknown[]) => {
  return pipe(
    Effect.all(data.map((item) => decodeUser(item))),
    Effect.map((users) => {
      console.log(`Decoded ${users.length} users`)
      return users
    })
  )
  // Type: Effect<User[], ParseIssue, never> ✓
}

However, using Effect.all with an object inside Schema.transformOrFail causes TypeScript to infer R = unknown:

const UserTransform = Schema.transformOrFail(
  RawUser,
  PrettyUser,
  {
    strict: true,
    decode: (raw) =>
      Effect.all({
        name: decodeRawField(raw.full_name),     // R = never
        age: decodeRawAge(raw.user_age),         // R = never  
        isAdult: Effect.succeed(raw.user_age >= 18)
      }),
      // TypeScript infers: Effect<..., ParseIssue, unknown>
      //                                            ^^^^^^^
    encode: () => { throw new Error("Not implemented") }
  }
)

const UserTransform = Schema.transformOrFail(
  RawUser,
  PrettyUser,
  {
    strict: true,
    decode: (raw) =>
      Effect.all({
        name: decodeRawField(raw.full_name),     // R = never
        age: decodeRawAge(raw.user_age),         // R = never  
        isAdult: Effect.succeed(raw.user_age >= 18)
      }),
      // TypeScript infers: Effect<..., ParseIssue, unknown>
      //                                            ^^^^^^^
    encode: () => { throw new Error("Not implemented") }
  }
)

const UserTransform = Schema.transformOrFail(
  RawUser,
  PrettyUser,
  {
    strict: true,
    decode: (raw) =>
      Effect.all({
        name: decodeRawField(raw.full_name),     // R = never
        age: decodeRawAge(raw.user_age),         // R = never  
        isAdult: Effect.succeed(raw.user_age >= 18)
      }),
      // TypeScript infers: Effect<..., ParseIssue, unknown>
      //                                            ^^^^^^^
    encode: () => { throw new Error("Not implemented") }
  }
)

const UserTransform = Schema.transformOrFail(
  RawUser,
  PrettyUser,
  {
    strict: true,
    decode: (raw) =>
      Effect.all({
        name: decodeRawField(raw.full_name),     // R = never
        age: decodeRawAge(raw.user_age),         // R = never  
        isAdult: Effect.succeed(raw.user_age >= 18)
      }),
      // TypeScript infers: Effect<..., ParseIssue, unknown>
      //                                            ^^^^^^^
    encode: () => { throw new Error("Not implemented") }
  }
)

This produces a compilation error:

Argument of type 'Effect<..., ParseError, unknown>' is not assignable 
to parameter of type 'Effect<..., ParseError, never>'.
  Type 'unknown' is not assignable to type 'never'.

Argument of type 'Effect<..., ParseError, unknown>' is not assignable 
to parameter of type 'Effect<..., ParseError, never>'.
  Type 'unknown' is not assignable to type 'never'.

Argument of type 'Effect<..., ParseError, unknown>' is not assignable 
to parameter of type 'Effect<..., ParseError, never>'.
  Type 'unknown' is not assignable to type 'never'.

Argument of type 'Effect<..., ParseError, unknown>' is not assignable 
to parameter of type 'Effect<..., ParseError, never>'.
  Type 'unknown' is not assignable to type 'never'.

Full reproduction: https://effect.website/play#ca4d68c96691

Why does TypeScript widen the Requirements channel from never to unknown in this specific composition pattern? Is this expected behavior or am I missing something about how to properly compose ParseResult operations in transformOrFail?

Type Inference Issue with ParseResult and Effect.all in Schema.transformOrFail

Similar Threads

Similar Threads

Similar Threads