Stefanio 29 авг 2023 в 16:00

Ad-hoc-полиморфизм и паттерн type class в C#

Средний

8 мин

14K

Блог компании RUVDS.comПрограммирование*.NET*C#*Функциональное программирование*

FAQ

Эта статья объясняет, что такое ad-hoc-полиморфизм, какие проблемы он решает и как вообще его реализовать, используя паттерн type class на языке программирования C#.

▍ Виды полиморфизмов

Оказывается, что полиморфизмов есть, как минимум, три вида:

Параметрический.
Специальный (ad-hoc).
Полиморфизм подтипов.

Начнём с параметрического полиморфизма. Допустим, у нас есть список элементов. Это может быть список целых чисел, чисел с плавающей запятой, строк, чего угодно. Теперь представьте метод GetHead(), который возвращает первый элемент из этого списка. Для него не важно, является ли возвращаемый элемент типом int, string, Apple или Orange. Его возвращаемый тип — это формальный типовой параметр, стоящий вместо T внутри IList<T>, и его реализация одинакова для всех типов: «вернуть первый элемент».

interface IList<T>
{
    T GetHead();
}

В отличие от параметрического полиморфизма, специальный полиморфизм привязан к типу. В зависимости от него вызываются разные реализации метода. Перегрузка методов — один из примеров ad-hoc-полиморфизма. Например, можно иметь две версии метода, присоединяющего первый элемент ко второму — одну, которая принимает два целых числа и складывает их, и другую, которая принимает две строки и конкатенирует их. Вы знаете, что 2 + 3 = 5, но "2" + "3" = "23".

class Appender
{
    public int AppendItems(int a, int b) =>
        a + b;

    public string AppendItems(string a, string b) =>
        $"{a}{b}";
}

При полиморфизме подтипов дочерние классы предоставляют разные реализации метода некоторого базового класса. В отличие от специального полиморфизма, где решение о том, какая реализация вызывается, принимается на этапе компиляции (раннее связывание), в полиморфизме подтипов оно принимается во время выполнения (позднее связывание).

abstract class Animal
{
    public abstract int GetMeatMass();
}

class Cow : Animal
{
    public override int GetMeatMass() => 20;
}

class Dog : Animal
{
    public override int GetMeatMass() => 5;
}

Теперь давайте ближе рассмотрим ad-hoc-полиморфизм, два других рассматривать подробно в этот раз не будем. Как уже было ранее сказано, перегрузка методов является одним из способов достижения специального полиморфизма: каждая «версия» метода будет принимать разные параметры, и при вызове метода будет выбрана правильная реализация на основе типа предоставленных параметров. Но представим, что есть другой сценарий — предположим, мы хотим иметь только один метод (можем назвать его AppendItems()), и хочется, чтобы этот метод принимал два «присоединяемых» элемента. Если вызывается с целыми числами, они должны быть присоединены с использованием арифметического сложения. Если вызывается со строками, они должны быть присоединены с использованием конкатенации. Можно придумать реализации для различных других типов, но для нашего примера int и string будет достаточно.

Конечно, есть вариант решить задачу «в лоб» — писать перегрузку на каждый тип данных, однако хотелось бы заставить компилятор помогать нам, не создавая 100500 методов.

class Appender
{
    public int AppendItems(int a, int b) =>
        a + b;

    public string AppendItems(string a, string b) =>
        $"{a}{b}";

    public bool AppendItems(bool a, bool b) =>
        a || b;
}

▍ Как соединять уток

Итак, необходимо, чтобы метод AppendItems() принимал два экземпляра чего-то «присоединяемого» и выполнял над ними операцию соединения. Также требуется, чтобы эта операция имела разные реализации для различных «присоединяемых» объектов. Для целых чисел — сложение, для строк — конкатенация. Это наилучший пример специального полиморфизма.

Обратите внимание, что метод должен иметь всего одну реализацию — без перегрузки или переопределения! Как же он может выполнять разные операции для разных типов? Итак, идея заключается в том, что метод AppendItems() даже не должен знать, как реализована операция присоединения; он должен просто её вызвать. Вот сам метод:

class Appender
{
    T AppendItems<T>(T a, T b) => a.Append(b);
}

В этом самая сложная часть — нужно каким-то образом получить операцию присоединения для целых чисел и строк. Как? Тем не менее, в глазах нашего метода AppendItems() они не будут целыми числами и строками. Они будут чем-то «присоединяемым». Это, по сути, пример утиной типизации по поведению: если оно ходит как утка и крякает как утка, то по нашему мнению — это утка. Нам не важно, что это на самом деле, всё, что нас волнует, это то, что оно способно крякать. Вот что и сделаем здесь, только вместо того чтобы значения умели крякать, необходимо, чтобы они могли присоединяться.

Конечно, метод выше не cкомпилируется, так как у обобщённого типа T нет метода Append(). И что же здесь делать? Я объясню два подхода к решению этой проблемы — контейнерные типы и паттерн type class.

▍ Контейнерные типы

Дабы убедить компилятор в том, что тип T по-настоящему присоединяемый, можно использовать подход с контейнерными типами, который задействует достаточно распространённые механизмы в C#. Тогда получится реализовать метод AppendItems() похожим образом на то, как было показано выше.

class Appender
{
    public T AppendItems<T>(AppendableValue<T> a, AppendableValue<T> b) =>
        a.Append(b);
}

Этот метод говорит: «Я беру два элемента типа AppendableValue<T> и присоединяю их». Компилятор отвечает: «Хорошо, я позволю вам вызвать метод Append() на значении типа AppendableValue<T>, потому что вы обещали, что у него будет метод Append(), и я полагаюсь на это». Если его нет на этапе компиляции, компилятор будет мягко говоря недоволен, потому что нарушено обещание, и компиляция завершится с ошибкой.

Ладно, метод AppendItems() получен. Перейдём к типу AppendableValue<T>.

Во-первых, AppendableValue<T> будет абстрактным классом. Прежде всего, достаточно удобно использовать абстрактный класс для реализации контейнерного типа, в случае если нужно передать некоторые параметры в конструктор базового класса, некоторый код на C# унаследует его и так далее.

Во-вторых, AppendableValue<T> будет параметризован — у него будет формальный типовой параметр. Почему? Ну, потому что его операция Append() (не путать с нашим методом AppendItems()!) является обобщённой. Она будет реализована по-разному для разных типов, в нашем случае как сложение для целых чисел и как конкатенация для строк. Поскольку метод Append() зависит от типа, весь абстрактный класс зависит от типа. Обратите внимание, что если бы он не зависел от типа, то это был бы случай параметрического полиморфизма, но так как зависит, это случай специального полиморфизма.

Итак, вот наш милый маленький контейнерный тип, реализованный при помощи абстрактного класса:

abstract class AppendableValue<T>
{
    public T Value { get; }

    protected AppendableValue(T value) =>
        Value = value;

    public abstract T Append(AppendableValue<T> item);
}

Теперь, когда создано определение контейнерного типа, давайте напишем две разные реализации для него: одну для int и другую для string. Вот они:

class AppendableIntValue :
    AppendableValue<int>
{
    public AppendableIntValue(int value) :
        base(value) { }

    public override int Append(AppendableValue<int> item) =>
        Value + item.Value;
}

class AppendableStringValue :
    AppendableValue<string>
{
    public AppendableStringValue(string value) :
        base(value) { }

    public override string Append(AppendableValue<string> item) =>
        $"{Value}{item.Value}";
}

Интерполяция строк здесь для демонстрационных целей — я мог бы просто написать (и более обычно) Value + item.Value, что также хорошо бы объединило их, но я специально хотел, чтобы AppendableStringValue отличался от AppendableIntValue, дабы подчеркнуть, что реализация специфична для каждого типа.

В целом, это было несложно, не так ли? Теперь мы можем передавать обычные экземпляры контейнерных типов в AppendItems(), и всё будет проходить проверку типов. Вот собственно код с использованием всех наработок:

var appender = new Appender();
Console.WriteLine(
    appender.AppendItems(
        new AppendableIntValue(1),
        new AppendableIntValue(2)));
