Rust атакует.

[DddIzer]

одно но, в описание раста на сайте я такой х...ни не увидел.

[DddIzer]

Но увидел другое, что мне не очень понравилось...  у них операторы (управляющие алгоритмические инструкции) могут возвращать значения.. само по себе это не ново.. но у них поддерживается значение "андефинед" для любого типа (подобно NULL значению в SQL), причем отсутствие его определятся отсутствием ;

[vlad]

Тут обращать на другое нужно внимание.. - здесь как "вРуби" значение (число 100) является сложным обьектом...  , что для меня , например, достаточно непривычно...

Причем непонятно, чем это лучше "times(100)"... Похоже на очередное ООП головного мозга - должны быть объекты и их методы через точечку.

[DddIzer]

Тут обращать на другое нужно внимание.. - здесь как "вРуби" значение (число 100) является сложным обьектом...  , что для меня , например, достаточно непривычно...

Причем непонятно, чем это лучше "times(100)"... Похоже на очередное ООП головного мозга - должны быть объекты и их методы через точечку.

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

[Geniepro]

Нет здесь никакой ошибки... ибо четко сказано "Here's some code that prints "Hello" 100 times:"... time - это время, а times - "раз" - так и переводится.. , для англоговорящего звучит естественно.

Ошибка не здесь, а в той статье, что привёл Jordan:

Сравнение D и Rust
http://versusit.ru/rust-vs-d

Посмотрим теперь, как будет выглядеть код, выводящий числа от 0 до 10. На Rust это будет так:

fn main() {
   for 100.times {
     io::println("Hello");
   }
}

На D аналогичный код бы выглядел следующим образом:
void main() {
  for (int i = 0; i < 10; i++) {
      writeln("Hello");
 }   
}

Код: [Выделить]

   for 100.times {
     io::println("Hello");
   }
Выводит Hello 10 раз, но из написанного это непонятно. Откуда взялось 100 и time?

Тут обращать на другое нужно внимание.. - здесь как "вРуби" значение (число 100) является сложным обьектом...  , что для меня , например, достаточно непривычно...

А я уже привык, хоть и не рубист...

[ilovb]

Тут обращать на другое нужно внимание.. - здесь как "вРуби" значение (число 100) является сложным обьектом...  , что для меня , например, достаточно непривычно...

Причем непонятно, чем это лучше "times(100)"... Похоже на очередное ООП головного мозга - должны быть объекты и их методы через точечку.

Я тоже раньше думал что ересь. Но поимев некоторый опыт на Lua понял таки в чем профит.

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

form_module = BOM..assert(form_struct.read(3)):sub(2, -2):gsub('""', '"')

form_struct.read(3) - читаем некую строку
:sub(2, -2) - обрезаем по одному символу слева и справа
:gsub('""', '"') - заменяем удвоенные кавычки

[ilovb]

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

[vlad]

Я тоже раньше думал что ересь. Но поимев некоторый опыт на Lua понял таки в чем профит.

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

По поводу "естественности" можно поспорить.

a().b().c() vs c(b(a()))

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

P.S. Хотя в копилку "методы с точкой"  можно положить автокомплит

[ilovb]

Все познается в сравнении: 

form_module = BOM..assert(form_struct.read(3)):sub(2, -2):gsub('""', '"')

form_module = BOM..gsub(sub(assert(form_struct.read(3)), 2, -2), '""', '"')

[vlad]

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

Ага. Смотрится крайне неестественно

[valexey_u]

Глупости какие. Что мешает сделать инфиксный оператор который будет сцеплять выражения?

Ну, то есть точка нафиг не нужна, нужно чтобы просто функция times возвращала значение. См. тот же operator << для того же cout'а в плюсцах. Ну или там + какой-нибудь.

[ilovb]

А как это должно выглядеть? Что-то не очень понимаю.
Хотя нафига в Rust for нужен я тоже не понял.

В Ruby то все просто:
count.times {print " hello! "}

[ilovb]

См. тот же operator << для того же cout'а в плюсцах.

И чем это лучше точки?

[valexey_u]

См. тот же operator << для того же cout'а в плюсцах.

И чем это лучше точки?

Тем, что это не в языке.

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

[Geniepro]

Я частенько тоже в хацкеле так делаю, хоть это и не ООП-язык:

Код: [Выделить]

process fname = do
    putStrLn $ "Processing " ++ fname ++ " ..."
    dat <- readFile fname
    let dat2 = dat
            |> lines
            |> map     (map (\c -> [c]))
            |> map     (map (\s -> if s == "\t" then "\t0" else s))
            |> map     concat
            |> map     words
            |> filter  (\xs -> length xs > 6)

            |> map     (\(time: inorg:incompr:intransm:outorg:outcompr:outtransm:_) ->
                         (time,[inorg,incompr,intransm,outorg,outcompr,outtransm]))

            |> map     (\(time, xs) -> (take 2 (if length time == 5 then '0':time else time)
                                       ,map (read :: String -> Int) xs))

            |> groupBy (\(t1, _) (t2, _) -> t1 == t2) -- сгруппируем по часам
            |> map     (\xs -> (fst $ head xs, map snd xs))

            |> map     (\(time, xs) ->
                         (time, map (\[inorg,incompr,intransm,outorg,outcompr,outtransm] ->
                                      (inorg,incompr,intransm,outorg,outcompr,outtransm)) xs))

            |> map     (\(time, xs) -> (time, unzip6 xs))

            |> map     (\(time, (inorg,incompr,intransm,outorg,outcompr,outtransm)) ->
                         (time, [inorg,incompr,intransm,outorg,outcompr,outtransm]))

            |> map     (\(time, xs) -> (time, map sum xs))

            |> map     (\(time, xs) -> (time, map (\x -> trunc3 $ fromIntegral x / (1024*1024::Double)) xs))

            |> map     (\(time, xs) -> unwords' (time:(map show xs)))


    writeFile (fname ++ ".out") $ unlines dat2Здесь оператор |> создаёт конвейер типа как pipe в юниксовой консоли. Его можно по сути считать в данном случае точкой, разделяющей объект и вызов его метода в том же Расте.

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