Подскажите перспективный ЯП, которому требуются батарейки

С -fno-exceptions перестаёт адекватно работать new. А почему - пытливый читатель догадается сам. Анонимус постом выше намекает.

Если внимательно прочитать введение, то там должен быть код разбора файла, а не только про стэки. А какая там версия языка - не имеет значения.

Замечательный ответ. А теперь расскажи как с -fno-exceptions сможет работать любой конструктор, если не сможет проинициализировать объект.

Если внимательно прочитать введение, то там должен быть код разбора файла, а не только про стэки. А какая там версия языка - не имеет значения.

Ну так об этом и речь :-) Если тот код, что там приведён (глава 6, если я правильно помню) представить на чистом Си, то никакой разницы в «высокоуровневости» видно не будет :-) Ну ладно, на цепепе можно писать на чуть-чуть более высоком уровне, чем на Си :-)

Замечательный ответ. А теперь расскажи как с -fno-exceptions сможет работать любой конструктор, если не сможет проинициализировать объект.

Молча :-) Лол :-) В чём вопрос, собственно? :-)

Если молча вернуть управление вместо передачи ошибки это нормально, то вопросов нет.

Кроме костылей типа errno или выбрасывания исключения способа сообщить наверх об ошибке у конструктора нет.

Кроме костылей типа errno или выбрасывания исключения способа сообщить наверх об ошибке у конструктора нет.

#include <cassert>

struct Foo {
  Foo(int e = 0) { if (e) set_error(e); }
  void set_error(int e) { err = e; }
  int error() const { return err; };
private:
  int err{0};
};

int main()
{
  Foo foo1;
  assert(!foo1.error());

  Foo foo2{10};
  assert(foo2.error());
}

Подход куте, если не ошибаюсь :-) Адептам нравится :-)

errno на батарейках. В общем хрень это в виде «забудьте про инварианты». Но работать будет.

+1 за crystal: язык сделан для людей, у него очень наглядный и лаконичный синтаксис языка Ruby, при этом crystal компилируется в очень быстрый код и в бенчмарках показывает скорость на уровне C++, а иногда и C.

Сам на неделе начал писать библиотеку для взаимодействия с Zabbix API.

Там на главной больше закорючек, чем в расте, который вы хейтите.

Мне всегда казалось, что boehm gc - это игрушка.

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

Вброс же.

У автора кончились батарейки.

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

Вот примерно так как тут я сделал поддержку в API и для включенных и для выключенных исключений. https://github.com/dzidzitop/libafc/blob/master/src/afc/json.hpp#L74

Мне всегда казалось, что boehm gc - это игрушка.

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

Любая программа на C++ где есть хоть один вызов new (явный или нет) использует исключения.

Если только она не собрана с -fno-exceptions

В CCL точный сборщик мусора, в SBCL - почти точный (консервативен только на стеке). Думаю, что в нормальной жабе - тоже точный (иначе вряд ли была бы она пригодна для серверов). Причём тут два стула? Просто разный уровень зрелости.

Почти любая программа на C++, собранная с -fno-exceptions, использует исключения.

Для примера: http://en.cppreference.com/w/cpp/container/vector/vector

секция Exceptions.

Вопрос знатокам: какое будет поведение в случае -fno-exceptions и какая программа его будет учитывать?

Мой вариант ответа - UB будет, поскольку в стандарте не описан C++ без механизма исключений.

Не обязательно UB. GCC вызовет abort().

Закорючки - это то, что после «http» не иначе как? Остальное вполне стройно и логично, далеко не «<a' <>>» в Русте. Вообще использовать «угловые» скобки - какой-то дичайший моветон, который мог прийти в голову только совсем прожжёным технарям без малейшего представления об эстетике.

# A very basic HTTP server
require "http/server"

server = HTTP::Server.new(8080) do |context|
  context.response.content_type = "text/plain"
  context.response.print "Hello world, got #{context.request.path}!"
end

puts "Listening on http://127.0.0.1:8080"
server.listen

А msvc вызовет exit(). А clang не вызовет ничего, а вернёт nullptr. А мой компилятор отформатирует 5" НГМД на компьютере пользователя.

Это и есть UB. Хотя если стандарт что-то пишет на этот счёт, то любопытно было бы прочесть.

