Тебе сильно поможет имя типа в духе:

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

Т.е. он ориентируется не на определение переменной, а на её использование?

Пример же был.

int a = 5
auto b = ...(a)...
auto c = ...(b)...
c+1

А ошибка выглядит так: пусть операция + определена для кучи типов. Может быть, с - это float и +1 будет плавающим сложением, а может быть, с - это строка и + определено как конкатенация. Значит, перед тем, чтобы понять смысл записи c+1, ты должен будешь на этапе чтения кода распарсить все auto. И компилятор тут тебе не поможет, если ты ошибся и решил, что c - это float, а оно на самом деле строка.

Другое дело, если современная ide распарсит все auto и подсветит реальный тип, но это уже автоматизация работы. Сначала нужно осознать и признать, что сама по себе работа присутствует.

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

Царь.

Может быть, с - это float и +1 будет плавающим сложением, а может быть, с - это строка и + определено как конкатенация. Значит, перед тем, чтобы понять смысл записи c+1, ты должен будешь на этапе чтения кода распарсить все auto. И компилятор тут тебе не поможет, если ты ошибся.

Иди мне скажи какие типы будут в хасскеле, а когда ты обсораёшься - ты мне скажешь, а с чего в коде с автовыводом типа тебе понадобилось знать тип?

auto r = c + 1;

На будущие всем адептам(а то чёт смотрю я на вас) - сливать этих нулей надо не споря с их высером, а уничтожая сам смысл их высера - т.е. его основание, а вернее его отсутствие. Когда основание помножено на ноль - весь высер балабола становится нулём.

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

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

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

Но если мне его ещё и придётся перед этим вычислять, через auto, то будет намного хуже.

Нет код без явного указания типов будет проще:

std::vector<std::string> strs;
std::string suffix;
auto ts = strs | transformed([&](auto s) { return s + suffix; });

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

Сначала нужно осознать и признать, что сама по себе работа присутствует.

Работа есть, вот только если писать не на C with Classes типы будут в духе того что я привёл, и это ещё простой пример. Типы генерируемые std::bind, не говоря уже о Boost.Fusion, Boost.Spirit куда как более забористые.

Работа есть, вот только если

Да неважно что «если». Вывод типов есть - код труднее анализировать. Вот и всё. Что для этой ситуации можно придумать ещё худшую ситуацию - это уже совершенно другой вопрос. То есть, у вывода типов, вообще говоря, не только одни плюсы.

Собственно типичная ситуация. Пацан пытается что-то доказать балаболу, цель которого не понять, а побалаболить. Соглашаясь с убогими выкладками, основанными на шизофрении, загоняя себя в лужу.

Ты должен разобрать, что есть b и a.

Ну я обычно не начинаю править/разбирать код с произвольного места. Как правило, когда доходишь до этого «c+1», то какое-никакое представление о происходящем имеется.

с - это строка и + определено как конкатенация

В таком виде не определено и нормальные люди сами такое определять не будут.

Сначала нужно осознать и признать, что сама по себе работа присутствует.

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

Есть ещё одна вещь - в D (и не только) вызовы a.f() и f(a) эквивалентны. В С++ тоже такое сделать хотят. И ничего страшного, как показывает практика.

Или ещё, некоторые языки позволяют такое:

let a = 1;
// ...
let a = "test";
// ...
let a = SomeObject...

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

Для меня это выглядит так же «очевидно» как если бы ты рассказывал как сложно пользоваться часами со стрелками (а не цифровыми) - ведь это надо посмотреть на положение часовой стрелки, потом минутной, потом (возможно) секундной. А если у нас ещё и числе на циферблате нет? Вообще кошмар. Но на практике все легко с этим справляются.

Небось, тоже скажешь «ужас» и что оно ошибки провоцирует? Тоже когда-то так думал пока не понял как оно удобно.

Пффффф. void* в С тоже и не такое может уметь.

void* в С тоже и не такое может уметь

Ты не понял что там написано.

Ну там было показано, что переменная может менять тип и принимать любые значения. Не?

void* в С тоже и не такое может уметь.

Да, void* тоже хотел упомянуть, но это всё-таки «немного» другое.

переменная может менять тип и принимать любые значения. Не?

Не совсем. Это будут разные переменные, как вот тут:

int a;
{
    double a;
    {
        string a;
    }
}