What is the use case of multi-type-parameters generic interface?

Question

Previously, I ask a similar question, but the answer given only demonstrates the usage of multiple-type-parameters(MTP) data structure, but not MTP generic interface.

Based on my experience, generic interface is useful for generalizing algorithms. For example, the sorting algorithm can be defined as such:

// Java code

interface Comparable<T> {
    Boolean compareTo(T other) 
}

void <T extends Comparable<T>> sort(List<T> elements) {
    // body
}

So, the code above demonstrated the usage of single-type-parameter generic interface.

However, I have not encountered any use case for multiple-type-parameter generic interface up until now.

Thus, I am hoping that some one could provide me some use cases regarding multiple-type-parameter interfaces.

Also, if possible, please explain how multiple-type-parameter could improve some situation.

(For example, the Comparable interface allows the sort function to be generalized, so that one do not need to define multiple sort function for different types of element)

P/S: I ask this question because I am considering whether to include MTP generic interface in my new programming language.

Answer 1

A map, also known as a dictionary, is a datastructure that maps keys of type K to values of type V. It is naturally parameterized by two parameters, K and V. This is the case in the Java collections library, for instance, where you can find the interface Map<K,V>.

There are may other examples, of course. For instance, you could have a graph whose vertices are labeled with type A and edges labeled with type B. Then it would be natural to have a class Graph<A,B>.

Supplemental: The OP is still asking for examples where generics with several parameters are used. In order to prod the imagination, here are some:

1. Dijsktra's algorithm for finding shortest paths in a graph could be parametrized by Graph<A, B extends Comparable> so that it works on any graph whose edges are labeled by values that implement the Comparable interface. (Yes, A is not used in this example, but that is beside the point. It is useful to allow vertices of graphs to be labeled.)

2. An implementation of Map<K, V> using AVL trees would be a class AVLMap<K extends Comparable, V>. Such a class will contain generic implementations of algorithms for manipulation of AVL trees. Other variants are possible (red-black trees, splay trees, etc.), each leading to a whole family of algorithms.

3. A function which takes a Map<K,V> and determines whether a given map represents an injective function.

4. A function which takes a Map<K,List<K>> representing a graph by the adjacency lists and determines whether the graph is bipartite. Or counts the number of cycles. Or computes the chromatic number. This is an example where there is a dependency between the parameters of Map. If we did not have multi-parameter interfaces, then we could not even express dependencies between the parameters.

5. A function which takes a Map<K, V> and converts it to a HasMap<K, V>.

6. A function whic takes a Map<K, V> and computes the inverse map Map<V, Set<K>>.

Answer 2

The most typical usecase I've encountered is generic idea of container, parameterized by both the container type and contained type. F.e. you can describe generic type class of containers providing get/set/delete operations for arbitrary types providing hash() operation.

Even more complicated usecase is type+container+monad, involving concrete monad where all update operations on the container occur, but this is mainly interesting in the Haskell realm.