ЯП dao

Ты какой-то странный - сперва рассказываешь о том что луп гавно,

Ты невменяемый. Я не буду в четвертый раз объяснять, почему loop говно. Ты уже не поймешь. Осознай только, лапоть, что сложность к этому никакого отношения не имеет.

а потмо просишь привести в пример задачУ, которая на порядок проще лупа.

Ты некомпетентен, чмо. Эта задача сложнее чем loop. Про оптимизацию напомнить?

На такой тривиальщине как компиляция регекспов он не будет особо значим.

Ну вот и продемонстрируй на «простой» задаче для начала. С оптимизацией.

Компилятор - это уже низкоуровневое перекладывание байтиков.

Ты некомпетентен. Скажи, компилятор Prolog+CLP(FD) в чистую Схему - это «низкоуровневое перекладывание байтиков»?

Это цель существования убогих макросистем типа общелиспа.

Метапрограммирование оправдано только как средство реализации высокоуровневых [e]DSL. В любых других случаях, независимо от реализации, метапрограммирование недопустимо.

Как раз при написании простых макросов не так важно пидорасишь ли ты списки или работаешь с более высокоуровневыми понятиями.

Определи «высокоуровневые понятия», тупица.

Суть хорошей макросистемы как раз и состоит в том, что она позволяет тебе добиться результата без написания компилятора руками.

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

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

То, что ты дерьмо и умеешь вонять, все тут уже поняли. А теперь попробуй побыть немного человеком, и вместо пидарской вони выдай что-то разумное. Конкретно, без пердежа - какие такие задачи ты собрался решать макросами, какими такими абстракциями ты собрался оперировать, и какого хера ты вообще еще не убился, сунув пальцы в розетку?

Внутри loop нету кода на common lisp.

Ты ничтожество. Намыливай веревку, сейчас тебе стыдно будет:

(loop for i upto 100 collect (* i i))

На каком языке написано выражение (* i i)?

Сложнее паскаля, конечно, но простенького.

Не, ну это вообще леденящий душу пиздец. LOOP сложнее Паскаля?!?

Это очень плохой ДСЛ. Возможность исполдьзовать как можно больше средств хост-языка - свойство хорошего дсл.

Ты дебил. Это текучая, дырявая абстракция. Никаких следов от host-языка в DSL быть не должно.

Конечно. Но это конкретные куски, имеющие смысл literal.

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

Ок. Если ты пообещаешь выкатить свой вариант. Не дать ссылку на чью-то реализацию, заметь - а выкатить свой. Договорились? И никакие отмазки не принимаются - я даю свою реализацию, ты даешь свою, либо идешь нахуй. Договорились?

Ты не охуел? Я писать Паскаль с гигиеной не подписывался, это ты тут вякал, что это проще, чем без таковой. Я выкачу реализацию без гигиены, на чистом define-macro.

Гигиена в принципе не может мешать.

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

Ты понимаешь, что дал ссылку на статью человека, который является одним из известнейших схемо-макротеоретиков, в том числе и теории гигиенических макросов?

Мне насрать. Абсолютно то же самое делается без всякой гигиены.

Что твой нанопасс сугубо гигиеничен, заточен под ненавистный syntax-case и принципиально не может работать без гигиены?

Чушь. Гигиена там абсолютно не нужна, и nanopass можно (и нужно) использовать для написания преобразований кода внутри define-macro.

И что он как раз и описывает работу на более высоком уровне абстракции вне кодогенерации?

Ты тупой. Он описывает переписывание AST. Никакого более высокого уровня абстракции быть не может в приницпе. Тот самый code walker, про которые ты тут напердел вагон какашек.

На сколько я знаю, система типов в ML сильно сложнее паскалевской.

На самом деле она проще. В Паскале до хера правил, а в ML надо тупо решать тупые уравнения.

А 90% работы будет именно реализация тайпчека.

Чушь.

Из оставшихся 90% еще 90% - реализация грамматики.

Чушь. Паскаль более сложный язык, в нем конструкций больше, и statements отличаются от expressions.

Эта задача сложнее чем loop.

Она проще.

Про оптимизацию напомнить?

Оптимизация вообще не дает никакого значимого вклада.

