Здравствуйте, VladD2, Вы писали:
MC>>На эту тему, кстати, статейка от в т.ч. Мартина есть (fulltext гуглится).
VD>Дык и давал бы прямую ссылку.
Просто прямые ссылки иногда мрут (вот, на readscheme, который я упоминал, таких полно), а эта, по идее, должна жить долго.

VD>Кстати, мне кажется CPS не самый эффективный путь реализации. Эффективнее было бы эмулировать стек вызовов.
Да, глобальный cps по идее тормозит код. Я статью проглядел мельком — там cps не глобальный предлагается, а по месту. Mark Feeley, кстати, про свой Gambit тоже что-то такое говорил. Плюс в статье есть ссылки всякие, на другие статьи и в т.ч. на другие подходы. По идее, должно сойти за отправную точку в изучении вопроса.

Здравствуйте, Denom, Вы писали:

D>Здравствуйте, VladD2, Вы писали:

VD>>... то прошу высказываться.

D>Мне почему-то кажется что по другому кроме как через cps-трансформацию не получится
D>А в идеале — через монады — как в F#.
D>(без изменения .NET runtime).
D>Кстати в mono так и сделали.
D>Со стэком наверное получится только в nemerlish. Пример можно подглядеть в IronScheme.
D>Как вариант попробовать на фиберах.

В Mono вся эта штука сделана на уровне рантайма, но внятных примеров использования я к сожалению не обнаружил (это еще в те времена когда они анонсировали фичу). Если махнуть рукой на решение в общем виде и ограничиться только "обобщением yield до масштабов класса" мне задача видится вполне решаемой на макросах.

Здравствуйте, Denom, Вы писали:
D>А в идеале — через монады — как в F#.
Ну тогда достаточно скопипастить в nemerle do-notation. Получится хелпер для ручной cps-трансформации.

D>Кстати в mono так и сделали.
А там континуации можно многократно вызывать?

D>Пример можно подглядеть в IronScheme.
А там разве полноценные континуации без cps сделаны?

Здравствуйте, hardcase, Вы писали:

H> Если махнуть рукой на решение в общем виде и ограничиться только "обобщением yield до масштабов класса" мне задача видится вполне решаемой на макросах.

На мой взгляд полноценные продолжения (т.е. сохраняющие контекст вычислений в любом месте и в любое время) невозможно реализовать эффективно, по крайней мере без поддержки рантайма. Но на практике такая круть не особо нужна. Полноценные продолжения — это слишком мощное оружие. Через них можно реализовать половину фич языка (например, исключения). Но большая часть фич уже есть в дотнете и стало быть в немерле. Так что продолжения нужны в основном ради реализации форк-флоу сценариев в виде "плоского" кода (без обработчиков событий и т.п.). И тут "обобщением yield до масштабов класса" или если смотреть с другой стороны "ограничение продолжений до масштаба класса" — это то что нужно. Все равно бессмысленно описывать ворк-флоу-логику размазывая ее по нескольким классам.

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

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

Здравствуйте, VladD2, Вы писали:

D>>(без изменения .NET runtime).
D>>Кстати в mono так и сделали.

VD>Что сделали? Не понял...

Добавили поддержку продолжений в рантайм

Здравствуйте, Mr.Cat, Вы писали:

MC>Ну тогда достаточно скопипастить в nemerle do-notation. Получится хелпер для ручной cps-трансформации.
Я с хаскелем можно сказать не знаком... А вот идея из F# с computation workflows мне понравилась — красиво...

MC>А там континуации можно многократно вызывать?
Судя по той версии что у меня (если я правильно понимаю)сохранённый стек при восстановлении не удаляется...

MC>А там разве полноценные континуации без cps сделаны?
Там 2 реализации с условной компиляцией... в моей ревизии CPS версия сломана...

Здравствуйте, Denom, Вы писали:
MC>>Ну тогда достаточно скопипастить в nemerle do-notation. Получится хелпер для ручной cps-трансформации.
D>Я с хаскелем можно сказать не знаком... А вот идея из F# с computation workflows мне понравилась — красиво...
Я f# плохо понимаю, но там ведь суть в том, что последовательность выражений вида let x = f(y) заменяется на цепочку вызовов bind соответствующей монады? Вроде и в скала такое имеется (эээ... sequence comprehensions что-ли).

MC>>А там континуации можно многократно вызывать?
D>Судя по той версии что у меня (если я правильно понимаю)сохранённый стек при восстановлении не удаляется...
Хм... Тогда смахивает на полноценный shift/reset или call/cc, в которых можно с континуацией делать что угодно, что можно с обычной функцией.

MC>>А там разве полноценные континуации без cps сделаны?
D>Там 2 реализации с условной компиляцией... в моей ревизии CPS версия сломана...
Просто та, которая без cps — там ведь неполноценные континуации? Или вру?

Здравствуйте, Mr.Cat, Вы писали:

MC>Я f# плохо понимаю, но там ведь суть в том, что последовательность выражений вида let x = f(y) заменяется на цепочку вызовов bind соответствующей монады? Вроде и в скала такое имеется (эээ... sequence comprehensions что-ли).
допустим есть монада async в ней описаны let, bind, return

и мы пишем

async
{
let a = func1()
let! b = func2()
a + b
}

только второе выражение, которое с ! заменится на bind, а всё что после него передастся в bind в стиле cps...

MC>Хм... Тогда смахивает на полноценный shift/reset или call/cc, в которых можно с континуацией делать что угодно, что можно с обычной функцией.
ну ну это call/cc и есть...

MC>Просто та, которая без cps — там ведь неполноценные континуации? Или вру?
хз... я код по диагонали просмотрел...