FuncType - v1.21.0
    Preparing search index...

    Interface Map<K, V>

    A traversable interface for key-value containers that excludes map, flatMap, flatMapAsync, and ap operations.

    Key-value containers (Map, Obj) cannot satisfy Functor's unconstrained map<B extends Type> because their type parameter is constrained (e.g., to Record or Tuple pairs). These containers redefine map/flatMap with their own tighter constraints.

    interface Map<K, out V> {
        _tag: "Map";
        "[toStringTag]": string;
        isEmpty: boolean;
        size: number;
        add(item: Tuple<[K, V]>): Map<K, V>;
        ap<U>(ff: Map<K, (value: V) => U>): Map<K, U>;
        contains(value: unknown): boolean;
        flatMap<K2, V2>(
            f: (entry: Tuple<[K, V]>) => Iterable<[K2, V2]>,
        ): Map<K2, V2>;
        flatMapAsync<U>(
            f: (value: V) => PromiseLike<Map<K, U>>,
        ): PromiseLike<Map<K, U>>;
        fold<B>(initial: B, fn: (acc: B, a: Tuple<[K, V]>) => B): B;
        foldLeft<B>(z: B): (op: (b: B, a: Tuple<[K, V]>) => B) => B;
        foldRight<B>(z: B): (op: (a: Tuple<[K, V]>, b: B) => B) => B;
        get(key: K): Option<V>;
        getOrElse(key: K, defaultValue: V): V;
        has(key: K): boolean;
        keys(): List<K>;
        map<U>(f: (value: V) => U): Map<K, U>;
        match<R>(
            patterns: { Empty: () => R; NonEmpty: (entries: Tuple<[K, V]>[]) => R },
        ): R;
        orElse(key: K, alternative: Option<V>): Option<V>;
        pipe<U extends unknown>(f: (value: [K, V][]) => U): U;
        reduce<B = Tuple<[K, V]>>(
            op: (
                b: Widen<Tuple<[K, V]>, B>,
                a: Widen<Tuple<[K, V]>, B>,
            ) => Widen<Tuple<[K, V]>, B>,
        ): Widen<Tuple<[K, V]>, B>;
        reduceRight<B = Tuple<[K, V]>>(
            op: (
                b: Widen<Tuple<[K, V]>, B>,
                a: Widen<Tuple<[K, V]>, B>,
            ) => Widen<Tuple<[K, V]>, B>,
        ): Widen<Tuple<[K, V]>, B>;
        remove(value: K): Map<K, V>;
        serialize(): SerializationMethods<[K, V][]>;
        toJSON(): SerializableEnvelope;
        toList(): List<Tuple<[K, V]>>;
        toSet(): Set<Tuple<[K, V]>>;
        toString(): string;
        toValue(): { _tag: "Map"; value: [K, V][] };
        values(): List<V>;
    }

    Type Parameters

    • K

      The element type of the traversable

    • out V

    Hierarchy (View Summary)

    Index
    _tag [toStringTag] isEmpty size
    add ap contains flatMap flatMapAsync fold foldLeft foldRight get getOrElse has keys map match orElse pipe reduce reduceRight remove serialize toJSON toList toSet toString toValue values

    Readonly_tag

    _tag: "Map"
    "[toStringTag]": string
    isEmpty: boolean
    size: number

    • Type Parameters

      • U

      Parameters

      Returns Map<K, U>

    • Parameters

      • value: unknown

      Returns boolean

    • Type Parameters

      • U

      Parameters

      • f: (value: V) => PromiseLike<Map<K, U>>

      Returns PromiseLike<Map<K, U>>

    • Type Parameters

      • B

      Parameters

      Returns B

    • Left-associative fold using the provided zero value and operation

      Type Parameters

      • B

      Parameters

      • z: B

        Zero/identity value

      Returns (op: (b: B, a: Tuple<[K, V]>) => B) => B

      A function that takes an operation to apply

    • Right-associative fold using the provided zero value and operation

      Type Parameters

      • B

      Parameters

      • z: B

        Zero/identity value

      Returns (op: (a: Tuple<[K, V]>, b: B) => B) => B

      A function that takes an operation to apply

    • Parameters

      • key: K
      • defaultValue: V

      Returns V

    • Whether the map holds an entry for key. Keys compare like a native Map: by identity for objects, by SameValueZero otherwise.

      True even when the stored value is undefined, where get(key) returns None. For an entry check (key and value), use contains(Tuple([k, v])), which compares the value with ===.

      Parameters

      • key: K

        The key to look up

      Returns boolean

      true if the map has an entry for key

    • The keys, in insertion order. A List, like Obj.keys().

      Returns List<K>

      A List of the map's keys

    • Type Parameters

      • U

      Parameters

      • f: (value: V) => U

      Returns Map<K, U>

    • Pattern matches over the Map, applying a handler function based on whether it's empty

      Type Parameters

      • R

      Parameters

      • patterns: { Empty: () => R; NonEmpty: (entries: Tuple<[K, V]>[]) => R }

        Object with handler functions for Empty and NonEmpty variants

      Returns R

      The result of applying the matching handler function

    • Pipes the value through the provided function

      Type Parameters

      • U extends unknown

        The return type of the function

      Parameters

      • f: (value: [K, V][]) => U

        The function to apply to the value

      Returns U

      The result of applying the function to the value

    • Parameters

      • value: K

      Returns Map<K, V>

    • Custom JSON serialization. Returns the canonical @functype-marked envelope object so native JSON.stringify (and the rest of the JSON toJSON protocol) emits a round-trip-able shape that Serialization.deserialize can reconstruct.

      Added in 1.2.0. Concrete types narrow the return to their specific marker/tag literals.

      Returns SerializableEnvelope

    • Returns { _tag: "Map"; value: [K, V][] }

    • The values, in insertion order. Duplicates are kept.

      Returns List<V>

      A List of the map's values

    Settings
    Member Visibility

    On This Page
    Properties
    Methods