Ну вот и продемонстрируй на «простой» задаче для начала. С оптимизацией.

Ты уж выбери - паскаль или регекспы. И, да? - то же требование, что и к паскалю.

Скажи, компилятор Prolog+CLP(FD) в чистую Схему - это «низкоуровневое перекладывание байтиков»?

Ты не понял? _любой_ компилятор - это низкоуровневое перекладывание байтиков. Если тебе пришлось для реализации дсл писать компилятор - значит макросистема недостаточно выразительна для того, чтобы решить задачу адекватным образом.

Метапрограммирование оправдано только как средство реализации высокоуровневых [e]DSL.

Ну да.

В любых других случаях, независимо от реализации, метапрограммирование недопустимо.

Именно по-этому система метапрограммирования в общелиспе совершенно никчемна.

Ты дебил. Ничего иного, кроме написания компиляторов, макросами делать нельзя.

Да можно, конечно. «написание компилятора» - это лишь средство. Взять тот же паскаль - мы можем реализовать его при помощи средств макросистемы, а можем в виде компилятора (если макросистема говно и не предполагает других способов).

Но, естественно, для уебка вроде тебя, который кроме говеного общелиспа ничего не видел, никаких способов, кроме как ебашить руками тысячестрочное кодеволкер-говно, нет.

На каком языке написано выражение (* i i)?

Это literal относительно loop

LOOP сложнее Паскаля?!?

Да, loop сложнее паскаля. Конечно, чтобы это было очевидным, надо для начала реализовать и то и другое. Проблема в том, что ты этого не делал - а потому не знаешь ни лупа, ни паскаля на дОлжном для оценки уровне.

Это текучая, дырявая абстракция.

Так речь о том и идет, что в правильно написанном ДСЛе можно достаточно свободно использовать хост-язык, и при этом ничего не течет. Конечно, для макросистемы общелиспа это жестокий рокетсаенс - там даже примитивные макросы текут. По-этому и приходится вводить какие-то смешные и совершенно искусственные ограничния из разряда «Никаких следов от host-языка в DSL быть не должно.» Но в нормальных языках такой проблемы нет.

И именно для них тебе и нужна твоя пидарская гигиена

Конечно же, нет. Ты ведь даже не знаешь, для чего нужна гигиена, лол. Те identifier clash, о которых ты говоришь - это какие-то 10% юзкейсов. Реальная польза гигиены проявляется тогда, когда мы пишем сложные анафоры и хотим добиться композабельности макросов. В этом случае сам критерий корректности экспанда совпадает с определением гигиены - то есть тебе придется гигиену упорно хуячить руками, если ты хочешь чтобы твои макросы работали. При этом я гарантирую, что в любом нетривиальном случае ты не сможешь навесить гигиену руками правильно с первого раза. Даже с десятого не сможешь.

Гигиена накладывает ограничения на язык

Гигиена не накладывает ограничений. Негигиеническая макросистема является строгим подмножеством гигиенической. Негигиенический defmacro реализуется в две строчки из гигиенического.

Ты не охуел? Я писать Паскаль с гигиеной не подписывался

Да ты что? Я же и не говорил, что тебе надо писать с гигиеной. Офк ты пишешь без гигиены на общелиспе.

Я выкачу реализацию без гигиены, на чистом define-macro.

Ну то есть договорились, да? Тогда давай еще условимся по части используемых спек, чтобы потом не было «а вот ты это не сделал, а я сделал», и, собственно, вперед?

Чушь. Гигиена там абсолютно не нужна, и nanopass можно (и нужно) использовать для написания преобразований кода внутри define-macro.

То есть ты не понимаешь как работает nanopass.

Он описывает переписывание AST. Никакого более высокого уровня абстракции быть не может в приницпе. Тот самый code walker, про которые ты тут напердел вагон какашек.

Хаха. Он не имеет отношение к кодеволкерам. Следующий раз сам разберись, на что кидаешь ссылки, лол.

На самом деле она проще. В Паскале до хера правил, а в ML надо тупо решать тупые уравнения.

Как я уже сказал - не знаю достаточно ML, но там есть параметрический полиморфизм, который все резко усложняет по сравнению с паскалем.

Чушь.

А, ну да, естественон, если ты хуячишь кодеволкер - то тайпчекер не будет так уж велиК, действительно +- тыща строк кода, совсем незаметно.

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

Чушь. Паскаль более сложный язык, в нем конструкций больше, и statements отличаются от expressions.

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

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

Ты, кстати, палишься. Ссылки на статейки схемачей, define-macro вместо defmacro...

А я где говорил, что я сторонник CL? Я люблю Схему, но не люблю гигиену. В CL меня бесит то, что он LISP-2.

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

Ты так и не осилил сформулировать, что ты считаешь «адекватным образом».

Он не имеет отношение к кодеволкерам.

Ты и что такое code walker не знаешь. Как ты с таким низким IQ до сих пор не убил себя, сунув пальцы в розетку?

Да, loop сложнее паскаля.

Редкостный недоумок.

Конечно, чтобы это было очевидным, надо для начала реализовать и то и другое.

Я это делал. LOOP - такого же уровня говнецо, что list comprehensions. Делается на трех с половиной тривиальных конструкциях.

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

Ты Паскаль только в кино видел, да? Оцени сложность семантики конструкции WITH.

Оптимизация вообще не дает никакого значимого вклада.

Опиши опимизацию на гигиенических говномакрах.

Ты так и не осилил сформулировать, что ты считаешь «адекватным образом»

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

Опиши опимизацию на гигиенических говномакрах.

Она там выглядит ровно так же как и на негигиенических, лол. О чем ты вообще?

Я это делал. LOOP - такого же уровня говнецо, что list comprehensions. Делается на трех с половиной тривиальных конструкциях.

Именно по-этому реализация занимает пятьтыщстрок?

Ты Паскаль только в кино видел, да?

Нет. Повторяю - я делал и луп и паскаль.

Оцени сложность семантики конструкции WITH.

Практически нулевая, такие вещи очень удобно делаются через имплициты на macro-generated macro.

Хотя я, быть может, плохо знаю семантику with, и там есть какие-то особенности, которых я не учел? Мы говорим о том with, которое:

with record do begin
  field1 := yoba
  field2 := pizda
  f(field3);
end;

Ты и что такое code walker не знаешь.

Прекрасно знаю. Так вот, в нанопассе как раз тот подход о котором говорю я - максимальное абстрагирование от аст-трансформации, никаких кодеволкеров. То есть кодеволкеры есть - но они под капотом, генерятся сами, программист их не пишет.

Ну так чо, давай линк на устраивающую тебя спеку паскаля и погнали.

Кстати, есть еще такое предложение - поскольку паскаль это слишком просто, давай лучше будем делать паскаль+макросы? То есть реализация паскаля с возможностью использования полной макросистемы хост-языка внутри него.

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

Оригинальный, Виртовский Паскаль. Без всяких расширений (то есть, ISO 7185).

Надо, чтобы на Паскале можно было описывать макросы.

Так об этом речь и шла

Задача-минимум - для самого Паскаля, максимум - для хост-языка тоже.

Это одно и то же.

Именно по-этому реализация занимает пятьтыщстрок?

Ну так они ж, коммонлисперы, криволапые все, макросами пользоваться не умеют.

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

Практически нулевая, такие вещи очень удобно делаются через имплициты на macro-generated macro.

Бла-бла-бла. Как конкретно ты хранишь информацию о типах, если у тебя даже global state нет?

Это одно и то же.

С какой радости? Если внутри компилятора Паскаля свой macroexpand, то host-язык об этом и знать-то ничего не будет.

Короче, вот это: http://www.moorecad.com/standardpascal/The_Programming_Language_Pascal_1973.pdf

С какой радости? Если внутри компилятора Паскаля свой macroexpand

Макроэкспанд один, конечно же, при чем тут свой? Если отдельный экспандер для самого паскаля городить то он будет слишком никчемный и бесполезным по сравнению с экспандером хост-языка.

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

Так вот, в нанопассе как раз тот подход о котором говорю я - максимальное абстрагирование от аст-трансформации, никаких кодеволкеров.

Code walker это и есть любая трансформация дерева. А уж как она сформулирована - это дело десятое. Не важно сделано оно в виде визитора, или TRS, или DSL высокого уровня в духе nanopass или Scrap Your Boilerplate, или вообще как /. (ReplaceAll) в Mathematica, или низкоуровневое дрочево списков с car/cdr/cons/list.

Бла-бла-бла. Как конкретно ты хранишь информацию о типах, если у тебя даже global state нет?

Ты забыл, что у меня гигиеническая макросистема - а значит есть полный доступ к лексическому контексту, в котором и лежат типы.

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

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

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

Code walker это и есть любая трансформация дерева.

Ну да. А суть указанного подхода - абстрагирование от трансформаций и, соответственно, кодеволкеров. Вместо того, чтобы писать АСТ-трансформер, мы указываем семантические rewriting rules произвольного вида. Естественно, в итоге тоже получится кодеволкер, но он уже генерится где-то там, под капотом. Программисту его писать не надо - он вместо этого использует встроенные возможности экспандера.

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

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

Это с твоей, убогой точки зрения так. Моя позиция в том, что экспандер должен быть туп, как пробка (как в Common Lisp), без всякой гнилой гигиены, так что внутри DSLей могут быть свои собственные экспандеры.

Вместо того, чтобы писать АСТ-трансформер, мы указываем семантические rewriting rules произвольного вида.

Да пиши, кто ж тебе запрещает. Но при чем тут гигиена?!?

а значит есть полный доступ к лексическому контексту

Ой беда-беда, в Паскале-то контекст не обязательно лексический. В одном модуле определение, в другом ты его используешь.

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

Примеры приводи. Гигиена может мешать и ограничивать. Она не может делать ничего того, что не может быть сделано на более низком уровне.

вместо генерации целевого кода указывать свойства сгенерированного кода

Лженаучная фантастика, что-то из разряда такого бреда: http://www.eecs.tufts.edu/~dias/dissertation/dissertation.pdf

Ты конкретные примеры приводи, где это реально работает и применяется, а не академическое говно.

паскаль это слишком просто

С интересом посмотрю, как в твоей реализации этого слишком простого языка обрабатывается goto. Особенно интересен случай irreducible control flow.

Да, важная деталь - реализация должна быть эффективной.

Моя позиция в том, что экспандер должен быть туп, как пробка (как в Common Lisp), без всякой гнилой гигиены, так что внутри DSLей могут быть свои собственные экспандеры.

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

Но при чем тут гигиена?!?

Без гигиены нет работы с лексическим контекстом. Значит никакие интересные макросы написать не удастся - только примитивные кодеволкеры.

В одном модуле определение, в другом ты его используешь.

И это обычный лексический контекст, да.

Гигиена может мешать и ограничивать.

Ну так приведи хоть один пример, где она ограничивает.

Она не может делать ничего того, что не может быть сделано на более низком уровне.

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

Примеры приводи.

Ну вот ты недавно говорил о with из паскаля, давай на этом и остановимся, чтобы далеко не ходить:

(begin-for-syntax
  (define-syntax >>
    (syntax-rules ()
      [(>> x ff ... f) (f (>> x ff ...))]
      [(>> x) x]))
  
  (define (make-id g)
    (g . >> . syntax->datum symbol->string
              (curryr string-split "-")
              cdr string-append* string->symbol
              (curry datum->syntax #'magic)
              syntax-local-introduce))
    
  (define (id-transformer getter setter tmp)
     (syntax-parser [id:id #`(#,getter #,tmp)]
                    [((~literal set!) id:id e:expr) #`(#,setter #,tmp e)])))

(define-simple-macro (with e:expr (~var s (static struct-info? "struct descriptor")) body:expr ...+)
  #:do [(match-define (list _ _ _ getters setters _) 
          (#'s . >> . syntax-local-value extract-struct-info))]
  #:with (getter ...) #`#,getters
  #:with (setter ...) #`#,setters
  #:with (transformed ...) #`#,(map make-id getters)
  (let* ([tmp e]) 
    (define-syntax transformed
      (make-set!-transformer (id-transformer #'getter #'setter #'tmp))) ...
    body ...))

(struct yoba (x y)
  #:mutable
  #:transparent)

(define y (yoba 1 2))

y ;(yoba 1 2)
(with y yoba
      (displayln (+ x y)) ; 3
      (set! x 10)
      (displayln (+ x y))) ; 12
y ;(yoba 10 2)

С интересом посмотрю, как в твоей реализации этого слишком простого языка обрабатывается goto. Особенно интересен случай irreducible control flow.

Тривиально раскрывается в letrec. Это классическая реализация goto в схемке.

Да, важная деталь - реализация должна быть эффективной.

Более эффективной реализации в схемке не существует. Но вобщем сделанный на таком goto цикл будет работать ровно с той же скоростью, что и обычный луп, например. То есть схемка в принципе не умеет делать переход быстрее чем так.

Без гигиены нет работы с лексическим контекстом.

Экий бред. Есть сотни способов работы с контекстом, но наличие гигиены ограничивает тебя ровно одним из них. И это гнило.

Значит никакие интересные макросы написать не удастся - только примитивные кодеволкеры.

От того, что ты повторишь чушь сто раз, меньшей чушью она не станет.

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

Экий бред. Есть сотни способов работы с контекстом

Без гигиены нету ни одного. Отсутствие гигиены - это ограничение, т.к. экспандер (и, соответственно, макрос) не может контролировать связывания переменных. Гигиена - это как раз наличие такой возможности.

От того, что ты повторишь чушь сто раз, меньшей чушью она не станет.

Ну ты, конечно, можешь привести хотя бы пару из сотни способов управления лексический контекстом в отсутствии гигиены?

Тривиально раскрывается в letrec. Это классическая реализация goto в схемке.

Для начала тебе придется код на Паскале перевести в SSA, и затем в CPS. Причем, делать это только для тех под-графов, в которых есть irreducible control flow. Если делать это для всех, то будет неэффективно.

Все еще «проще, чем loop»?

Но вобщем сделанный на таком goto цикл будет работать ровно с той же скоростью, что и обычный луп, например.

Ага, только тебе надо это делать только для goto, причем не всех. Ты же не хочешь так же обрабатывать control flow внутри, например, if?

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

Чушь. Зачем «контролировать», когда можно, например, переопределить оба способа связывания (let и lambda), и тащить в них контекст через локальные макры? Это низкоуровневый, но универсальный способ. Так можно контроллировать стадии экспанда - а при гигиене стадии тебе жестко навязаны.

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

Что с тайпчекером-то сложного? Там банальный type propagation, делается в один проход переписыванием дерева depth-first. Исходный AST без типов, целевой AST с каждым expression и lvalue узлом, аннотированным его типом (или идентификатором типа). Правила тривиальны.

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

Вот эффективная трансляция императивного кода в типа-как-бы-функциональный - это уже интереснее.

Чушь. Зачем «контролировать», когда можно, например, переопределить оба способа связывания (let и lambda), и тащить в них контекст через локальные макры?

Закат солнца вручную, да.

Это низкоуровневый, но универсальный способ.

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

Что с тайпчекером-то сложного? Там банальный type propagation, делается в один проход переписыванием дерева depth-first.

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

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

Для ML даже проще

В ML есть полиморфизм - это сильно усложняет представление типизированного дерева и вообще control-flow тайпчека.

Вот эффективная трансляция императивного кода в типа-как-бы-функциональный - это уже интереснее.

Это как раз элементарные вещи для реализации которых даже задумываться не нужно.

Закат солнца вручную, да.

1) Это все легко абстрагируется

2) Точно так же можно делать для идентификаторов в eDSL-ях, которые напрямую не транслируются в идентификаторы Схемки (и ты обосрешься это делать с гигиеной)

3) Это нужно крайне редко (потому как наличие такой потребности - это code smell само по себе)

Твоя хуитка с переопределенными лямбдами наебнется на первых же чуть менее тривиальных примерах.

Оно работает всегда, в отличие от гнилогигиены, которая работает ТОЛЬКО для лямбдок с летами.

Если делать это для всех, то будет неэффективно.

Да нет, вполне эффективно.

Для начала тебе придется код на Паскале перевести в SSA, и затем в CPS.

Ты совсем дурак чтоли? Надо быть полным ебланом, чтобы переводить код в SSA, чтобы потом переводить его в CPS.

Все еще «проще, чем loop»?

Конечно. Метки лупа в схеме вообще в отличии от паскалевского goto только через продолжения реализовать можно.