Значения, функции и Box

f1 : T => R
f2 : (T1, T2, T3, ..., TN) => R

Box.box : T => Box<T>
//применение
val boxed : Box<Int> = Box.box(3)

Functor

class Box<T> {
  // какая-то реализация семантики Box
  
  //Применение функции "внутри" box 
  def map<R>(fn : T => R) : Box<R>
}

// Применение к асинхронной операции
val operation : Async<Image> = loadImage(...);
operation.map(image => alert("Она загрузилась!"));

class Box<T> {
  static def<T, R> map(fn : T => R, box : Box<T>) : Box<R>
}

//Применение к асинхронной операции:
val operation : Async<Image> = loadImage(...);
Async.map(image => alert("Оно загрузилось"), operation);

//Или более реалистичный пример, с дополнительными функциями
val operation : Async<Image> = loadImage(...);
Async.apply(showImage, operation);

def showImage(image : Image) : void {
  //....
}

Applicatives

val imageOp : Async<Image> = loadImage(...);
val partnerData : Async<SpamData> = loadPartnerData(...);

def showUI(image : Image, data : SpamData) : void {
  //...
}

Box.map(showUI, imageOp, partnerData);

class Box<T> {
  static def map<T1, T2, T3, ..., TN, R>(
    fn : (T1, T2, T3, ..., TN) => R,
    a1 : Box<T1>, a2 : Box<T2>, a3 : Box<T3>, ..., an : Box<TN>) : Box<R>
}

// Вполне реальный для JS API:
// Такими могли бы быть Promise! 
// И Promise достаточно легко допиливаются до этого состояния.
var imageOp = loadImage(...);
var spamData = loadPartnerData(...);
Aysnc.apply(showUI, [imageOp, spamData]);

// Сравните с обычным (синхронным) применением:
var image = getSomeImage();
var spamData = getSomeData();
showUI(image, spamData);

fn <$> arg1 <*> arg2 <*> arg3

Монады

var partnerData : Async<Int> = loadPartnerData(...);
var otherPartnerData : Async<String> = loadPartnerData(...);
var evenMoreData : Async<String> = loadEvenMoreData(...);

def loadDependentData(d1 : Int, d2 : String, d3 : String) : Async<Image> {
  final String imageUrl = d2 + d1 + d3;
  return loadImage(imageUrl);
}

class Box<T> {
  static def mmap<T1, T2, T3, ..., TN, R>(
    fn : (T1, T2, T3, ..., TN) => Box<R>,
    a1 : Box<T1>, a2 : Box<T2>, a3 : Box<T3>, ..., an : Box<TN>) : Box<R>
}

// Применение!
// И это тоже стоило бы сделать в Promise, но...
var partnerImage : Box<Image> = Async.mapply(loadDependentData, partnerData, otherPartnerData, evenMoreData);
Async.apply(showUI, partnerImage);

Всё вместе

// function application
var a : T1 = ..., b : T2 = ..., c : T3 = ...;
def f(x1 : T1, x2 : T2, x3 : T3) : R
var r : R = f(a, b, c);

// Functor
// Только для одноаргументных функций
var a : Box<T1> = ...;
def f(x1 : T1) : R
var r : Box<R> = Box.apply(f, a);

// "Applicative"
var a : Box<T1> = ..., b : Box<T2> = ..., c : Box<T3> = ...;
def f(x1 : T1, x2 : T2, x3 : T3) : R
var r : Box<R> = Box.apply(f, a, b, c);

// "Monad"
var a : Box<T1> = ..., b : Box<T2> = ..., c : Box<T3> = ...;
def f(x1 : T1, x2 : T2, x3 : T3) : Box<R>
var r : Box<R> = Box.mapply(f, a, b, c);

Немного практики

ARK>Если язык ленивый — то не факт, что вложенный вызов будет исполнен раньше, чем невложенный.

DO(Monad,
    (x, unit(1))
    (y, unit(2))
    (z, DO(Monad,
        (x, unit(5))
        (_, unit(x - 2))
    ))
    (_, unit(x + y + z))
)

   return from v1 in a
          from v2 in b
          select v1+v2;

