foreach + yield - Nemerle

Уже пробегала идея для автоматизация foreach + yield: url=http://www.rsdn.ru/forum/nemerle/4806737
Как показывает личная практика фича нужна.

Вопрос какой синтаксис выглядит более очевидным ?
В Python ,например, используется: 'yield from x'.
Но в Nemerle мне кажется это может запутать.

Может быть что-то в стиле:

yield ..a;

Есть идеи ?

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

_NN>Вопрос какой синтаксис выглядит более очевидным ?
_NN>В Python ,например, используется: 'yield from x'.
_NN>Но в Nemerle мне кажется это может запутать.

Угу. Особенно когда синтаксис linq сможет поддерживаться нормально.

yield from x in seq where x > 0;
yield from from x in seq where x > 0;

_NN>Может быть что-то в стиле:
_NN>

_NN>yield ..a;
_NN>

Снова птички. А может yield all? Насколько это коряво будет звучать по английски без from?

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

Z>Снова птички. А может yield all? Насколько это коряво будет звучать по английски без from?
".." используется в макросе $"..$x" и в квазицитатах <[ {..$x} ]>
Мне кажется логично его заюзать в yield.

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

Z>>Снова птички. А может yield all? Насколько это коряво будет звучать по английски без from?
_NN>".." используется в макросе $"..$x" и в квазицитатах <[ {..$x} ]>
_NN>Мне кажется логично его заюзать в yield.

Да я понял откуда он взят. Только я например, вижу там не .., а ..$.

_NN>Есть идеи ?
может как в F# ?

yield! items

_NN>Есть идеи ?
Чуть более многословно, но набирать проще и более понятно, имхо.

yieldmany items

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

_NN>>Есть идеи ?
STD>может как в F# ?

STD>

STD>yield! items
STD>

Этот вариант выглядит хорошо и даже возможен на практике:

public macro YieldMany(seq)
syntax("yield", "!", seq)
{
  <[ foreach(s in $seq) yield s; ]>
}

Только IDE не может понять что это нормальный код:

  F() : IEnumerable[int]
  {
    yield! [1,2]; // typing fails on finding the operator op_LogicalNot(list[int-])
  }

P.S.
Кстати, syntax("yield!") невозможен, грамматика такое запрещает: MacroClassGen.n.
Можно подумать как исправить этот недостаток

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

_NN>Уже пробегала идея для автоматизация foreach + yield: url=http://www.rsdn.ru/forum/nemerle/4806737
_NN>Как показывает личная практика фича нужна.

_NN>Вопрос какой синтаксис выглядит более очевидным ?
_NN>В Python ,например, используется: 'yield from x'.
_NN>Но в Nemerle мне кажется это может запутать.

_NN>Может быть что-то в стиле:
_NN>

_NN>yield ..a;
_NN>

_NN>Есть идеи ?

дык yields,

macro Yields (expr) syntax ("yields", expr)

<[ foreach(e in $expr) yield e;]>

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

Голосование

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

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

_NN>Голосование

а где Yield ..a;

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

Еще вариант: yieldseq

_NN>Есть идеи ?

Может лучше оставить просто слово yield и пусть сам компилятор проверяет типы и возвращает коллекцию поштучно? А в редком случае когда правильного варианта нет, пусть пользователь распишет foreach? Очередное ключевое слово непонятно зачем для очевидной штуки городить.

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

_NN>>Есть идеи ?

_>Может лучше оставить просто слово yield и пусть сам компилятор проверяет типы и возвращает коллекцию поштучно? А в редком случае когда правильного варианта нет, пусть пользователь распишет foreach? Очередное ключевое слово непонятно зачем для очевидной штуки городить.

СОГЛАСЕН

А>СОГЛАСЕН

Главное чтобы неочевидных косяков не осталось, типа:

YieldFunc[T](t:T):IEnumerable[object]
{
  yield t;
}

При T = object[] будет иметь не то поведение, какое будет иметь:

YieldFunc(t:object[]):IEnumerable[object]
{
  yield t;
}

Что может ставить в тупик.

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

А>>СОГЛАСЕН

_>Главное чтобы неочевидных косяков не осталось, типа:
Ну вот, сейчас yield явно выдает одно значение, а тут вместо одного "случайно" будет последовательность.
Есть конечно хак вида:

YieldFunc(t:object[]):IEnumerable[object]
{
  yield [t]; // Пакуем а yield неявно распакует :)
}

Но насколько это очевидно ?
Мне кажется проще тогда иметь явный синтаксис происходящего.

_NN>Ну вот, сейчас yield явно выдает одно значение, а тут вместо одного "случайно" будет последовательность.
_NN>Есть конечно хак вида:
_NN>

_NN>YieldFunc(t:object[]):IEnumerable[object]
_NN>{
_NN>  yield [t]; // Пакуем а yield неявно распакует :)
_NN>}
_NN>

Этот случай ошибкой времени компиляции разруливается, так как t приводится к IEnumerable[object] и поэлементно и целиком. А на generic'е временем компиляции не отделаешься.

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

_>Может лучше оставить просто слово yield и пусть сам компилятор проверяет типы и возвращает коллекцию поштучно? А в редком случае когда правильного варианта нет, пусть пользователь распишет foreach? Очередное ключевое слово непонятно зачем для очевидной штуки городить.

Это очень плохой вариант.

1) Не очевидно. Два совершенно разных по семантике действия выглядят одинаково. Их не отличить друг от друга.
2) Если вдруг какой-то тип начнет реализовывать IEnumerable, какой-то код может сломаться черт знает в каком месте, причем поломка может вылезти только в рантайме.
3) Что если я действительно хочу сделать yield IEnumerable? Одним значением.

Контринтуитивно и совершенно не способствует чтению кода.

yieldmany лидирует с большим отрывом.

Я склоняюсь к тому что лучше не вводить лишнюю неопределенность.

Добавляем или есть еще предложения ?

_NN>Добавляем или есть еще предложения ?

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

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

_NN>>Добавляем или есть еще предложения ?

_>Фильтра нет, так что это как бы не many а all. Но люди уже проголосовали, и yieldall никто даже не предложил, так что пили yieldmany. Уж всяко лучше чем какой-нить хитрый восклицательный знак.

Мы никуда не спешим, а делать необдуманно нехорошо

Насчет фильтра действительно интересная идея.

Можно сравнить на простом примере , что яснее выражает суть:

yieldall F.Where(_ > 1)
yieldall F.SelectMany(p => p + 1)
// vs.
yieldmany F.Where(_ > 1)
yieldmany F.SelectMany(p => p + 1)

От:	_NN_	www.nemerleweb.com
Дата:	15.06.13 13:51
Оценка:	+1

	От:	Ziaw
	Дата:	15.06.13 14:53
	Оценка:

От:	_NN_	www.nemerleweb.com
Дата:	15.06.13 15:12
Оценка:

	От:	Ziaw
	Дата:	15.06.13 16:06
	Оценка:

От:	STDray	http://stdray.livejournal.com
Дата:	15.06.13 19:52
Оценка:	+2

	От:	Аноним
	Дата:	17.06.13 07:04
	Оценка:

	От:	artelk
	Дата:	17.06.13 12:31
	Оценка:

	От:	hi_octane
	Дата:	17.06.13 14:00
	Оценка:	+1 -1

	От:	Аноним
	Дата:	17.06.13 14:05
	Оценка: