JS: Polymorphism
2026-02-21 02:55 Diff
https://hexlet.io/courses/js-polymorphism/lessons/parametric-polymorphism/theory_unit

The word polymorphism can mean different things depending on the context. When programmers in imperative languages talk about polymorphism, they usually mean polymorphism of subtypes. At the same time, programmers in functional languages have parametric polymorphism in mind. Let us talk about the latter.

We will see Java code in this lesson. Do not worry if you don't fully understand it. Our goal is to deal with concepts, not Java itself.

The lodash library has the _.concat() function, which combines arrays passed to it:

This function joins any array, regardless of the type of data contained within. Let's try to implement it ourselves.

It is a slightly stripped-down version of the concat function. It only works with two arguments, each of them is an array. The function creates a new array, then traverses the passed arrays one by one, and adds their values to the newly created array.Then, it returns the result:

Take a close look at this code. Does it perform any operations on the data inside the array? The correct answer is no. This data moves from one array to another, but we do not act on it. Our new concat() function, like the original _.concat() function, can handle arrays containing any data type.

This behavior seems natural for developers who've only written in dynamic languages. But in static languages, it's not so simple. Below is an example of the definition of arrays in Java:

The first thing you might notice is the need to specify the type. For the first array, it is int. For the second one, it is String. You can't create an array without specifying what type its values will have. The same applies to functions that process arrays:

Note the signature of the concat() method: concat(): int[] concat(int[] arr1, int[] arr2). In contrast to the JavaScript variant, the input parameters here are arrays of numbers. I.e., this function won't work for an array of strings. Nor will it work for all other data types.

What does this mean in practice? Something simple but sad. We have to implement a similar function for each type even though the algorithm inside is identical.

It is where parametric polymorphism comes in handy. Static languages have to introduce special constructions into the language. They help us describe these algorithms without regard to the type of parameter. In some languages, they're called templates (C++) or generics (Java, C#):

In this code, we see a type called T. It simply means we can use it within an array with any type. The concat() method now works like its JavaScript counterpart.

Parametric polymorphism makes it possible to write generalized algorithms for composite types. In some cases, it reduces the amount of code. Sometimes, this comes at the expense of having a simple solution. But you won't see an increase in complexity for most typical operations. You can see that in the code above.

Dynamic languages don't need parametric polymorphism to implement generalized algorithms. Any collection can contain any data type at any time. It eliminates the need to introduce additional language constructs and learn new concepts.

In the literature, the usage of parametric polymorphism is often called generalized programming.