Это другой UB. man Undefined vs Unspecified.

использовать «угловые» скобки - какой-то дичайший моветон

В crystal они используются для наследования.

Но самопровозглашенных эстетов не переубедить.

А смысл от hello world? Давайте что-то сложнее. Например:

if (a = @a).responds_to?(:abs)
  # here a is guaranteed to respond to `abs`
end

case {value1, value2}
when {.even?, .odd?}
  # Matches if value1.even? && value2.odd?
end

def foo(
  # These are positional arguments:
  x, y, z = 1,
  # This is the splat argument:
  *args,
  # These are the named arguments:
  a, b, c = 2,
  # This is the double splat argument:
  **options
  )
end

class Employee < Person
  def initialize(@name : String, @company_name : String)
  end
end

@[Flags]
enum IOMode

def some_proc(&block : Int32 -> _)
  block
end

twice &->say_hello

@[ThreadLocal]
@@values = [] of Int32

Действительно, никаких закорючку. Просто вершина элегантности.

В crystal они используются для наследования.

Это не скобка, это кончик стрелки, показыващий, от чего и что наследует. Я когда увидел эту стрелку (а было это применительно к Julia) - у меня и близко не было сомнений относительно её назначения. Т.е. ну как ещё можно прочитать «class Child < Parent» ?

Насчёт case'а, например - а что является аналогом в Rust'е, позволящем вычислять логические условия when над произвольным количеством значений за один присест?

Со splat-аргументами пока не сталкивался, каюсь, но относительно странности «@» и «@@» соглашусь - да, это неудачное заимствование из Ruby, без предваритальной подготовки читать это трудновато.

Но в целом даже с приведёнными закорючками - код выглядит весьма чистым и лаконичным, пусть и загадочным. Код на Rust при этом выглядит просто мерзким, здесь вообще не в его загадочности дело.

Вот это:

if (a = @a).responds_to?(:abs)
  # here a is guaranteed to respond to `abs`
end

- неочевидно разве что в части использования т.н. «символов» (этого самого abc), а так вполне обычная конструкция в любом языке и в Rust'е наверняка тоже.

Кстати, жаль, что в Crystal нет methods из языка Julia - очень не хватает его на фоне отсутствия также присутвующей в Julia мощнойй внутренней системы документации по языку.

Julia

Там и так библиотек хватает: https://pkg.julialang.org , по крайней мере тех, которые он хочет писать.

про это вообще стандарт молчит. Т.е. без exceptions - это не C++, а очередной диалект.

Julia для языка,созданного серьёзными людьми и не программистами по роду основной деятельности - для своих коллег по научной среде - язык откровенно волюнтаристкий и авантюристкий: он переделывается с каждым новым предрелизом, причём изменения просто колоссальные, и отнюдь не в фуункциональной его части. Для языка, который пилят уже вроде как 7-й год - это очень странно. Т.е. если бы он был ориентирован сугубо на программеров, желающих получить некий идеально продуманный по части синтаксиса инструмент - это было бы оправдано. Julia же ориентирована на тех, кто по роду деятельности никак не может переписывать свой код с выходом каждой новой версии и мирриться с тем, что используемые им библиотеки сначала резко ломаются с переходом с 0.5 на 0.6, потом через полгодика всё вроде бы стабилизируется, потом выходит 0.7,в котором опять куча breaking changes - и вот уже нужно опять начинать жизнь с начала. В научной среде такие вещи не любят, поэтому и пакетов для Julia за 7 лет его существования создано всё равно намного меньше, чем для R за то же время.

https://crystal-lang.org/docs/syntax_and_semantics/splats_and_tuples.html

Забавно, про splat'ы (способ указания на необходимость работы со списком аргументов переменной длины) читал и помнил какое-то время - а потом вывалилось из головы. Для меня конечно «*» - это разыменование указателя, ничего не могу с этим ретроградством поделать.

Да, с эстетикой тут не очень...

def foo(
  # These are positional arguments:
  x, y, z = 1,
  # This is the splat argument:
  *args,
  # These are the named arguments:
  a, b, c = 2,
  # This is the double splat argument:
  **options
  )
end

Что за язык? Это и есть crystal?

Складывается ощущение, что из языков программирования вы знакомы только с Python, Qt-шным вариантом C++ и Rust-ом.

