Уроки абстракции: чему ПП может научить ООП

Абстракция — это один из величайших призрачных инструментов, когда-либо изобретенных людьми, для представления, расшифровки и изображения мира. — Джерри Зальц

Я хочу приблизиться к истине как можно ближе, и поэтому я абстрагирую все, пока не достигну фундаментального качества объектов. — Пит Мондриан

Одной из наиболее рекомендуемых «лучших практик» в программировании является принцип СУХОЙ: не повторяйте себя . Для реализации этого принципа могут использоваться многие методы: инкапсуляция, параметризация, инверсия управления и многое другое. Одним из этих методов является абстракция, и одно из основных различий между функциональным программированием (FP) и объектно-ориентированным программированием (ООП) заключается в способе применения абстракции. Обычной практикой в ​​ООП является ограничение абстракции строгим полезным минимумом для рассматриваемой проблемы. В ООП преждевременная абстракция часто считается ошибкой, во многом как преждевременная оптимизация.

В FP, с другой стороны, абстракция обычно проталкивается настолько далеко, насколько это возможно. Каждая проблема разбита на ряд простейших возможных функций, которые затем составляются для построения решения проблемы. Выявление этих абстракций, как правило, является наиболее важной частью решения проблемы. На самом деле, программисты на FP часто тратят больше времени, пытаясь найти проблему, которую они должны решить, чем ее решение. И, конечно же, обычно кажется, что эти функции одинаковы при переходе от одной проблемы к другой. Только то, как они составлены, отличается. Это причина, почему абстракция является одним из наиболее ценных методов, используемых программистами FP.

В этой статье мы сравним, как ООП и FP будут обрабатывать абстракцию в конкретной простой задаче: вычислении суммы целых чисел от 1 до произвольного значения n . Задача настолько проста, что ее можно решить с помощью императивного программирования, и, кажется, нет ничего интересного, чему ее можно научить. Вот как это можно сделать в императивной Java:

static int sum(int n) { int sum = 0; for (int i = 1; i <= n; i++) { sum += i; } return sum; } 

Кажется, что не существует более простого и эффективного способа сделать это. Однако для программиста ООП, а также для программиста на FP интересная часть проблемы еще впереди. Но каждый из этих программистов, вероятно, пойдет по-разному. Мы также могли бы заметить (и продемонстрировать!), Что сумма n первых целых чисел равна (n * (n + 1) / 2) . Как вы увидите, это пошло бы в другую сторону, к как можно меньшей абстракции.

Абстрагирование вычислений в объектно-ориентированном программировании

Программисты FP и OOP сразу заметят одну возможную абстракцию, которая является операцией, применяемой для построения результата. Здесь мы добавляем значения для построения результата. Что если нас попросят вернуть товар вместо суммы?

В ООП существует два очевидных способа абстрагировать вычисления: использование шаблона стратегии или инверсия управления ( IoC ).

Использование шаблона стратегии

Java-способ абстрагировать вычисления в форме, которая может быть передана программе, состоит в создании объекта, содержащего методы, выполняющие вычисления. (Если вам повезло, и есть только один метод, лямбда-выражения могут упростить это, но подход остается тем же.) Чтобы это было абстракцией, мы должны превратить абстрактную часть в интерфейс, а конкретную часть — в реализация:

 static int compute(int n, Computer computer) { int result = computer.identity(); for (int i = 1; i <= n; i++) { result = computer.compute(result, i); } return result; } interface Computer { int compute(int a, int b); int identity(); } static class Adder implements Computer { @Override public int compute(int a, int b) { return a + b; } @Override public int identity() { return 0; } } static class Multiplier implements Computer { @Override public int compute(int a, int b) { return a * b; } @Override public int identity() { return 1; } } public static void main(String... args) { System.out.println(compute(5, new Adder())); System.out.println(compute(5, new Multiplier())); } 

Здесь мы абстрагировали вычисления и теперь можем повторно использовать программу с другой стратегией вычисления, такой как умножение. Обратите внимание, что мы помещаем элемент identity , используемый в качестве начального значения для вычислений, в различные реализации Computer , поскольку он будет отличаться для разных типов вычислений ( 0 для сложения, 1 для умножения).

Честно говоря, это не кажется большим улучшением, и многие программисты не видят интереса отсоединения вычислений от итерации. Кроме того, этот подход не учитывает, что у нас фактически есть две вложенные возможные абстракции: сама операция (сложение или умножение) и концепция тождественности определенного значения, которое связано с операцией и не меняет значение для его получения. связан через эту операцию. Значение 0 — это идентификатор для сложения, а 1 — это идентификатор для умножения. Многие другие операции имеют значение идентичности. Пустая строка — это идентификатор для конкатенации строк, а пустой список — это идентификатор для конкатенации списков.

Конечно, мы могли бы снова использовать шаблон Стратегии для идентификации, но это создало бы действительно грязное решение, и большинство программистов, вероятно, подумали бы, что использование интерфейса с двумя методами является достаточной абстракцией. Как вы увидите позже, программисты на FP так не думают.

Использование инверсии контроля (IoC)

Другой, более объектно-ориентированный метод абстрагирования вычислений называется инверсией управления . Решение паттерна стратегии использует композицию для решения проблемы, тогда как инверсия управления основана на наследовании.

С помощью этой техники мы создаем абстрактный класс, который выполняет цикл, вызывая абстрактный метод для получения начального значения и еще один для вычисления:

 static abstract class Computer { public final int compute(int n) { int result = identity(); for (int i = 1; i <= n; i++) { result = doCompute(result, i); } return result; } abstract int doCompute(int a, int b); abstract int identity(); } static class Adder extends Computer { @Override public int doCompute(int a, int b) { return a + b; } @Override int identity() { return 0; } } static class Multiplier extends Computer { @Override public int doCompute(int a, int b) { return a * b; } @Override int identity() { return 1; } } public static void main(String... args) { Computer adder = new Adder(); System.out.println(adder.compute(5)); Computer multiplier = new Multiplier(); System.out.println(multiplier.compute(5)); } 

 @FunctionalInterface interface Computer { int compute(int a, int b); } 

 static int compute(int n, int identity, IntBinaryOperator computer) { int result = identity; for (int i = 1; i <= n; i++) { result = computer.applyAsInt(result, i); } return result; } 

 public static void main(String... args) { System.out.println(compute(5, 0, (a, b) -> a + b)); System.out.println(compute(5, 1, (a, b) -> a * b)); } 

 static int[] range(int n) { int[] result = new int[n]; for (int i = 0; i < n; i++) { result[i] = i + 1; } return result; } 

 static int fold(int[] collection, int identity, IntBinaryOperator computer) { int result = identity; for(int i : collection) { result = computer.applyAsInt(result, i); } return result; } 

 static int compute(int n, int identity, IntBinaryOperator computer) { return fold(range(n), identity, computer); } public static void main(String... args) { System.out.println(compute(5, 0, (a, b) -> a + b)); System.out.println(compute(5, 1, (a, b) -> a * b)); } 

 public static void main(String... args) { System.out.println(IntStream.rangeClosed(1, 5).reduce(0, (a, b) -> a + b)); System.out.println(IntStream.rangeClosed(1, 5).reduce(1, (a, b) -> a * b)); } 

 1 1 + 2 = 3 1 + 2 + 3 = 6 1 + 2 + 3 + 4 = 10 1 + 2 + 3 + 4 + 5 = 15 

 private static List<Integer> triangular(int length) { List<Integer> result = new ArrayList<>(); for(int i = 1; i <= length; i++) { // <1> result.add(result.size() == 0 ? i : result.get(result.size() - 1) + i); // <2> } return result; } public static void main(String... args) { System.out.println(triangular(5)); } 

 private static <T> T last(List<T> list, T defaultValue) { return list.size() == 0 ? defaultValue : list.get(list.size() - 1); } 

 private static List<Integer> triangular(int length) { List<Integer> result = new ArrayList<>(); for(int i = 1; i <= length; i++) { result.add(last(result, 0) + i); } return result; } 

 private static List<Integer> range(int start, int end) { List<Integer> result = new ArrayList<>(); for(int i = start; i <= end; i++) { result.add(i); } return result; } 

 private static <T, U> U fold( Iterable<T> elements, U initial, BiFunction<U, T, U> f) { U result = initial; for (T t : elements) { result = f.apply(result, t); } return result; } 

 private static List<Integer> triangular(int length) { return fold(range(1, length), new ArrayList<>(), (a, b) -> { a.add(last(a, 0) + b); return a; }); } 

 private static <T> List<T> emptyList() { return new ArrayList<>(); } private static <T> List<T> append(List<T> list, T t) { list.add(t); return list; } 

 private static List<Integer> triangular(int length) { return fold( range(1, length), emptyList(), (a, b) -> append(a, last(a, 0) + b)); } 

 private static List<Integer> scan( int length, Integer z, BinaryOperator<Integer> op) { return fold( range(1, length), emptyList(), (a, b) -> append(a, op.apply(last(a, z), b))); } private static List<Integer> triangular(int length) { return scan(length, 0, (a, b) -> a + b); } private static List<Integer> factorial(int length) { return scan(length, 1, (a, b) -> a * b); } 

 private static <T> List<T> scan( Iterable<T> elements, T z, BinaryOperator<T> op) { return fold( elements, emptyList(), (a, b) -> append(a, op.apply(last(a, z), b))); } 

 private static List<Integer> triangular(int length) { return scan(range(1, length), 0, (a, b) -> a + b); } private static List<Integer> factorial(int length) { return scan(range(1, length), 1, (a, b) -> a * b); } 

 private static <T, U> List<U> scanLeft( Iterable<T> elements, U z, BiFunction<U, T, U> f) { return fold( elements, emptyList(), (a, b) -> append(a, f.apply(last(a, z), b))); } private static List<Integer> triangular(int length) { return scanLeft(range(1, length), 0, (a, b) -> a + b); } private static List<Integer> factorial(int length) { return scanLeft(range(1, length), 1, (a, b) -> a * b); } 

 private static List<String> constructString(List<Character> characters) { return scanLeft(characters, "", (s, c) -> s + c); } System.out.println(constructString(Arrays.asList( 'H', 'e', 'l', 'l', 'o', ',', ' ', 'W', 'o', 'r', 'l', 'd', '!'))); 

 [H, He, Hel, Hell, Hello, Hello,, Hello, , Hello, W, Hello, Wo, Hello, Wor, Hello, Worl, Hello, World, Hello, World!] 

 private static <T> List<List<T>> starts(List<T> list) { return scanLeft(list, emptyList(), (lst, elem) -> append(lst, elem)); } System.out.println(starts(Arrays.asList(1, 2, 3, 4, 5))); 

 [[1], [1, 2], [1, 2, 3], [1, 2, 3, 4], [1, 2, 3, 4, 5]] 

 [[1, 2, 3, 4, 5], [1, 2, 3, 4, 5], [1, 2, 3, 4, 5], [1, 2, 3, 4, 5], [1, 2, 3, 4, 5]] 

 private static <T> List<T> append(List<T> list, T t) { List<T> result = new ArrayList<>(list); result.add(t); return result; }