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 выполняется внутри лябмды или снаружи.

[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 

[amarao]

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

[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]

Семантика цикла в верхнем примере — поиск с ранним выходом при успехе и ранним осознанием облома. Соответственно, его надо выражать не в базисе 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)()

[amarao]

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

[juan_gandhi]

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

[permeakra]

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

[juan_gandhi]

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