Как я понял, они хотят убить сразу выводок зайцев: и простота, и лаконичность, и быстродействие, и «авто-параллелизм»... И всё — из коробки. А в этом случае, как известно, то хвост тонет, то уши вянут :)

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

А так да, у меня есть опыт работы только с этими двумя ЯП. С питоном и руби довольно маленький опыт. Одни скрипты.

ЧЯДНТ?

Да. Примеры из оф. доки. Можете представить, что будет в пользовательском коде.

Т.е. ну как ещё можно прочитать «class Child < Parent» ?

Как оператор сравнения?

Насчёт case'а, например - а что является аналогом в Rust'е, позволящем вычислять логические условия when над произвольным количеством значений за один присест?

При чём тут раст? Это вы заливали про элегантность и отсутсвие закорючек. А теперь отнекиваетесь.

C++, вроде как, мультипарадигмальный, а значит никто не заставляет использовать исключения.

Насчёт case'а, например - а что является аналогом в Rust'е, позволящем вычислять логические условия when над произвольным количеством значений за один присест?

Match в Rust — это pattern matching, а не только case как в Crystal. Конкретно по твоему вопросу ответы здесь Extra Conditionals with Match Guards

match (x, y) {
    _ if x.is_even() && y.is_odd() => (), // matches if x.is_even() && y.is_odd()
}

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

Так это типичный C/C++ синтаксис с небольшой примесью OCaml.

Синтаксис Crystal, насколько я помню, пытается максимально точно скопировать синтаксис Ruby. А у Ruby, если не брать места, где Ruby пытается копировать Perl, синтаксис довольно-таки логичный и продуманный для динамически типизированного ЯП. Там после первого знакомства и объяснения, для чего и как используются символы вроде :, @ и ?, все быстро встает на свои места.

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

А так да, у меня есть опыт работы только с этими двумя ЯП.

Ну тогда вам сложнее понять, почему многим синтаксис Rust-а не сильно нравится. Когда знакомишься с разными языками, то начинает вырабатываться какой-то навык по их изучению. Который a) упрощает вход в новый язык и b) позволяет более толерантно относиться к особенностям синтаксиса разных языков.

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

Хотя, наверное, со стороны приверженцев OCaml-ов и Haskell-ей в Rust-е все хорошо. Но там совсем уж деформация психики ;) (шутка, только шутка).

Т.е. ну как ещё можно прочитать «class Child < Parent» ?

Как оператор сравнения?

А в C++ тогда как прочитать class Child : Parent? Как оператор деления?

Как оператор деления?

Оператор деления /, ваш кэп.

Не использовать исключения означает не использовать new/delete, STL, «умные» указатели, (до определённой степени) перегрузку операторов, локали и пр. В общем всё, что не помечено явно как noexcept или где есть указание, что исключения не бросаются.

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

Хотя, наверное, со стороны приверженцев OCaml-ов и Haskell-ей в Rust-е все хорошо

Для меня как приверженца OCaml и Haskell (и C++) в Rust всё плохо. Точнее не всё, а именно синтаксис, почти отбивает желание пользоваться.

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

Я с такой проблемой не сталкивался. Для меня синтаксис раста вполне продуманный и никаких проблем с этим у меня не возникало.

Rust-а как можно больше выразить одиночными символами

Можно конкретные примеры, ну кроме лайфтаймов?

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

Моей первой мыслью было «зависит», а не «наследуется».

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

Логика/0

Можно конкретные примеры, ну кроме лайфтаймов?

Ну, по поводу одиночных символов — это утрирование и гиперболизация, но вот fn вместо func или function, а так же mut вместо mutable — что же это еще, как не экономия на спичках? Или i32 вместо int32.

Моей первой мыслью было «зависит», а не «наследуется».

А наследование — это и есть одна из самых жестких форм зависимостей.

Куча проектов не использует исключения

Толпы разработчиков таких проектов могут просто не отдавать себе отчета о том, что же они делают в таких проектах и каковы могут быть последствия. В особенности, если они используют контейнеры из STL и не используют у себя two phase init (в той или иной его форме).

Зачастую такие разработчики говорят «нас устраивает std::abort вместо проброса исключения» и, одновременно, «а вот KDE падает».

Единственное исключение в KDE/Qt - это bad_alloc. Нет?