весь нормальный мир давно пишет так

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

a.each |b| do
 blabla
end

a.map { |b| blabla }

куда понятнее

Вотоночо, Михалыч. А почему бы не использовать другое ключевое слово? Есть например ключевое слово return. Тоже можно сказать - «верни лямбду и подставь». Ещё понятнее будет, не? А ещё можно взять слово ... ну скажем else. Почему бы не обозвать лямбду таким хорошим словом?

Так говорят что руби это и есть перл на стероидах, не?

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

Мне как-то пофиг, я фигурные скобки ставлю.

А пара do-end была выбрана, вероятно, как обобщение понятия блока из паскаль-подобных языков. Указанный метод «делает» (выполняет) код в лямбде по определенным правилам. select - для фильтрации значений, open - для вызова обработчика на дескпритор файла, loop - для бесконечного повторения и т.п.

На кислоте, я бы сказал.

это не лямбда, это блок)

В руби (и помоему только в нем) можно прокинуть в метод один блок.

some_method{ code... }

#или

some_method do
  code...
end

#одно и тоже

как обобщение понятия блока из паскаль-подобных языков

Песец. Просто песец. Предлагаю таки обобщить return.

Какой нахрен блок, если в нём аргументы? Откуда в блоке аргументы?!

str.join(array)

Тут да, есть такой бред. Гвидо, видимо, иногда баловался веществами. Только записывать принято str.join(iterable), чисто формальная претензия.

Лямбда вот

->{ code.. }

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

Какой нахрен блок, если в нём аргументы? Откуда в блоке аргументы?!

В Ruby блоком - называется особый синтаксис для записи лямбд.

Откуда в блоке аргументы?!

def a
  yield 1 #отсюда
end
a{|i| p i } # 1

По итогам этого треда окончательно записал для себя руби в эзотерические.

Но (формально) это не лямбда.

Здрасти. Формально это как раз и есть лямбда. Не лямбда оно синтаксически. В Ruby синтаксически лямбда - производное от понятие блока. Хотя логически всё наоборот.

array.select{|v|v[/someregexp/]}. # ВЫБРАТЬ ПО someregexp

Читаю как выбрать элементы в v, такие, у которых, в свою очередь все и каждый элементы выбранного массива v удовлетворяют regexp ( [] - доступ к элементам )

each_slice(3). # КАЖДЫЙ КУСОК ПО 3 ЭЛЕМЕНТА

Каждый элемент массива v разбить на 3 куска.

map{|v| «#{v[0]} blabla #{v[1]} blablabla #{v[2]}»}. # ПОДСТАВИТЬ ЗНАЧЕНИЯ В СТРОКУ

Применить map к каждому куску разбивки на предыдущем этапе.

Короче, overkill.

По итогам этого треда окончательно записал для себя руби в эзотерические.

Все такие записыватели никак не могут показать какой-нибудь эквивалентный более читабельный код.

Не лямбда оно синтаксически.

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

Короче, overkill.

Ась?

Все такие записыватели никак не могут показать какой-нибудь эквивалентный более читабельный код.

Это потому что оригинальный код никто не может прочесть и понять, что он делает.

Каждый элемент массива v разбить на 3 куска.

Х))))))

Я понял. Когда Луна растёт, это синтаксически лямбда. А когда Луна убывает, это синтаксически не лямбда.

О моя голова! Вам точно осталось переопределить return!

Синтаксически лямбда - это результат применения метода lambda к блоку: lambda{code}. А суть одна — объект класса Proc:

irb(main):020:0> def a(&block) ; p block ; end
=> nil
irb(main):021:0> a{}
#<Proc:0x9aa0aec@(irb):21>
=> #<Proc:0x9aa0aec@(irb):21>
irb(main):022:0> a(&lambda{})
#<Proc:0x9a9eb0c@(irb):22 (lambda)>
=> #<Proc:0x9a9eb0c@(irb):22 (lambda)>
irb(main):023:0> 

Т.е. нечитаемо, видишь. Я даже с пайпами более-менее понимаю, что это «типа скобочки для лямбы», но нечитаемо. Fial.

Вам точно осталось переопределить return!

return не нужен. Без обязательных ключевых слов return и function жаваскрипт был бы хотя бы внешне не ужасен.

Я, как ни странно, наоборот. Когда я пишу или вижу код на чём угодно, кроме Python или JS, думаю о том, насколько же компактнее и понятнее был бы такой же код на Python или JS.

1.9.3-p194 :041 > def a
1.9.3-p194 :042?>   yield
1.9.3-p194 :043?>   end
 => nil 
1.9.3-p194 :047 > def b &block
1.9.3-p194 :048?>   block.call
1.9.3-p194 :049?>   end
 => nil 
1.9.3-p194 :050 > t=Time.now;10000.times{a{}};Time.now-t
 => 0.002899452
1.9.3-p194 :051 > t=Time.now;10000.times{b{}};Time.now-t
 => 0.024449555 

Вот я о чем.

Хм, не знал. Это повод для доработки интерпретатора, впрочем.

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

Здесь вашего сектанта, которому нужно к веществологам, я не вижу.

Так что там с питоном? На что способен такой синтаксис?

ы

у меня после знакомства с перлом такая хрень про плюсы :(

не хочу узнавать руби

Без обязательных ключевых слов

Уже есть perl. В нём слова почти не обязательны. А если вас не беспокоит скорость, то совсем не обязательны, можно обойтись только знаками препинания и цифрами.

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

вот же Ментальный вирус (комментарий)

выдайте более читаемый код, ну хоть на чем-нибудь..

Я даже с описанием по-русски не понимаю что этот код делает, ага. Хотелось бы примеры ввода и соответствующие им примеры вывода.

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

На perl с List::MoreUtils можно попробовать. В нативных функциях нет «разбить массив на группы», правда мне за 12 лет ни разу не потребовалось.

На перле таки компактнее и красивее.

о том и речь.

Так то ничего страшного, очевидно просто инициализация proc, но тем не менее механизм другой..

Уже есть perl. В нём слова почти не обязательны.

Не о том речь. JS вся построена на функциях. Там куда ни плюнь, попадешь в функцию. Возьмём простой код:

array.map(function(v){return v + 2})

Заменим function на короткое fun, а return сделаем необязательным в конце функций. Получаем:

array.map(fun(v){v + 2})

array.map(fun{v: v + 2})

Теперь избавимся от лишних скобок в map(), будем лямбды записывать постфиксно, как в Ruby. За одно, и слово fun выкинем, оно больше не обязательно:

array.map{v: v + 2}

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

Заменим function на короткое fun

И получаем херню, потому что я читаю ЭТО и не могу понять, где прикол, где смеяться.

оптимизация последовательности(){}

И опять получаем херню. У нас чётко синтаксис разграничивал аргументы и код.

array.map{v: v + 2}
Стало совсем хорошо.

Нет предела совершенству!

array|map|v|v+2

И получаем херню, потому что я читаю ЭТО и не могу понять, где прикол, где смеяться.

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

Какой странный язык. Странные ключевые слова «then» и «else», они слишком длинные, их надо заменить на скажем «th» и «el».

functor
datatype
struct

Это же ужасно! Так много длинных слов! Они все так мешают пониманию алгоритма :( И вообще, я смотрю на этот код, вижу одни ключевые слова. Прямо как в бейсике. То ли дело brainfuck!

array map v v+2

Ибо пробел — лучший разделитель.

Ъ! А когда-то наши предки писали без пробелов, кстати, и ничо, не обламывались.

в идеале - несомненно, но здесь нет однозначности. здесь не ясно, v - это параметр, или метод, или переменная..

делаешь машину времени..

Почему?

Потому что ты не понимаешь, что наиболее часто используемые конструкты языка должны записываться наиболее кратко. Вот язычок для тебя: http://progopedia.ru/language/cobol/

Ибо пробел — лучший разделитель.

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