ResultAsync.combine

// Homogeneous lists
function combine<T, E>(
  asyncResultList: ResultAsync<T, E>[]
): ResultAsync<T[], E>

// Heterogeneous tuples
function combine<T1, T2, E1, E2>(
  asyncResultList: [ResultAsync<T1, E1>, ResultAsync<T2, E2>]
): ResultAsync<[T1, T2], E1 | E2>

// Homogeneous lists  
function combineWithAllErrors<T, E>(
  asyncResultList: ResultAsync<T, E>[]
): ResultAsync<T[], E[]>

// Heterogeneous tuples
function combineWithAllErrors<T1, T2, E1, E2>(
  asyncResultList: [ResultAsync<T1, E1>, ResultAsync<T2, E2>]
): ResultAsync<[T1, T2], (E1 | E2)[]>

import { ResultAsync } from 'neverthrow'

const results = await ResultAsync.combine([
  fetchUser(1),
  fetchUser(2),
  fetchUser(3)
])

// results is Result<User[], FetchError>
if (results.isOk()) {
  const users = results.value // User[]
}

const combined = await ResultAsync.combine([
  fetchUser(id),      // ResultAsync<User, FetchError>
  fetchPosts(userId), // ResultAsync<Post[], PostError>
  fetchComments(id)   // ResultAsync<Comment[], CommentError>
])

// combined is ResultAsync<[User, Post[], Comment[]], FetchError | PostError | CommentError>

const results = await ResultAsync.combine([
  okAsync(1),
  errAsync('error'),  // First error
  okAsync(3)
])

// results is Err('error')
// Third operation may not even execute

const results = await ResultAsync.combineWithAllErrors([
  errAsync('error1'),
  okAsync(2),
  errAsync('error3')
])

// results is Err(['error1', 'error3'])
// All operations executed, all errors collected

const validateForm = async (form: FormData) => {
  return ResultAsync.combineWithAllErrors([
    validateEmail(form.email),
    validatePassword(form.password),
    validateAge(form.age),
    checkUsernameAvailable(form.username)
  ]).map(() => form)
}

const result = await validateForm(formData)
if (result.isErr()) {
  // Show all validation errors at once
  displayErrors(result.error)
}

const loadDashboard = async (userId: number) => {
  const combined = await ResultAsync.combine([
    fetchUserProfile(userId),
    fetchRecentActivity(userId),
    fetchNotifications(userId),
    fetchSettings(userId)
  ])
  
  return combined.map(([profile, activity, notifications, settings]) => ({
    profile,
    activity,
    notifications,
    settings
  }))
}