common-stuff
    Preparing search index...

    Function map

    • Maps each element of an iterable structure preserving the original container type.

      • Array → Array
      • Set → Set
      • Map → Map (mapper receives and returns [key, value])
      • Record → Record (mapper receives and returns [key, value])
      • Iterable → lazy Iterable (eagerly resolved when mapper is async)
      • AsyncIterable → lazy AsyncIterable (mapper may be async)

      When the mapper returns a Promise, the function returns a Promise of the resulting container.

      Type Parameters

      • V
      • R

      Parameters

      • input: V[]
      • mapper: (value: V, index: number) => Promise<R>

      Returns Promise<R[]>

      map([1, 2, 3], v => v * 2)            // [2, 4, 6]
      await map([1, 2, 3], async v => v*2)  // [2, 4, 6] (Promise)
      map(new Set([1, 2]), v => v + 1)      // Set { 2, 3 }

    • Maps each element of an iterable structure preserving the original container type.

      • Array → Array
      • Set → Set
      • Map → Map (mapper receives and returns [key, value])
      • Record → Record (mapper receives and returns [key, value])
      • Iterable → lazy Iterable (eagerly resolved when mapper is async)
      • AsyncIterable → lazy AsyncIterable (mapper may be async)

      When the mapper returns a Promise, the function returns a Promise of the resulting container.

      Type Parameters

      • V
      • R

      Parameters

      • input: V[]
      • mapper: (value: V, index: number) => R

      Returns R[]

      map([1, 2, 3], v => v * 2)            // [2, 4, 6]
      await map([1, 2, 3], async v => v*2)  // [2, 4, 6] (Promise)
      map(new Set([1, 2]), v => v + 1)      // Set { 2, 3 }

    • Maps each element of an iterable structure preserving the original container type.

      • Array → Array
      • Set → Set
      • Map → Map (mapper receives and returns [key, value])
      • Record → Record (mapper receives and returns [key, value])
      • Iterable → lazy Iterable (eagerly resolved when mapper is async)
      • AsyncIterable → lazy AsyncIterable (mapper may be async)

      When the mapper returns a Promise, the function returns a Promise of the resulting container.

      Type Parameters

      • K
      • V
      • K2
      • V2

      Parameters

      • input: Map<K, V>
      • mapper: (value: [K, V], index: number) => Promise<[K2, V2]>

      Returns Promise<Map<K2, V2>>

      map([1, 2, 3], v => v * 2)            // [2, 4, 6]
      await map([1, 2, 3], async v => v*2)  // [2, 4, 6] (Promise)
      map(new Set([1, 2]), v => v + 1)      // Set { 2, 3 }

    • Maps each element of an iterable structure preserving the original container type.

      • Array → Array
      • Set → Set
      • Map → Map (mapper receives and returns [key, value])
      • Record → Record (mapper receives and returns [key, value])
      • Iterable → lazy Iterable (eagerly resolved when mapper is async)
      • AsyncIterable → lazy AsyncIterable (mapper may be async)

      When the mapper returns a Promise, the function returns a Promise of the resulting container.

      Type Parameters

      • K
      • V
      • K2
      • V2

      Parameters

      • input: Map<K, V>
      • mapper: (value: [K, V], index: number) => [K2, V2]

      Returns Map<K2, V2>

      map([1, 2, 3], v => v * 2)            // [2, 4, 6]
      await map([1, 2, 3], async v => v*2)  // [2, 4, 6] (Promise)
      map(new Set([1, 2]), v => v + 1)      // Set { 2, 3 }

    • Maps each element of an iterable structure preserving the original container type.

      • Array → Array
      • Set → Set
      • Map → Map (mapper receives and returns [key, value])
      • Record → Record (mapper receives and returns [key, value])
      • Iterable → lazy Iterable (eagerly resolved when mapper is async)
      • AsyncIterable → lazy AsyncIterable (mapper may be async)

      When the mapper returns a Promise, the function returns a Promise of the resulting container.

      Type Parameters

      • T
      • R

      Parameters

      • input: Set<T>
      • mapper: (value: T, index: number) => Promise<R>

      Returns Promise<Set<R>>

      map([1, 2, 3], v => v * 2)            // [2, 4, 6]
      await map([1, 2, 3], async v => v*2)  // [2, 4, 6] (Promise)
      map(new Set([1, 2]), v => v + 1)      // Set { 2, 3 }

    • Maps each element of an iterable structure preserving the original container type.

      • Array → Array
      • Set → Set
      • Map → Map (mapper receives and returns [key, value])
      • Record → Record (mapper receives and returns [key, value])
      • Iterable → lazy Iterable (eagerly resolved when mapper is async)
      • AsyncIterable → lazy AsyncIterable (mapper may be async)

      When the mapper returns a Promise, the function returns a Promise of the resulting container.

      Type Parameters

      • T
      • R

      Parameters

      • input: Set<T>
      • mapper: (value: T, index: number) => R

      Returns Set<R>

      map([1, 2, 3], v => v * 2)            // [2, 4, 6]
      await map([1, 2, 3], async v => v*2)  // [2, 4, 6] (Promise)
      map(new Set([1, 2]), v => v + 1)      // Set { 2, 3 }

    • Maps each element of an iterable structure preserving the original container type.

      • Array → Array
      • Set → Set
      • Map → Map (mapper receives and returns [key, value])
      • Record → Record (mapper receives and returns [key, value])
      • Iterable → lazy Iterable (eagerly resolved when mapper is async)
      • AsyncIterable → lazy AsyncIterable (mapper may be async)

      When the mapper returns a Promise, the function returns a Promise of the resulting container.

      Type Parameters

      • T
      • R

      Parameters

      • input: AsyncIterable<T>
      • mapper: (value: T, index: number) => R | Promise<R>

      Returns AsyncIterable<R>

      map([1, 2, 3], v => v * 2)            // [2, 4, 6]
      await map([1, 2, 3], async v => v*2)  // [2, 4, 6] (Promise)
      map(new Set([1, 2]), v => v + 1)      // Set { 2, 3 }

    • Maps each element of an iterable structure preserving the original container type.

      • Array → Array
      • Set → Set
      • Map → Map (mapper receives and returns [key, value])
      • Record → Record (mapper receives and returns [key, value])
      • Iterable → lazy Iterable (eagerly resolved when mapper is async)
      • AsyncIterable → lazy AsyncIterable (mapper may be async)

      When the mapper returns a Promise, the function returns a Promise of the resulting container.

      Type Parameters

      • T
      • R

      Parameters

      • input: Iterable<T>
      • mapper: (value: T, index: number) => Promise<R>

      Returns Promise<Iterable<R, any, any>>

      map([1, 2, 3], v => v * 2)            // [2, 4, 6]
      await map([1, 2, 3], async v => v*2)  // [2, 4, 6] (Promise)
      map(new Set([1, 2]), v => v + 1)      // Set { 2, 3 }

    • Maps each element of an iterable structure preserving the original container type.

      • Array → Array
      • Set → Set
      • Map → Map (mapper receives and returns [key, value])
      • Record → Record (mapper receives and returns [key, value])
      • Iterable → lazy Iterable (eagerly resolved when mapper is async)
      • AsyncIterable → lazy AsyncIterable (mapper may be async)

      When the mapper returns a Promise, the function returns a Promise of the resulting container.

      Type Parameters

      • T
      • R

      Parameters

      • input: Iterable<T>
      • mapper: (value: T, index: number) => R

      Returns Iterable<R>

      map([1, 2, 3], v => v * 2)            // [2, 4, 6]
      await map([1, 2, 3], async v => v*2)  // [2, 4, 6] (Promise)
      map(new Set([1, 2]), v => v + 1)      // Set { 2, 3 }

    • Maps each element of an iterable structure preserving the original container type.

      • Array → Array
      • Set → Set
      • Map → Map (mapper receives and returns [key, value])
      • Record → Record (mapper receives and returns [key, value])
      • Iterable → lazy Iterable (eagerly resolved when mapper is async)
      • AsyncIterable → lazy AsyncIterable (mapper may be async)

      When the mapper returns a Promise, the function returns a Promise of the resulting container.

      Type Parameters

      • K extends PropertyKey
      • V
      • K2 extends PropertyKey
      • V2

      Parameters

      • input: Record<K, V>
      • mapper: (value: [K, V], index: number) => [K2, V2]

      Returns Record<K2, V2>

      map([1, 2, 3], v => v * 2)            // [2, 4, 6]
      await map([1, 2, 3], async v => v*2)  // [2, 4, 6] (Promise)
      map(new Set([1, 2]), v => v + 1)      // Set { 2, 3 }

    • Maps each element of an iterable structure preserving the original container type.

      • Array → Array
      • Set → Set
      • Map → Map (mapper receives and returns [key, value])
      • Record → Record (mapper receives and returns [key, value])
      • Iterable → lazy Iterable (eagerly resolved when mapper is async)
      • AsyncIterable → lazy AsyncIterable (mapper may be async)

      When the mapper returns a Promise, the function returns a Promise of the resulting container.

      Type Parameters

      • K extends PropertyKey
      • V
      • K2 extends PropertyKey
      • V2

      Parameters

      • input: Record<K, V>
      • mapper: (value: [K, V], index: number) => Promise<[K2, V2]>

      Returns Promise<Record<K2, V2>>

      map([1, 2, 3], v => v * 2)            // [2, 4, 6]
      await map([1, 2, 3], async v => v*2)  // [2, 4, 6] (Promise)
      map(new Set([1, 2]), v => v + 1)      // Set { 2, 3 }

    Settings

    Member Visibility