Console.WriteLine(
    appender.AppendItems(
        new AppendableStringValue("1"),
        new AppendableStringValue("2")));

▍ Паттерн type class

С контейнерными классами было весело. Однако с паттерном type class дело обстоит ещё веселее — он более гибкий и, следовательно, более мощный. Но вместо того чтобы принимать мои слова на веру, читайте дальше и убедитесь в этом сами.

Type class — это концепция, возникшая в Haskell. Самый простой способ описать её с точки зрения того, что мы уже знаем на данный момент, заключается в том, что вместо упаковки значений в контейнерные типы AppendableIntValue и AppendableStringValue для выполнения операции над ними, сами типы бы предлагали возможность выполнить операцию над ними. По сути, это есть отделение данных от операции.

Это означает, что нам нужно немного изменить наш метод AppendItems(). Он всё равно принимает два элемента для присоединения, но вместо контейнерного типа теперь требуется класс присоединяемого типа. Наиболее близким описанием в C# был бы следующий код, хоть и невозможный:

class Appender
{
    public T AppendItems<IAppendable<T>>(T a, T b) =>
        IAppendable.Append(a, b);
}

В отличие от Haskell, классы типа не представляют собой существующую структуру в C# и их необходимо моделировать (например, подобно монадам). Обычно это делается через определение интерфейса класса типа, который реализуют для различных конкретных типовых параметров. Позвольте мне предоставить вам немного строк кода, которые демонстрируют эту концепцию во всей её красе:

interface IAppendable<T>
{
    T Append(T a, T b);
}

struct AppendableInt : IAppendable<int>
{
    public int Append(int a, int b) =>
        a + b;
}

struct AppendableString : IAppendable<string>
{
    public string Append(string a, string b) =>
        $"{a}{b}";
}

Видите? Eсть интерфейс IAppendable<T> и две его реализации: AppendableInt и AppendableString.

Одна из крутых вещей о type class заключается в том, что легко расширять библиотеки, не имея доступа к их исходному коду. Например, при желании поддерживать какие-то типы, отличные от int и string, нужно лишь предоставить новые реализации для этих типов. Помимо этого, можно не только предоставить реализации для новых типов, но и переопределить реализации для существующих типов, например, чтобы присоединять целые числа с использованием умножения вместо сложения.

struct AppendableIntMultiplicative : IAppendable<int>
{
    public int Append(int a, int b) =>
        a * b;
}

Дальше встаёт вопрос: каким образом нужно доработать метод AppendItems(), чтобы использовать интерфейс IAppendable<T>? Как вы могли заметить, все реализации интерфейса созданы в виде структур, используя ключевое слово struct. Это позволяет в обобщённой среде создавать экземпляры таких объектов, используя оператор default и zero cost allocation. То есть создание экземпляра присоединяемого type class ничего не стоит! Правда, за это нужно использовать два формальных типовых параметра.

class Appender
{
    public T AppendItems<TAppendable, T>(T a, T b)
        where TAppendable : struct, IAppendable<T> =>
        default(TAppendable).Append(a, b);
}

А вот так это используется.

Console.WriteLine(appender.AppendItems<AppendableInt, int>(1, 2));
Console.WriteLine(appender.AppendItems<AppendableString, string>("1", "2"));

▍ Вывод

Ad-hoc-полиморфизм выражается в языке программирования C# путём перегрузки методов. В зависимости от подставляемого типа, выбирается нужная реализация метода, то есть, компилятор помогает нам в рамках раннего связывания. Чтобы заставить его продолжать помогать нам, имея один универсальный контракт вместо множества перегрузок, существует мощный паттерн type class из мира функционального программирования, который реализуется в C# путём отделения операции от данных.

▍ P.S.

Кстати, помимо этой статьи есть proposal в репозитории dotnet и библиотека language-ext, где можно найти больше интересных примеров:

Ещё я веду Telegram-канал StepOne, куда выкладываю много интересного контента про коммерческую разработку, C# и мир IT глазами эксперта.

Telegram-канал с розыгрышами призов, новостями IT и постами о ретроиграх 🕹️

Теги:

Хабы: