JS ФП тезисы: различия между версиями

Материал из support.qbpro.ru
imported>Supportadmin
imported>Supportadmin
Строка 659: Строка 659:




 
= = =
* * *


С точки зрения программиста '''монада''' -  это абстрактный контейнер с тремя функциями.
С точки зрения программиста '''монада''' -  это абстрактный контейнер с тремя функциями.

Версия от 16:57, 30 мая 2015

Парадигмы (стили) программирования

Языки программирования состоят из операторов, условных операторов, операторов цикла и функций. Наличие условных операторов и операторов циклов являются отличительными чертами "императивных языков программирования". Функциональные языки, как правило, поддерживают только операторы и функции.

Интересно, что ни один из трех языков, Java, C ++ и C, не являются функциональными языками программирования.Язык C - императивный язык программирования, C ++ и Java, императивный / объектно- ориентированные языки программирования. Т.е. существуют три парадигмы (стиля) программирования: императив, объектно-ориентированный и функциональный. Существует еще один, декларативный стиль.

Различия между этими парадигмами заложены в основе. Императив и объектно-ориентированное программирование основано на «машине Тьюринга». Функциональное программирование на базе "лямбда-исчисления", а декларативное программирование основано на «логике первого порядка". Будут рассмотрены различия между, императивным, объектно-ориентированным и функциональном программировании на практическом уровне.

В императивном языке программирования изменение состояния программы достигается путем выполнения серии операторов, и выполняет контроль потока, прежде всего, с помощью условных операторов, операторов цикла и вызовов функций. Программа, приведенная ниже простая реализация метода JavaScript Array.join в императивном стиле. 

function simpleJoin(stringArray) {
    var accumulator = '';
    for (var i=0, l=stringArray.length; i < l; i++) {
        accumulator = accumulator + stringArray[i];
    }
    return accumulator;
}

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

Array.prototype.simpleJoin = function() {
    var accumulator = "";
    for (var i=0, l=this.length; i < l; i++) {
        accumulator = accumulator + this[i];
    }
    return accumulator;
}

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

Теперь запишем функциональную версию этой функции. 

function simpleJoin(stringArray, i, accumulator) {
    if (i === stringArray.length) {
     return accumulator;
    } else {
     return simpleJoin(stringArray, i+1, accumulator+stringArray[i])
    }
}

Первое, что нужно отметить, это то, что мы не используем здесь цикл для итерации. Вместо этого для итерации используется рекурсия. Действительно, это одна из характеристик функционального языка программирования.

Функция называется впервые для данного массива в StringArray, i установлено в 0, и аккумулятор установлен в "". Второй раз функции вызывается из себя с той же StringArray, я установлен на i + 1, и аккумулятор установлен в аккумуляторе + StringArray [i]. И мы продолжаем так же, пока i === stringArray.length, когда мы возвращаемся аккумулятор. Мы будем обсуждать рекурсию подробно позже в более поздней почте. Просто помните, мы использовали рекурсию для этого итерации здесь.

Но осталось кое-что еще от императивного стиля - условный оператор. Functional languages tend to use expressions that evaluate to some value, instead of statements that don't evaluate to anything. Итак, давайте перепишем функцию, чтобы сделать его как функциональные, как можно в JavaScript. 

function simpleJoin(stringArray, i, accumulator) {
    return (i === stringArray.length) ? accumulator :
        simpleJoin(stringArray, i + 1, accumulator + stringArray[i])
}

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

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

Однако в случае JavaScript, как сейчас вы не можете использовать рекурсию для этого итерации. Вы должны продолжать использовать императивный или объектно-ориентированного метода для итерации. Это потому, что JavaScript (пока) не поддерживает "оптимизацию хвостового вызова". Мы будем обсуждать хвостовую рекурсию, и хвостовую оптимизацию, и как обойти эту проблему позже. JavaScript - мультипарадигмальный язык программирования:императивный, объектно-ориентированный и функциональный язык.

Хорошим примером мультипарадигмальной природы JavaScript является метод Array.forEach. Обратите внимание, что все современные браузеры уже реализовали это. Вот простая реализация. 

Array.prototype.forEach = function(callback) {
    for (var i = 0, len = this.length; i < len; ++i) {
        callback(this[i], i, this);
    }
}

В этом коде цикл for императивный код. Добавление в прототип объектно-ориентированное. Передача функции в качестве аргумента другой функции (callback) - функциональный код и эта возможность функционального программирования известна как “higher order function” (функции высшего порядка). В JavaScript, мы принимаем это как должное - передача функции в качестве аргумента. Удивительно этой возможности не было в самых популярных языках, до недавнего времени. например, вы не можете передавать функции в качестве аргументов в Java, хотя вы можете сделать это косвенно, через интерфейсы. То же самое в случае с C, хотя вы можете сделать это косвенно, используя указатели.

Функции первого класса и замыкания

Возможность функционального программирования, реализованые Бренданом Эйчом в JavaScript были first class functions или first class citizens. Это означает что функции рассматриваются как и все другие переменные. Т.е. можно передать их в качестве аргументов функций, вы можете вернуть их в качестве значений от других функций, или вы можете назначить им переменные или структуры данных. Мы видели ранее передачу функции в качестве аргумента. Вот пример присвоения функции переменной. 

function greet(name) {
    console.log("Hello " + name);
}

greet("John"); // "Hello John"

var sayHello = greet;
sayHello("Alex"); // "Hello Alex"

Некоторые теоретики языка программирования рассматривают "анонимные функции" как функции первого класса. Чтобы не отстать, Брендан Эйч выбросил анонимные функции в миксе. Вот анонимная функция в JavaScript. 

function(name) {
    console.log(“Hello “ + name);
}

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

var sayHello = function(name) {
    console.log(“Hello “ + name);
}
sayHello("Jane"); // "Hello Jane"

Что делать, если мы хотим изменить приветствие? Иногда мы хотели бы сказать, "Hi", а не "Hello". Мы могли бы создать обобщенную функцию "createGreeting", которая, в свою очередь "сочинит" еще одну функцию для вас, и вернет новую комбинированную функцию. Так что, если мы бы хотели сказать "Hi" мы вернули функцию, а если мы хотели сказать "Hello" мы бы вернули другую функцию, которая говорит "Hello". Мы можем делать все это потому что JavaScript поддерживает функции первого класса, и мы можем вернуть функцию из другой функций. Вот код. 

function createGreeting(greeting) {
    return function(name) {
        console.log(greeting + " " + name);
    }
}
var sayHi = createGreeting("Hi");
sayHi("Jack"); // "Hi Jack"
var sayHello = createGreeting("Hello");
sayHello("Jack"); // "Hello Jack"

Функция createGreeting принимает greeting в качестве аргумента. Функция возвращает новую анонимную функцию. Однако созданная анонимная функция была создана внутри другой функции createGreeting. Таким образом она является вложенной функцией. Теперь, поскольку наш язык поддерживает анонимные функции, он также будет поддерживать вложенные функции. И когда мы возвращаемся вложенные функции из нашей функции мы столкнуться с другой проблемой.

Анонимная функция принимает аргумент name и печатает в консоли greeting+name.Переменная name является аргументом анонимной функции, и ведет себя так же, как и любой другой переменной, определенной в функции. Другими словами name "локальна" для анонимной функции. Но это не относится к переменной greeting. Она определен в другой функции - createGreeting и, следовательно, "не локальна" для анонимной функции. Однако анонимные функции могут получить доступ к переменной greeting и это называется Лексическая область видимости.

“Scope” (контекст, граница) переменной является её "видимостью" в пределах программы. "Лексическая область" означает, что видимость распространяется для всего текста (кода). Поэтому можно сказать “локальная переменная лексически ограничена” внутри функции, это значит, что локальные переменные функции видны для всего текста внутри функции, даже для кода внутри другой вложенной функции. Это также означает, что когда вы запускаете вложенную функцию вне окружения лексического контекста, the nested functions non local variable will not be visible. И в этом проблема возвращения вложенных функций из другой функции. И в самом деле вот что мы здесь делаем. 

var sayHi = createGreeting("Hi");

В строке выше мы присваиваем возвращенную анонимную функцию переменной SayHi. И вызываем функцию в следующей строке. 

sayHi(“Jack”)

Функция sayHi вызывается вне createGreeting. И переменная greeting недоступна вне createGreeting. Переменные доступные в контексте в котором они были определены, могут быть недоступны в контексте в котором они действительно вызываются. Вот почему языки, такие как C не поддерживает вложенные функции. Для того, чтобы так работать, язык должен поддерживать другой возможность функционального программирования под названием замыкание. JavaScript поддерживает замыкания. Любой язык, который поддерживает функции первого класса и вложенные функции должен поддерживать замыкания.


Замыкание является ссылкой на все не локальные переменные функции. В предыдущем примере greeting была не локальной переменной, а name локальной. Замыкание-это таблица ссылок на все используемые в функции не локальные переменные. Это позволяет функции по-прежнему обращаться к не локальным переменным, даже если функция выходит из контекста этих переменных.

Функторы

Рассмотрим функцию. 

function plus1(value) {  
    return value + 1  
}

Это просто функция, которая принимает целое число и добавляет единицу к нему. Аналогично создадим другую функция Plus2. Мы будем использовать эти функции позже. 

function plus2(value) {  
    return value + 2  
}

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

function F(value, fn) {  
    return fn(value)  
}

F(1, plus1) ==>> 2

Эта функция будет работать хорошо, пока значение передается целое. Попробуем массив. 

F([1, 2, 3], plus1)   ==>> '1,2,31'

Ой. Мы взяли массив целых чисел, добавили целое и получили строку! Не только он это сделал неправильную вещь, мы получили строку передав массив. Другими словами наша программа "испачкала" структуру ввода. Мы хотим чтобы F работала "правильно". Правильно, это "сохранить структуру" на выходе.


Что значит "сохранить структуру"? Наша функция должна "развернуть" исходный массива и получить свои элементы. Затем вызвать переданную функцию для каждого элемента. Затем обернуть возвращаемые значения в новый массив и вернуть его. К счастью JavaScript имеет встроенную такую функцию - map. 

[1, 2, 3].map(plus1)   ==>> [2, 3, 4]

Функция map это функтор!

Функтор - это функция, получающая данные и функцию на входе и сохраняющая структуру данных на выходе.

Подробнее.

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

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

В случае JavaScript, функция filter - функтор, потому что он возвращает массив, однако forEach не функтор, потому что он возвращает undefined, т.е.. forEach не поддерживает структуры.

Функторы пришли из теории категорий в математике, где функторы определяются как "гомоморфизм между категориями". Давайте расшифруем:

  • homo = то же самое
  • morphisms = функции, поддерживающие структуры
  • category = тип

Согласно теории, функция F является функтор, когда для двух компонуемых обычных функции f и g выполняется равенство: 

F(f . g) = F(f) . F(g),

где . (точка) обозначает композицию, т.е функторы должны сохранить композицию.

Поэтому, учитывая это уравнение можно проверить, является данная функция действительно функтором или нет.

Array Functor

Мы видели, что map это функтор, который действует по типу Array. Докажем, что JavaScript функция Array.map это функтор. 

function compose(f, g) {
    return function(x) {return f(g(x))}
}

Композиция функций выполняется из набора функций при помощи вызова следующей функции, с результатами предыдущей функции. Обратите внимание, что наша функция compose работает справа налево. g называется раньше, чем f.

[1, 2, 3].map(compose(plus1, plus2)) ==>> [ 4, 5, 6 ]

[1, 2, 3].map(plus2).map(plus1) ==>> [ 4, 5, 6 ]

Да! Map действительно функтор.

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

String Functor

Можно ли написать функтор для типа строки? Можено развернуть строку? На самом деле можно, если думать о строке как о массиве символов. Все дело в том, как вы смотрите на значения. Также известно, что символы имеют текстовые коды, которые являются целыми числами. Таким образом, использовать plus1 для charcode символа, обернуть их обратно в строку, и вернуть её. 

function stringFunctor(value, fn) {  
    var chars = value.split("")  
    return chars.map(function(char) {  
        return String.fromCharCode(fn(char.charCodeAt(0)))  
    }).join("")  
}

stringFunctor("ABCD", plus1) ==>> "BCDE"

Вы можете начать видеть, как масштабны функторы. Вы можете фактически написать парсер, используя String Functor в качестве основы.

Function Functor

В JavaScript функции являются first class citizens. Это означает, что вы можете обращаться к функции, как к любой другому значению. Можно ли написать функтор для значения типа функции? Да! Но как мы развернуть функцию? Функцию можно развернуть, вызвав её и получив возвращаемое ей значение. Но мы сразу столкнемся с проблемой. Для вызова функции мы должны передать аргументы. Помните, что этот функтор принимает только функцию в качестве аргумета. Мы можем решить эту проблему, вернув новую (анонимную) функцию. Новая (анонимная) функция будет вызвана с аргументами (initial) и мы, в свою очередь вернем анонимную функцию (без аргументов), в которой вызовем оригинальную функцию-аргумент (fn) в качестве параметров которой будет результат первой анонимной функции. (ЖЕСТЬ) 

function functionFunctor(value, fn) {  
    return function(initial) {  
        return function() {  
            return fn(value(initial))  
        }  
    }  
}

var init = functionFunctor(function(x) {return x * x}, plus1)  
var final = init(2)  
final() ==> 5

Наша Function Functor действительно ничего не делает. Но есть несколько моментов. Ничего не происходит, пока вы не вызовете final. Каждая функция находится в состоянии анабиоза, пока вы не вызовете финал. Function Functor формирует основу для более удивительным функциональной вещи как поддержание состояния, продолжение вызова и даже promises. Вы можете написать свои собственные Function Functor, чтобы сделать эти вещи!

MayBe Functor

function mayBe(value, fn) {
    return value === null || value === undefined ? value : fn(value)
}

Да, это правильный функтор. 

mayBe(undefined, compose(plus1, plus2))     ==>> undefined
mayBe(mayBe(undefined, plus2), plus1)       ==>> undefined
mayBe(1, compose(plus1, plus2))             ==>> 4
mayBe(mayBe(1, plus2), plus1)               ==>> 4

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

if (result === null) {
    return null
} else {
    doSomething(result)
}

Identity Function

function id(x) {
    return x
}

Функция выше, что известно как функции идентификации. Это просто функция, которая возвращает значение, переданное ему. Он называется так для тождественности в математическом аппарате.

Мы узнали, что ранее функторы должны сохранить структуру. Однако то, что я не упомянул то, что функторы должны сохранить идентичность. т.е. 

F(value, id) = value

Попробуем для map. 

[1, 2, 3].map(id)    ==>>  [ 1, 2, 3 ]

Типы сигнатур

Тип сигнатуры функции это тип аргумента и возвращаемого значения. Тип сигнатуры для нашей plus1: 

f: int -> int

Тип сигнатуры для map зависит от сигнатуры функции-аргумента. Так если map будет вызвана с функцией plus1, то её сигнатура: 

map: [int] -> [int]

Но типы сигнатур Однако тип сигнатур функции-аргумента не обязательно должны быть такими же, как выше. Могут быть такие функции: 

f: int -> string

из-за которой тип сигнатуры map бутет таким: 

map: [int] -> [string]

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

F: A -> B

Другими словами map может принимать массив целых чисел и возвращть массив строк и это будет по-прежнему функтор.

Монады особый случай функторов чей тип сигнатуры 

M: A -> A

Монады

Рассмотрим map functor из последней главы. Мы могли бы использовать map, чтобы перебрать два массивы добавление каждого элемента первого ко второму. 

var result = [1, 2].map(function(i) {
    return [3, 4].map(function(j) {
       return i + j
    })
})
console.log(result)     ==>>  [ [ 4, 5 ], [ 5, 6 ] ]

Тип сигнатуры внутренней функции: 

f: int -> int

и тип сигнатуры внутреннего map: 

map: [int] -> [int]

Тип сигнатуры внешней функции: 

f: int -> [int]

и тип сигнатуры внешнего map: 

map: [int] -> [[int]]

Это правильное поведение функтора. Но это не то, что мы хотим. Мы хотим, чтобы результат был плоским, как показано ниже. 

[ 4, 5, 5, 6 ]

Array Monad

Для того чтобы это произошло, тип сигнатуры функтора всегда должен быть ограничен 

F: [int] -> [int]

Но функторы не предоставляют такое ограничение. Но монады да. Тип сигнатуры Array Monad: 

M: [T] -> [T]

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

f: T -> [T]

Эта функция известна как lift, потому что она поднимает тип до требуемого. Это также известно как монадическая функция (mf). И исходное значение переданное монаде называется монадическим значением (mv). (Прим. т.е. аргументом mv для монады всегда массив, результат - тоже массив, причем строго того же типа что и аргумент mv.) Вот arrayMonad. 

function arrayMonad(mv, mf) {
    var result = []
    mv.forEach(function(v) {
        result = result.concat(mf(v))
    })
    return result
}

Теперь можно использовать Array Monad для выполнения первого вычисления 

console.log(arrayMonad([1,2,3], function(i) {
    return [i + 1]
}))                                       ==>>  [ 2, 3, 4 ]

Обратите внимание, что наша монадическая функция заворачивает результат в массив [i + 1]. Теперь давайте попробуем для с двумерной задачи с которой мы начали. 

var result = arrayMonad([1, 2], function(i) {
    return arrayMonad([3, 4], function(j) {
        return [i + j]
    })
})
console.log(result)                      ==>>  [ 4, 5, 5, 6 ]

Теперь заметно превосходство монад над функторами.

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

function forEach2d(array1, array2, callback) {
    return arrayMonad(array1, function(i) {
        return arrayMonad(array2, function(j) {
            return [callback(i,j)]
        })
    })
}

И мы можем попробовать эту функцию 

forEach2d([1, 2], [3,4], function(i, j) {
    return i + j
})                                     ==>> [ 4, 5, 5, 6 ]

Обратите внимание, что функция обратного вызова просто обычная функция, так что нам пришлось поднять(lift) её возвращаемые значения [callback(i,j)] в массив. Однако во всех монадах определена функция, чтобы сделать подъем. Её называют mResult. Добавим mResult к объекту функции arrayMonad. Функция concat не эффективна, поскольку она создает новый массив каждый раз. Взамен будем использовать array push. Вот окончательный код для Array Monad. 

function arrayMonad(mv, mf) {
    var result = []
    mv.forEach(function(v) {
        Array.prototype.push.apply(result, mf(v))
    })
    return result
}

arrayMonad.mResult = function(v) {
    return [v]
}

и переписанная forEach2d 

function forEach2d(array1, array2, callback) {
    return arrayMonad(array1, function(i) {
        return arrayMonad(array2, function(j) {
            return arrayMonad.mResult(callback(i,j))
        })
    })
}

Как упражнение попробуйте реализовать forEach3d.

ArrayMonad представляет одноместную функцию и иначе известный как bind или mbind. Для того, что бы функция стала монадой, необходимо определить по крайней мере функции mbind и mresult.

Identity Monad

Identity monad простейшая из всех монад, названная так потому, что это является тождественна mresult. 

function indentityMonad(mv, mf) {
    return mf(mv)
}

identityMonad.mResult = function(v) {
    return v
}

Она не очень полезная, но она правильная.

Maybe Monad

Maybe Monad подобна identity monad, за исключением того, что он не будет вызывать монадическую функцию для значений null или undefined. На самом деле она сводится к функтору mayBe. 

function mayBeMonad(mv, mf) {
    return mv === null || mv === undefined || mv === false ? null : mf(mv)
}

mayBeMonad.mResult = function(v) {
    return v
}

Законы монад

Первый закон монад

M(mResult(x), mf) = mf(x)

Который означает, что mResult должен сделать с x, чтобы превратить х в монадическое значение. М будет разворачивать это монадическое значение перед его применением в монадической функции mf. Давайте проверить это на нашем array monad. 

var x = 4;  
function mf(x) {  
    return [x * 2]  
}
arrayMonad(arrayMonad.mResult(x), mf)  ==>>  [ 8 ]
mf(x)                                  ==>>  [ 8 ]

Второй закон монад

M(mv, mResult) = mv

Это означает, что mBind извлекает значение mv ,а mResult должен будет обернуть назад это значение обратно монадическое. Это гарантирует, что mResult является одноместной функцией. Давайте проверить его. Это эквивалентно сохранению идентичности в случае функтора. 

arrayMonad([1, 2, 3], arrayMonad.mResult)  ==>>  [ 1, 2, 3 ]

Третий закон монад

M(M(mv, mf), mg)) =  M(mv, function(x){return M(mf(x), mg)})

Не имеет значения, если вы применяете mf к mv, а затем к mg, или применять mv к монадической функции, представляющей композицию mf и mg. 

function mg(x) {
    return [x * 3]
}
arrayMonad(arrayMonad([1, 2, 3], mf), mg)  ==>>  [ 6, 12, 18 ]
arrayMonad([1, 2, 3], function(x) {
    return arrayMonad(mf(x), mg)
})                                         ==>>  [ 6, 12, 18 ]

doMonad

Мы знаем, что монадическая функция принимает значение и возвращает монадическое значение. Монада принимает монадическое значение и монадическую функцию и возвращает монадическое значение. Что делать, если монадическая функция вызывает монаду с монадическим значением и самой себя, и возвращает результат? Это было бы правильная монадическая функция, потому что она возвращает монадическое значение.

Функция doMonad делает именно это. Это передает в монаду массив монадических значений и callback в качестве аргументов. Это определяет монадическую функцию как рекурсивно вызывающую монаду для каждого монадического значения и саму себя. Цикл заканчивается, когда не остается монадических значений. Она возвращает callback с каждым развернутым значением монадических значений.Сallback cb каррируется в замыкании, называемой оберткой и становится видимой для mf. Каррирование или карринг (англ. currying) в информатике — преобразование функции от многих аргументов в функцию, берущую свои аргументы по одному. 

function curry(fn, numArgs) {
    numArgs = numArgs || fn.length
    return function f(saved_args) {
        return function() {
            var args = saved_args.concat(Array.prototype.slice.call(arguments))
            return args.length === numArgs ? fn.apply(null, args) : f(args)
        }
    }([])
}

function doMonad(monad, values, cb) {
    function wrap(curriedCb, index) {
        return function mf(v) {
            return (index === values.length - 1) ?
                monad.mResult(curriedCb(v)) :
                monad(values[index + 1], wrap(curriedCb(v), index + 1))
        }
    }
    return monad(values[0], wrap(curry(cb), 0))       
}
doMonad(arrayMonad, [[1, 2], [3, 4]], function(x, y) {
    return x + y
})                           //==>> [ 4, 5, 5, 6 ]

Теперь нет необходимости в функции forEach2d , которую мы написали ранее! И лучшее еще впереди!

Пример использования doMonad для массивов

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

function FOR() {
    var args = [].slice.call(arguments)
        callback = args.pop()
    return doMonad(arrayMonad, args, callback)
}

FOR([1, 2], [3, 4], function(x, y) {
    return x + y
})                          //==>> [ 4, 5, 5, 6 ]
FOR([1, 2], [3, 4], [5, 6], function(x, y, z) {
    return x + y + z
})                          //==>> [ 9, 10, 10, 11, 10, 11, 11, 12 ]

Удивительно!

State Monad

Ранее рассматривался function fucntor, который принимал значения типа function. Аналогично монадические значения могут также быть функциями. Однако важно различать монадические функции и монадические значения, являющиеся функциями. Тип сигнатуры монадической функции 

