Знакомство с функциональным каррингом в Swift

znakomstvo s funkczionalnym karringom v swift

Содержание статьи

Когда вы слышите слово «карри», прежде всего, что, по-видимому, приходит на ум, это отличная часть индийской кухни. Индийцы используют для приготовления блюд очень сложное сочетание специй. Они добавляют все ингредиенты один за другим, чтобы получить отличную карри.

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

Но в любом языке программирования мы можем легко объявить функцию, принимающую несколько аргументов одновременно, и большинство программистов привыкли к этому. Зачем использовать карри?

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

Он использует возможность многократного использования кода и чем меньше кода вам придется написать, тем меньше у вас будет ошибок! Вы можете представить карринг/некарринг как способ утверждать устранение и внедрение правил для конструктивной логики. Это обеспечивает связь с более элегантной мотивацией того, чем он существует.

Программисты могут объявить каждую функцию двумя эквивалентными способами. В карри функция принимает только один аргумент и возвращает функцию. Затем возвращенная функция принимает один довод и возвращает окончательный результат.

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

Давайте сначала рассмотрим более популярный стиль определения функции:

func multiply1(_ x: Int, _ y: Int) -> Int {
  return x*y
}

Вышеприведенная функция принимает два аргумента и возвращает результат их умножения.

Теперь мы можем определить ту же функцию другим способом:

func multiply2(_ x: Int) -> (Int) -> Int {
  return { $0 * x }
}

Разница между этими двумя функциями заключается в их стиле вызова:

multiply1(3, 4) //returns 12
multiply2(3)(4) //returns 12

В первой функции мы передаем оба аргумента одновременно. Во второй функции мы передаем первый аргумент (который сам возвращает функцию), а затем передаем второй аргумент.

На самом деле, обе функции здесь выполняют то же самое. Эти два примера показывают, как мы всегда можем превратить функцию, принимающую несколько аргументов одновременно, в серию функций, принимаемых по одному аргументу за раз. Это процесс каррирование. Поэтому умножить2 функция является карри версией умножить1.

Мы можем представить вторую функцию как цепочку функций следующим образом:

//Benefit: 1
multiply2(3)(multiply2(4)(multiply2(5)(6))) //returns 360
//Benefit: 2
let multiplier = multiply2(2)
let integerList = 1...100
let x = integerList.map(multiplier) //returns [2, 4, 6, 8, 10, 12 ...]

Вот некоторые из преимуществ функции карри. Вы всегда можете объединить операции с помощью нескольких простых шагов. Прекрасно, правда?

Давайте рассмотрим другой пример:

Теперь давайте создадим a MorningWalk для воскресенья и добавьте к нему 100 шагов.

Итак, в основном здесь мы называем addSteps() метод экземпляра в самом экземпляре.

Но мы также можем сделать то же самое в кари-путь, как это:

Это делает то же, что мы делали выше. Во-первых, мы назначаем addSteps и minusSteps методы на две разные переменные. На этом этапе мы не вызываем никаких функций. Мы только что сделали ссылку на функции, как и указатели на функции. На следующем шаге мы фактически вызываем функции, хранящиеся внутри stepIncreaser и StepDecreaser.

теперь, stepIncreaser принимает один аргумент, который есть MorningWalk экземпляр и возвращает функцию, тип которой (Int) -> (). Итак, возвращенная функция принимает аргумент типа Int и ничего не возвращает. Здесь возвращена функция and addStepфункция s() имеет одинаковый тип сигнатуры метода. Эта же концепция касается tон шагDecreaсер.

Итак, наконец-то мы можем сказать, что метод экземпляра в Swift также является методом типа. Он принимает экземпляр класса в качестве аргумента и возвращает функцию, которая затем принимает другие аргументы и возвращает/обновляет окончательный результат.

Мы также можем вызвать следующие методы так:

Вывод

В этой статье мы имели функцию с более чем одним аргументом. Мы превратили его в функцию, которая всегда принимала один аргумент за раз, в результате чего создавалась другая функция, пока не осталось аргументов. Тогда это дало нам окончательный результат. Таким образом, мы можем сказать, что функции – это не что иное, как обычные значения, которые могут создаваться и возвращаться другими функциями.

Теперь у вас есть что-то новое и интересное, что можно попробовать в ежедневных задачах программирования!

Добавить комментарий

Ваш адрес email не будет опубликован.