Generic type parameter problem/limitation/question

[myitcv]

Consider the following which is a modified cut-down version of the immutable-js type definition:

interface IIterable<T, K, V> {
    has(key: K): boolean;
    includes(value: V): boolean;
    slice(begin?: number, end?: number): T
    // flatMap<MK, MV>(...): Problems here!
}

interface ISeq<T, K, V> extends IIterable<T, K, V> {
    toSeq(): T;
}

interface IKeyedIterable<T, K, V> extends IIterable<T, K, V> {
    // flip(): Problems here!
}

interface List<V> extends IIterable<List<V>, number, V> {
    set(index: number, value: V): List<V>;
}

interface KeyedSeq<K, V> extends ISeq<KeyedSeq<K, V>, K, V>, IKeyedIterable<KeyedSeq<K, V>, K, V> {
}

The existence of the type parameter T for the definitions of IIterable and ISeq allows slice() to reflect that it returns a sliced instance of the same container 'type' without requiring a type assertion:

let l1: List<string>;
let l2: List<string> = l1.slice(0, 2);

However I can't type flatMap and flip. Taking flip as an example, it should return a container of the same 'type' but with K and V switched. flatMap should return a container of the same 'type' but with MK and MV.

This problem would be 'solved' if we could refer to generic types without requiring that they be passed arguments:

interface IIterable<T, K, V> {
    has(key: K): boolean;
    includes(value: V): boolean;
    slice(begin?: number, end?: number): T<K, V>
    flatMap<MK, MV>(mapper: (value?: V, key?: K, iter?: T<K, V>) => T<MK, MV>, context?: any): T<MK, MV>
}

interface ISeq<T, K, V> extends IIterable<T, K, V> {
    toSeq(): T<K, V>;
}

interface IKeyedIterable<T, K, V> extends IIterable<T, K, V> {
    flip(): T<V, K>;
}

interface List<V> extends IIterable<List, number, V> {
    set(index: number, value: V): List<V>;
}

interface KeyedSeq<K, V> extends ISeq<KeyedSeq, K, V>, IKeyedIterable<KeyedSeq, K, V> {
}

Am I missing something obvious here?

Or do I need to look to some higher order definition with code generation of (generic) interfaces to properly support this?

[mhegazy]

from a cursory look, it seems that flatMap should be defined as*:

export interface Iterable<K, V> {
    flatMap(
      mapper: (value?: V, key?: K, iter?: this) => this,
      context?: any
    ): this;
}

this way no need to infer any new type parameters, just pass them through, which seems to be the expected behavior of flatMap if understand the documentation correctly.

* I am refereing to new this types from #4910

[mhegazy]

@myitcv please reopen if this does not address the issue.

[myitcv]

@mhegazy apologies, somehow I totally missed your reply!

Yes #4910 does help for certain functions.

However for map and flatMap, this can't be used as the return type because those methods are themselves generic:

export interface Iterable<K, V> {
    map<M>(
      mapper: (value?: V, key?: K, iter?: this) => M,
      context?: any
    ): Iterable<K, M>; // can't use 'this' here
}

Any thoughts?

[sandersn]

No, you're not missing something obvious. Typescript doesn't support higher-kinded types. Code generation might be the answer if you can't express the concept any other way.

Haskell's Functor typeclass is essentially what you want, but with more methods than just map.

The type is fmap :: Functor f => (a -> b) -> f a -> f b -- replace Functor with Iterable and you get

function fmap<F extends Iterable, A, B>(mapper: (a:A) => B, i: F<A>): F<B> {
    // code that uses the iterable interface to iterate over i...
}

Unfortunately, Typescript doesn't support higher-order types, so you'll have to find a different way of expressing this code.

[myitcv]

@sandersn - thanks for confirming. Code generation is probably the cleanest solution here.

[shelby3]

Unfortunately this means no Functor map nor generic iterator factories.