mf: v -> mv

т.е. принимает значение и поднимает его до монадического значения. Вспомним, что монадическое значение само по себе функция. Поэтому mf вернет функцию mv.

Типы сигнатуры монадического значения, являющегося функцией, зависит от того, что делает сама эта функция. В случаеs state monad тип сигнатуры монадического значения: 

mv: state -> [value, new state]

Функция в монадическом значении принимает состояние state и возвращает массив, содержащий данные value и новое состояние new state. Состояние state может быть любого типа: array, string, integer и т.д.

StateMonad принимает монадическое значение и монадическое функцию и возвращает функцию, для которой мы должны задать исходное состояние. Исходное состояние передается mv, которое возвращает значение. Затем вызывается mf с этим значением и mf возвращает монадическое значение, которое является функцией. Мы должны вызвать эту функцию с NewState. Уф! 

function stateMonad(mv, mf) {  
    return function(state) {  
        var compute = mv(state)  
        var value = compute[0]  
        var newState = compute[1]  
        return mf(value)(newState)  
    } 
}

mResult для state monad: 

stateMonad.mResult = function(value) {  
    return function(state) {  
            return [value, state];  
    }  
}

(Примечание о применении: проверка на ошибку)

Parser Monad

Парсер- это функция, которая принимает строку, анализирует её по некоторым критериям и возвращает совпавшую часть и остаток. Позволяет написать тип сигнатуры функции. 

parser: string -> [match, newstring]

Это выглядит как монадическое значение state monad, с ограничением типа state строкой. Но это еще не все, анализатор вернется NULL, если строка не соответствует этим критериям. Так что давайте напишем Parser Monad, чтобы удивить разницу. 

function parserMonad(mv, mf) {  
    return function(str) {  
        var compute = mv(str)
        if (compute === null) {
            return null
        } else {
            return mf(compute[0])(compute[1])
        }  
    } 
}

parserMonad.mResult = function(value) {  
    return function(str) {  
        return [value, str];  
    }  
}

Как мы видели ранее, монады требует, чтобы вы определить по крайней мере две функции, mBind (саму функцию монаду) и mResult. Но это еще не все. При желании вы можете определить еще две функции, mZero и Mplus.

mZero является определение «Nothing» для монады. например. для arrayMonad, mZero будет [ ]. В случае анализатора монады mZero определяется следующим образом. (mZero должен иметь тот же тип сигнатуры монадического значения). 

parserMonad.mZero = function(str) {
    return null
}

Mplus это функция, которая принимает монадические значения в качестве аргументов, и игнорирует mZero среди них. Как принятые значения обрабатываются зависит от каждой монады. Для parser monad, mZero будет взять набор анализаторов (монадические значения Parser монады) и вернет значение, возвращенное первым парсером который вернет значение не mZero (NULL). 

parserMonad.mPlus = function() {
    var parsers = Array.prototype.slice.call(arguments)
    return function(str) {
        var result, i
        for (i = 0; i < parsers.length; ++i) {
            result = parsers[i](str)
            if (result !== null) {
                break;
            }
        }
        return result
    }
}

Continuation Monad

The continuation monad takes a bit to understand. In the chapter on function composition we saw that the composition of two functions f and g is given by 

(f . g) = f(g(x))

f is known as the continuation of g.

We also know that we can wrap values in a function by creating a closure. In the example below the inner function has a value wrapped in its closure. 

function(value) {
    return function() {
        // value can be accessed here
    }
}

The monadic value of a continuation monad, is a function that takes a continuation function and calls the continuation with its wrapped value. This is just like the inner function above called with a continuation function and we we can write it as 

function(continuation) {
    return continuation(value)
}

The mResult function of monad takes a value and lifts it to a monadic value. So we can write the mResult function for the continuation monad. 

var mResult = function(value) {
    return function(continuation) {
        return continuation(value)
    }
}

So mResult is a function that takes a value, returns a monadic value which you call with a continuation.

The continuation monad itself or mBind is more complicated. 

var continuationMonad = function(mv, mf) {
    return function(continuation) {
         // we will add to here next
    }
}

First it will return a function you need to call with a continuation. Thats easy. But how can it unwrap the value inside mv? mv accepts a continuation, but calling mv with the continuation will not do. We need to unwrap the value in mv and call mf first. So we need to trick mv into giving us the value first by calling it with our own continuation thus. 

mv(function(value) {
    // gotcha! the value
})

We can add this function to the code above. 

var continuationMonad = function(mv, mf) {
    return function(continuation) {
        return mv(function(value) {
            // gotcha! the value
        })
    }
}

Now all we have to do is call mf with the value. We know a monadic function takes a value and returns a monadic value. So we call the returned monadic value from mf with the continuation. Phew! Here is the complete code for the continuation monad. 

var continuationMonad = function(mv, mf) {
    return function(continuation) {
        return mv(function(value) {
            return mf(value)(continuation)
        })
    }
}
continuationMonad.mResult = function(value) {
    return function(continuation) {
        return continuation(value)
    }
}

Дополнительная информация

Чистые и Грязные функции

То, что мы называем функциями в C++ или любом другом императивном языке, не то же самое, что математики называют функциями. Математическая функция — просто отображение значений в значения.

Мы можем реализовать математическую функцию на языке программирования: такая функция, имея входное значение будет рассчитать выходное значение. Функция для получения квадрата числа, вероятно, умножит входное значение само на себя. Она будет делать это при каждом вызове, и гарантированно произведет одинаковый результат каждый раз, когда она вызывается с одним и тем же аргументом. Квадрат числа не меняется с фазами Луны.

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

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


=

С точки зрения программиста монада - это абстрактный контейнер с тремя функциями.

  • map — заменяет содержимое контейнера без изменения самого контейнера. Заменяем каждый гвоздь в коробке шурупом, каждый int в массиве float-ом — так map и работает.
  • unit — берет элемент и возвращает контейнер с одним этим элементом. Делаем из гвоздя коробку с одним гвоздем. Делаем из int массив из одного int.
  • join — уменьшает вложенность контейнеров — из коробки коробок гвоздей делает коробку с гвоздями (из массива массивов int-ов — массив int-ов). Ну или из коробки коробок коробок гвоздей делаем коробку коробок гвоздей. Это уже сложная концепция, доступная только программистам и более абстрактно развитым товарищам; обычный человек будет обескуражен тем, как в одну коробку могли поместиться несколько точно таких-же коробок. Впрочем, простая замена коробок коробок на мешки мешков или пакеты пакетов позволяет совершить абстрактно-теоретико-категориальный прорыв.

Монада - это интерфейс с двумя методами:

  • "поднять в монаду". Давайте называть этот метод 'pure'. Функция от одного аргумента. На входе какое-то значение, на выходе это же значение, но помеченое другим типом.
  • "применить функцию к значению в монаде" или "совершить действие". В энергичном языке, думаю, уместо было бы название 'apply'. Функция от двух аргументов. На входе монадическое значение (полученное из первой функции) и собственно функция-действие, которое нужно применить к первому аргументу. На выходе новое монадическое значение, то есть изменённое функцией-действитем. Ну, эта особенность с "на выходе новое", она в общем-то нужна в языках с одним присваиванием, в остальных можно передать монадическое значение по ссылке и поменять его.

Всё остальное относится к конкретным монадам и рассматривать их нужно отдельно.

Собственно, весь смысл в двух вещах:

  1. новый тип даёт инкапсуляцию
  2. явная передача функции-действия развязывает (decoupling) их от собственно процесса применения действия. И основная фишка в том, что этот, своего рода, late binding может происходить не в рантайме (как в технологии COM, если знаете), а во время компиляции. С хорошей поддержкой полиморфизма в системе типов можно:
  • гибко определять как будут выполняться одинаковые действия в разных монадах
  • повторно использовать однажды определённые действия в новых монадах.
Источник — https://support.qbpro.ru/index.php?title=JS_ФП_тезисы&oldid=1736