return a.SelectMany(v1 => b.SelectMany(v2 => v1+v2))

Maybe<int> Add3(Maybe<int> a, Maybe<int> b)
XC>{
XC>   return a+b;
XC>}

from v1 in a
from v2 in f(v1)
select g(v1,v2)

var a = b + c;

var a = add(b, c)

ARK>Как раз о чем я в первом посте и написал.

ARK>Каким? Они не могут причинить вред программисту, должны ему подчиняться и заботиться о своей корректности?

//Ручками
Maybe<int> Add1(Maybe<int> a, Maybe<int> b)
{
   if(!a.HasValue || !b.HasValue) return Maybe.None<int>();
   return Maybe.Return(a.Value+b.Value);
}

//Через bind
Maybe<int> Add2(Maybe<int> a, Maybe<int> b)
{
   return Bind(a, v1 => Bind(b, v2 => Maybe.Return(v1+v2)));
}

//Через монадный синтаксис
Maybe<int> Add3(Maybe<int> a, Maybe<int> b)
{
   return from v1 in a
          from v2 in b
          select v1+v2;
}

ARK>Да, вот это правильный вариант.

from v1 in a
from v2 in b
select v1+v2

ARK>>Если язык ленивый — то не факт, что вложенный вызов будет исполнен раньше, чем невложенный.

putStrLn "abc" >> putStrLn "def"

m >> n     =      m >>= \_ -> n

ARK>Ввод-вывод можно и безо всяких монад выполнять последовательно в том порядке, в каком он записан.

stack.push(a)
...
stack.pop()

var stack1 = push(stack0, a)
...
var (a,stackN) = pop(stackN-1)

putStrLn "abc" >>= (\unused_parameter -> putStrLn "def")

getLine >>= (\string_from_user -> putStrLn string_from_user)

getLine >>= 
    (\first_string ->
        getLine >>=
            (\second_string ->
                putStrLn first_string ++ second_string
            )
    )

do
    first_string <- getLine
    second_string <- getLine
    putStrLn first_string ++ second_string

ARK>Нда... По-моему, код с проверками выглядит гораздо чище, чем это.

ARK>Посмотрел. Выглядит как ужасная грязь — даже на маленьких кусочках кода.

function main(){
    async(function* (){
        console.log('begin');
        console.log(yield sleep(100)); 
        console.log(yield sleep(200));
        console.log(yield sleep(300));
        console.log(yield sleep(400));
        console.log(yield sleep(500));
        console.log(yield sleep(600));
        console.log(yield sleep(700));
        console.log('end');
        yield sleep(800)
        return 'very end';
    }).then(function(value){
        console.log(value);    
    });
}

function async(coroutineFn){
    var coroutine = coroutineFn();

    function next(previous){
        var result = coroutine.next(previous);
        var current = Promise.resolve(result.value);

        if(result.done)
            return current;
        
        return current
                .then(function(value){
                    return next(value);
                });
    }

    return next(void 0);
}

function sleep(delay){
    return new Promise(function(succeed, failure){
        setTimeout(function(){
            succeed(delay);
        }, delay);
    });
}

main();

The general monad concept includes any situation where the programmer wants to carry out a purely functional computation while a related computation is carried out on the side.

а дальше идут monad transformers, которые представляют не просто одну монаду, а способ добавить к монаде новую функциональность. т.е. ввам не придётся например выбирать между Error monad (прекразает вычисление при возбуждении ошибки), State monad, Parsing monad (сохраняет текущее состояние бибилиотеки парсинга), а вы их можете объединить вместе, наслоив одну на другую и использовать всю необходимую вам функциональность в общем коде. более того, вы можете добавить в этот бутерброд новые монады по мере развития программы, а эта запись do с вызываемыми в ней процедурами останется неизменной

ARK>Вы взорвали мне мозг.

var a = GetUserInput();
var b = GetUserInput();
return a - b;

f = f1 <*> f2

 f <*> id = f = id <*> f

<*> f1 f2 = 
    a =>  {
            var mb = f1 (a);
            return bind(mb, f2);
          };

f <*> return = f = return <*> f .

