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

g> Большая, очередь — некоторая структура в памяти, а вот потоки событий — абстракции,структуры не имеющие.

... и работающие по божественной природе своей Любая абстракция при использовании проецируется на что либо. Очередь такая же абстракция. У нас OOP или где

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

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

g>> Большая, очередь — некоторая структура в памяти, а вот потоки событий — абстракции,структуры не имеющие.

H>... и работающие по божественной природе своей Любая абстракция при использовании проецируется на что либо. Очередь такая же абстракция. У нас OOP или где
А я не утверждаю обратное. Я говорю что структуры не имеют, так же как не имеют структуры IEnumerable последовательности.

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

g> g>> Большая, очередь — некоторая структура в памяти, а вот потоки событий — абстракции,структуры не имеющие.

g> H>... и работающие по божественной природе своей Любая абстракция при использовании проецируется на что либо. Очередь такая же абстракция. У нас OOP или где

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

Где-то они сторятся? Из чего-то они выбираются? Следовательно и структура есть.

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

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

g>> g>> Большая, очередь — некоторая структура в памяти, а вот потоки событий — абстракции,структуры не имеющие.

g>> H>... и работающие по божественной природе своей Любая абстракция при использовании проецируется на что либо. Очередь такая же абстракция. У нас OOP или где

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

H>Где-то они сторятся? Из чего-то они выбираются? Следовательно и структура есть.

Необязтельно.

IEnumerable<int> Seq()
{
    var count = 0;
    while(true)
    {
        yield return count++;
    }
}

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

_>>(цитата) "с поддержкой юникода" (и при этом не могли толком объяснить, что же именно они там поддерживают: UTF8? UCS2? Whatever?)
CC>Ну может они оччччень сильно напряглись и реализовали ваще весь Unicode стандарт, с блекждеком и всем что к нему полагается


Ммм, реализовать — это хорошо, но хранить-то его все равно как-то надо. А у нас кроме байт, по сути, других инструментов нету...

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

[]

E__>Понимаешь, Шеридан. Тут не в Винде даже проблема. Изначальный интерфейс написан хрен знает когда для ОЧЕНЬ платного Юникса,

Гугление на тему 2-ого 3-его АСУ Экспрессов показывает, что 2-ой Экспресс в качестве ОС использовал ГДР-ую TKS (переделанные MVT, SVS, MVS) на ЕС-ах и, частью, на западных аналогах IBM360/370, а 3-ий использует — OS390, что логично, т.к. OS390 прямая наследница MVS, на родных IBM-их S390. Надо заметить, что перечисленные ОС совсем не UNIX. Кстати — 2-ой Экспресс начал жить в 82 году, а первый релиз IBM-ого UNIX — AIX увидел свет в 86.

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

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

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

I>Но у тебя почему то сиська и яйцо.
У тебя совсем с логикой туго?

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

g> g>> g>> Большая, очередь — некоторая структура в памяти, а вот потоки событий — абстракции,структуры не имеющие.

g> g>> H>... и работающие по божественной природе своей Любая абстракция при использовании проецируется на что либо. Очередь такая же абстракция. У нас OOP или где

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

g> H>Где-то они сторятся? Из чего-то они выбираются? Следовательно и структура есть.

g> Необязтельно.

g>

g> IEnumerable<int> Seq()
g> {
g>     var count = 0;
g>     while(true)
g>     {
g>         yield return count++;
g>     }
g> }
g>

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

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

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

g>> g>> g>> Большая, очередь — некоторая структура в памяти, а вот потоки событий — абстракции,структуры не имеющие.

g>> g>> H>... и работающие по божественной природе своей Любая абстракция при использовании проецируется на что либо. Очередь такая же абстракция. У нас OOP или где

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

g>> H>Где-то они сторятся? Из чего-то они выбираются? Следовательно и структура есть.

g>> Необязтельно.

g>>

g>> IEnumerable<int> Seq()
g>> {
g>>     var count = 0;
g>>     while(true)
g>>     {
g>>         yield return count++;
g>>     }
g>> }
g>>

H>Не о таком примитивизме речь. Я тоже такую фейковую очередь могу сделать
На сделай, на делфи
А потом сделай так чтобы при обращении к следующему элементу он на консоль выводился.
Или в делфи уже итераторы появились?

H>Только это ничего не доказывает. Я к тому клоню, что если в одном случае будут задействоваться ненулевое количество ресурсов, так и в другом тоже.
Конечно, только "ненулевое" может быть 1, а может быть 1000.

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

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

g> H>Не о таком примитивизме речь. Я тоже такую фейковую очередь могу сделать

g> На сделай, на делфи
g> А потом сделай так чтобы при обращении к следующему элементу он на консоль выводился.
g> Или в делфи уже итераторы появились?

Хм Я думал ты в курсе. Итераторы давно уже есть

g> H>Только это ничего не доказывает. Я к тому клоню, что если в одном случае будут задействоваться ненулевое количество ресурсов, так и в другом тоже.

g> Конечно, только "ненулевое" может быть 1, а может быть 1000.

g> Вот тебе пример для раздумия: поток событий движения мыши, сколько он ресурсов захавает с Rx и сколько с рукопашной реализацией очереди (учитывая что кто-то должен складывать в очередь, а кто-то обрабатывать).

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

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

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

g>> H>Не о таком примитивизме речь. Я тоже такую фейковую очередь могу сделать

g>> На сделай, на делфи
g>> А потом сделай так чтобы при обращении к следующему элементу он на консоль выводился.
g>> Или в делфи уже итераторы появились?

H>Хм Я думал ты в курсе. Итераторы давно уже есть
Давно это когда?


g>> H>Только это ничего не доказывает. Я к тому клоню, что если в одном случае будут задействоваться ненулевое количество ресурсов, так и в другом тоже.

g>> Конечно, только "ненулевое" может быть 1, а может быть 1000.

g>> Вот тебе пример для раздумия: поток событий движения мыши, сколько он ресурсов захавает с Rx и сколько с рукопашной реализацией очереди (учитывая что кто-то должен складывать в очередь, а кто-то обрабатывать).

H>Если движения мыши будут где то храниться, то совершенно неважно каким будет средство доступа Ту же очередь можно реализовать так, что она будет вычитывать напрямую из системного буфера, как и класть в него.
В том то и дело что в Rx они не хранятся, но код пишешь так, как-будто хранятся.

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

g> g>> Или в делфи уже итераторы появились?

g> H>Хм Я думал ты в курсе. Итераторы давно уже есть

g> Давно это когда?

В Delphi 2005.

g> g>> Вот тебе пример для раздумия: поток событий движения мыши, сколько он ресурсов захавает с Rx и сколько с рукопашной реализацией очереди (учитывая что кто-то должен складывать в очередь, а кто-то обрабатывать).

g> H>Если движения мыши будут где то храниться, то совершенно неважно каким будет средство доступа Ту же очередь можно реализовать так, что она будет вычитывать напрямую из системного буфера, как и класть в него.

g> В том то и дело что в Rx они не хранятся, но код пишешь так, как-будто хранятся.

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

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

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

g>> g>> Или в делфи уже итераторы появились?

g>> H>Хм Я думал ты в курсе. Итераторы давно уже есть

g>> Давно это когда?

H>В Delphi 2005.
И как это в коде выглядит? И какой тип возвращает?

g>> g>> Вот тебе пример для раздумия: поток событий движения мыши, сколько он ресурсов захавает с Rx и сколько с рукопашной реализацией очереди (учитывая что кто-то должен складывать в очередь, а кто-то обрабатывать).

g>> H>Если движения мыши будут где то храниться, то совершенно неважно каким будет средство доступа Ту же очередь можно реализовать так, что она будет вычитывать напрямую из системного буфера, как и класть в него.

g>> В том то и дело что в Rx они не хранятся, но код пишешь так, как-будто хранятся.

H>Если они не храняться, то откуда же им браться
Пользователь жмет на кнопку и образуется новый элемент.

H>Как я уже сказал, абстракции очереди ничто не мешает делать вычитку откуда угодно, было бы откуда читать.
Вот в этом и прикол, не всегда есть "откуда" читать. А даже если есть, не всегда можно делать в виде "дай мне два вверх, а потом один вниз, если изменение <= -11".

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

g> И как это в коде выглядит? И какой тип возвращает?

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

var i : byte;

for i in TBytes.Create(1, 2, 3, 4, 5) do
 writeLn(i);

g> Вот в этом и прикол, не всегда есть "откуда" читать. А даже если есть, не всегда можно делать в виде "дай мне два вверх, а потом один вниз, если изменение <= -11".

Ну так в чем проблема при натягивании абстракции на конкретную ситуацию? Если не удовлетворяет абстракция ей ищется/пишется/точится замена

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

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

g>> И как это в коде выглядит? И какой тип возвращает?

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

H>var i : byte;

H>for i in TBytes.Create(1, 2, 3, 4, 5) do
H> writeLn(i);
H>

не, я про yield return, который позволяет по факту прерывать выполнение функции и возобновлять его впоследствии.
А то что аналог foreach появился я в курсе.

g>> Вот в этом и прикол, не всегда есть "откуда" читать. А даже если есть, не всегда можно делать в виде "дай мне два вверх, а потом один вниз, если изменение <= -11".

H>Ну так в чем проблема при натягивании абстракции на конкретную ситуацию? Если не удовлетворяет абстракция ей ищется/пишется/точится замена
Пользователя как раз очень удовлетворяет. Асинхронные потоки сообщений можно обрабатывать точно также, как обычные коллекции, несмотря на то что задействуются сильно разные механизмы.
Другое дело что в языке без поддержки монад, лямбд с замыканиями, без множественной подписки на события еще кучи подобных фишек реализовать это не получится.

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

E>Ну поток событий, очередь событий — какая в принцинципе разница?

В модели программирования. Есть интерактивная модель, как у тебя или у IEnumerable, есть реактивная, как у IObservable.

http://en.wikipedia.org/wiki/Reactive_programming

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

g> g>> И как это в коде выглядит? И какой тип возвращает?

g> H>Тип зависит от то того, что перебираешь. Выглядит, например, так:
g> H>

g> H>var i : byte;

g> H>for i in TBytes.Create(1, 2, 3, 4, 5) do
g> H> writeLn(i);
g> H>

g> не, я про yield return, который позволяет по факту прерывать выполнение функции и возобновлять его впоследствии.
g> А то что аналог foreach появился я в курсе.

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

g> H>Ну так в чем проблема при натягивании абстракции на конкретную ситуацию? Если не удовлетворяет абстракция ей ищется/пишется/точится замена

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

Замыкания и лямбды в дельфях есть. Реализация мультиделегата сложности не представляет

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

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

g>> g>> И как это в коде выглядит? И какой тип возвращает?

g>> H>Тип зависит от то того, что перебираешь. Выглядит, например, так:
g>> H>

g>> H>var i : byte;

g>> H>for i in TBytes.Create(1, 2, 3, 4, 5) do
g>> H> writeLn(i);
g>> H>

g>> не, я про yield return, который позволяет по факту прерывать выполнение функции и возобновлять его впоследствии.
g>> А то что аналог foreach появился я в курсе.

H>yield'а нет. Видел пару ручных реализаций, но они не для серьезного применения. Да, без него несколько усложняется логика перечислителя, но только и всего.
Ты снова неправ, потому что думаешь "только и всего". С помощью yield return можно делать coroutines, можно писать асинхронный код в линейном виде.

g>> H>Ну так в чем проблема при натягивании абстракции на конкретную ситуацию? Если не удовлетворяет абстракция ей ищется/пишется/точится замена

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

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

Кстати как там у лямбд с замыканием на локальные переменные?

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

g> H>yield'а нет. Видел пару ручных реализаций, но они не для серьезного применения. Да, без него несколько усложняется логика перечислителя, но только и всего.

g> Ты снова неправ, потому что думаешь "только и всего". С помощью yield return можно делать coroutines, можно писать асинхронный код в линейном виде.

Как я уже сказал, для ценителей есть реализации (я бы их использовать не стал, но я не ценитель)

g> H>Замыкания и лямбды в дельфях есть. Реализация мультиделегата сложности не представляет

g> да, только события его ни разу не поддерживают.
g> Это должно быть в языке чтобы красиво выглядело и работало, одними библиотеками тут не отделаешься.

Средства языка позволяют все сделать красиво, уж ты поверь События в VCL не поддерживают, но мы же о собственном фреймвоке говорим, а тут проблем нет.

g> Кстати как там у лямбд с замыканием на локальные переменные?

Все в порядке.

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

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

g>> H>yield'а нет. Видел пару ручных реализаций, но они не для серьезного применения. Да, без него несколько усложняется логика перечислителя, но только и всего.

g>> Ты снова неправ, потому что думаешь "только и всего". С помощью yield return можно делать coroutines, можно писать асинхронный код в линейном виде.

H>Как я уже сказал, для ценителей есть реализации (я бы их использовать не стал, но я не ценитель)

Без поддержки языка скорее всего фигня.

g>> H>Замыкания и лямбды в дельфях есть. Реализация мультиделегата сложности не представляет

g>> да, только события его ни разу не поддерживают.
g>> Это должно быть в языке чтобы красиво выглядело и работало, одними библиотеками тут не отделаешься.

H>Средства языка позволяют все сделать красиво, уж ты поверь
Я писал на делфи, на C#, на F#. С уверенностью могу утверждать что на делфи красиво не выйдет.

H>События в VCL не поддерживают, но мы же о собственном фреймвоке говорим, а тут проблем нет.
Нет уж, спасибо.


g>> Кстати как там у лямбд с замыканием на локальные переменные?
H>Все в порядке.

Конкретнее?

Func<int> A(int x)
{
   var y = x*2;
   Func<int> r = () => y;
   y++;
   return r;
}

Такое можно написать?