Control flow as a type

[amarao]

Чем больше я про это думаю, тем больше я его хочу.

Любое замыкание (в расте) может управлять control flow приложения, но только в смысле panic!. Замыкание не может управлять другим control flow, например, break/continue/return.

Это делает не экивалентным цикл итератора и применение map для того же самого итератора. Несправедливо! Если бы только компилятор понимал управление control flow и мог правильно проверить его совместимость...

Comments

[permeakra]

Вот так вот люди и приходят к монадкам и хаскелю.

[amarao]

Мимо монадок. Монадка - один из методов, причём не самый эффективный или выразительный.

also, хочу узрить return return на монадках.

[permeakra]

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

Опишите, что он делает.

[amarao]

fn find(x, sample) -> TypeFoo {
  for x in foo.iter () {
    if x.should_return(sample){
       return x.make_foo(sample);
    }
    if x.should_stop(sample){
       break;
    }
  }
  TypeFoo::default()
}

Теперь попробуй это записать через filter/map:

fn find(x, sample) -> TypeFoo {
    foo.iter.map(|x| { .... } )...
}

[permeakra]

Если я правильно понял, то

module Test where
import Control.Monad

testFn rc bc dv l = either id id $ (forM_ l $ \e -> if rc e then Left e else (if bc e then Left dv else return () ) ) >> return dv


*Test> testFn (==1) (==2) 0 [3,3,2,1]
0
*Test> testFn (==1) (==2) 0 [3,3,1,2]
1

[permeakra]

Форматирование съелось. Определение функции в одну строчку.

[amarao]

Не то, чтобы я хорошо знал хаскели, но выглядит так, что ты просто делаешь энум с вариантами (хоть и замаскированными).

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

Я плохо читаю хаскель и не могу понять, if выполняется внутри лябмды или снаружи.

[juan_gandhi]

Не обязательно к хаскелю, э. Скала тоже хорошая.

[permeakra]

>Не то, чтобы я хорошо знал хаскели, но выглядит так, что ты просто делаешь энум с вариантами (хоть и замаскированными).

Отчасти. инстанс монадки Either (эквивалент Result в Rust) написан так, что после первого Left ничего не вычисляется, там даже список не будет конструироваться. Кроме того, GHC умный, вполше может промежуточное построение Either optimize away.

>Я плохо читаю хаскель и не могу понять, if выполняется внутри лябмды или снаружи.
Внутри. Все if внутри лямбны, снаружи только монадка.

> Напиши без материализованного энума (без байтов в памяти) и в виде отдельной функции, которую ты вызываешь по имени.

Какие мы привередливые.

import Control.Monad.Cont

testCn :: (a -> Bool) -> (a -> Bool) -> a -> [a] -> a
-- ^ immidiate return condition checker, abort and return default value checker, default value, list to proc.
testCn rc bc dv l = flip runCont id $ callCC $ \rexit -> do
  callCC $ \lexit -> forM_ l $ \e -> do
     when (rc e) $ rexit e
     when (bc e) $ lexit ()
  return dv

Используется монада продолжений, на которой можно сочинить любой разумный control flow. Первый callCC дает продолжение rexit (return-exit), которое позволяет выскочить из функции сразу, второй callCC дает продолжение, которое выскакивает перед

 return dv 

[permeakra]

В скалу завезли TCO ?

[juan_gandhi]

Ну где-то да. At a certain degree.

[yurikhan]

Семантика цикла в верхнем примере — поиск с ранним выходом при успехе и ранним осознанием облома. Соответственно, его надо выражать не в базисе map/filter, а в базисе map/filter/take 1.

Не тестировал, но что-то такое:

NotFound = object()
Break = object()
Continue = object()

def find(xs, sample) -> TypeFoo:
    z = next((y
              for x in xs
              if Continue != (y := (x.make_foo(sample) if x.should_return(sample) else
                                    Break if x.should_stop(sample) else
                                    Continue))),
             NotFound)
    return {NotFound: TypeFoo, Break: TypeFoo}.get(z, lambda: z)()

[yurikhan]

Вообще мысли вида «хочу иметь break/continue/return expr/throw expr в виде first-class значения» обычно приходят при попытке применить рефакторинг Extract Method к куску говнокода, где на входе коллекция, потом по ней for выше человеческого роста, а внутри этого for’а — вышеупомянутые управляющие конструкции в ассортименте.

[amarao]

Я это плохо понимаю, я не вижу, где заканчивается итератор и начинается функция. when - в функции или в вызывающем коде?

[amarao]

Ну ты просто энумизируешь флоу и делаешь по ним lookup в словаре. Это всем читерство.

[amarao]

Да, но это может быть не говнокод, а просто много требований, может быть, даже с сайд-causes при ответе на вопрос "что делать дальше".

Хочется эти ответы и проверки вынести в отдельные функции.

Например, представь себе, обычный for-цикл по коллекции (без права на спекулятивное чтение, то есть ты не знаешь длины итератора и не можешь делать peek).

Теперь у тебя есть пять решений: break, continue, return (math for(i)), update context, pass.

Каждое i должно быть обработано каждой из 10000 функций KYC/AML подразделения, которое делает всякую фигню (включая запрос фотки задницы на фоне задней страницы паспорта).

Как ты такое напишешь? Разумеется, ты сделаешь рефакторинг, чтобы тебе такое не надо было писать. Но рефакторинг ты сделаешь, потому что тебе инструмент не позволяет.

[yurikhan]

Каждое i должно быть обработано каждой из 10000 функций KYC/AML подразделения

А характерный размер коллекции (из которой каждое i)?

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

[permeakra]

Аннотировал скобками и точками-с-запятой. Оба when, понятное дело, во внутренней лямбде.

testCn rc bc dv l = flip runCont id $ callCC $ \rexit -> do {
  callCC $ \lexit -> forM_ l $ \e -> do{
     when (rc e) $ rexit e;
     when (bc e) $ lexit ();
  };
  return dv;
  }

runCont - раскрывает монадку продолжения
callCC - расставляет точки возврата (куда выходить) и отправляет в свой аргуменет условную 'команду выхода' в эту точку возврата.
forM_ - запустить монадические вычисления на 'iterable' коллекции, и склеить 'слева направо', выкидывая результат. Он получает здесь лямбду, в которую передает элемент. Эта внутренняя лямбда синтаксически захватывает 'команды выхода' из более внешних.

Если тебя смущает $, то это чтоб скобки не размножались. f $ g == f (g) . Удобно, когда нужно отграничить лямбду или сделать длинный пайплайн.

[yurikhan]

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

[amarao]

А что, если каждое требование - отдельная функция, выбираемая диспетчером требований?

[yurikhan]

Ну и? Надо сесть за моделирование и тип возврата этих функций-требований сформулировать в терминах предметной области («этому разрешить без очереди и без дальнейших проверок», «да, если не противоречит другим проверкам», «минус десять очков Гриффиндору», «ни за что и никогда»), а не в терминах управляющих конструкций того цикла, в котором перебираются проверки.

Если проверки одного клиента влияют на результаты проверок для других (например, у нас ограниченный ресурс), то, значит, у нас опять не задача на map-map-filter, а на map-map-sum-sort-take 100.