Maybe<int> Add3(Maybe<int> a, Maybe<int> b)
{
   return a+b;
}

G>//Ручками
G>Maybe<int> Add1(Maybe<int> a, Maybe<int> b)
G>{
G>   if(!a.HasValue || !b.HasValue) return Maybe.None<int>();
G>   return Maybe.Return(a.Value+b.Value);
G>}

G>//Через bind
G>Maybe<int> Add2(Maybe<int> a, Maybe<int> b)
G>{
G>   return Bind(a, v1 => Bind(b, v2 => Maybe.Return(v1+v2)));
G>}

G>//Через монадный синтаксис
G>Maybe<int> Add3(Maybe<int> a, Maybe<int> b)
G>{
G>   return from v1 in a
G>          from v2 in b
G>          select v1+v2;
G>}
G>

T Add<T>(T a, T b) where T : IAddable<T>
{
   return a + b;
}

implementation IAddable<int> for Maybe<int>
{
  ...
}

from v1 in a
from v2 in f(v1)
select g(v1, v2)

Maybe<int> Add3(Maybe<int> a, Maybe<int> b)
{
   return a+b;
}

add : Maybe Int -> Maybe Int -> Maybe Int
add x y = [| x + y |]

add x y = return (!x + !y)

G>from v1 in a
G>from v2 in f(v1)
G>select g(v1, v2)
G>

  g(a, f(a));

   return from v1 in a
          from v2 in a
          select v1+v2;

var
  val: Integer;
begin
  if condition then
    val = 3;
  else
    val = 5;
  use(val);
end

begin
  use(if condition then 3 else 5 end);
end

I>var a = add(b, c)
I>

Now you don't know what you have. Could be an int, a string, a list or a problem.

I>А ты таки попробуй Без этого сложновато рассуждать про монады.

foreach (var item in arr)
{
    use(item);
}

let maybe = new MaybeBuilder()
let sugared =
    maybe {
        let x = 12
        let! y = Some 11
        let! z = Some 30
        return x + y + z
    }

let maybe = new MaybeBuilder()
let desugared = 
    maybe.Delay(fun () ->
        let x = 12
         maybe.Bind(Some 11, fun y ->
            maybe.Bind(Some 30, fun z ->
                maybe.Return(x + y + z)
                )
            )
        )

middleIsRegex > '(' regex ')'
repetition    > (middleIsRegex | primitive) {'*'}

            var middleIsRegex = from lp in lparen 
                                from rx in regex 
                                from rp in rparen
                                select rx;    

            var repeatedStar = from s in _.Repeat0(star) 
                               select s.HasValue ? s.Value[0] :Blank.New();

            var repetition = from rx in _.Or(middleIsRegex, primitive)
                             from rs in repeatedStar
                             select rs is AST.Blank ? rx : Repetition.New(rx);

            var middleIsRegex = _.Sequence(lparen, regex, rparen).Select(x => string.Concat(x));
            var regexOrPrimitive = _.Or(middleIsRegex, primitive);
            var repeatedStar = _.Repeat0(star).Select(toString);
            var repetition = _.Sequence(regexOrPrimitive, repeatedStar).Select(x => string.Concat(x));

ARK>>>foreach (var item in arr)
ARK>>>{
ARK>>>    use(item);
ARK>>>}
ARK>>>

void use (T item, Action finished);


use(item[0],() => use(item[1],() => use(item[2],() => use(item[3],() => ... ))))

items.Aggregate(()={}, (acc, item) => () => { use(item, acc); });

void use (T item, Action finished) {
   
  ... 
  xxx.onFinishedEvent = () => finished();
}

Future use (T item) {
  Future f = new Future(); 
  
 
  ... 
  xxx.onFinishedEvent = () => f.finished();
}

items.Aggregate(Finished.Empty, (acc, item) => { return acc.then(() => use(item, acc)); });

forach(var item in items) {
  await use(item);
}

fn : Box<A -> B>
v : Box<B>

fn <*> v == Box.apply($, fn, v) //или Box.apply(applyFn, [fn, v])

// $ - это в haskell применение функции, так же, как и строка ниже
$ fn x = applyFn(fn, x) = fn(x)