Говоря абстрактно - не смущает. Например, в SQL стандарты живут отдельно от жизни.

Касаемо конкретно С++ - нужно быть в теме, чтобы знать. Я не в теме, потому и спрашиваю. И что, эти отдельные фичи прямо массово используются в основном теле кода? В старых проектах люди озаботились впиливанием новых фич в код, написанный до их появления? Или используют только в новом коде?

Ну и самое главное - что изменилось в жизни сиплюсплюсника с появлением выведения типов? Стало ли жить лучше? Хуже?

И что, эти отдельные фичи прямо массово используются в основном теле кода?

Да.

В старых проектах люди озаботились впиливанием новых фич в код, написанный до их появления?

Постепенно, по мере развития старого кода.

Ну и самое главное - что изменилось в жизни сиплюсплюсника с появлением выведения типов? Стало ли жить лучше? Хуже?

Обобщённый код стал лаконичнее и нагляднее. В необобщённом сократилось дублирование имён типов.

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

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

Это умеет нормальный конпелятор автоматом.

Всё эти порядки, чистота - это кастыли, которые адепты вдруг стали называть фичами.

Типичный пример - ты написал выше. Если во вменяемом языке это будет f(a, f1(b)), то в хацкеле будет f(a, f1) - т.к. в те дремучие времена анализ кода был недостижим, то и придумали этот кастыль. Чтобы на уровне конпелятора это сводить к нормальному виду.

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

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

Бесполезно, особенно в хацкеле. Чистые функции в 95% случаев стоят меньше, чем оверхед на спавн их в параллель.

если мы знаем, что arg1 и arg2 чистые, мы можем вычислить их параллельно.

Они итак чисты, а если не чистые - они треадсейв.

И это есть итак во вменяемом конпеляторе - выделить чистоту проще паренной репы.

а если не чистые - они треадсейв.

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

если мы знаем, что arg1 и arg2 чистые, мы можем вычислить их параллельно.

Они итак чисты, а если не чистые - они треадсейв.
И это есть итак во вменяемом конпеляторе - выделить чистоту проще паренной репы.

если жизнь такая простая, то почему стандартом c++ так и не определён порядок вычисления аргументов?

то почему стандартом c++ так и не определён порядок вычисления аргументов?

А как же там разруливаются сайд-эффекты тогда?

похоже, что никак. т.е. если ты запустишь f(a(), b()), где a и b влияют друг на друга, то ты сам виноват.

Охренеть.

чтобы оставить компилятору простор для оптимизации

я не спорю, но если

И это есть итак во вменяемом конпеляторе - выделить чистоту проще паренной репы.

, то почему в стандарте с++ нет различий в порядке вычисления чистых и грязных аргументов?

Если они не чистые, они не могут быть треадсейв, так как они могут шарить общую память

Да ты прям гений нахрен. Все треды шарят общую память, но почему-то работают? Ниужели разрыв шаблона у адептов?

Весь треадсейв в текущем мире основан на костылях, а не на мистической чистоте. Т.е. память-то общая, но кто сказал, что её могут все как угодно использовать?

и порядок выполнения становиться обязательным

С чего это? Вся синхронизация основана на отсутствии порядка. Если нужен порядок - он сохраняется отдельно, и то это уже далеко не параллельное, т.е. независимое исполнение. Если у тебя есть зависимости - это уже никак не может быть свободно параллельным.

s/костылях/соглашениях в коде/

Все треды шарят общую память

а кто сказал, что они безопасно ее шарят?

адептов

не угадал, я ФП ненавижу, просто говорю то что есть.

С чего это?

f1=function(){a=10}
f2=function(){a=20}

a=null
;(function(x, y){console.log(a)})(f1(), f2())
a=null
;(function(x, y){console.log(a)})(f2(), f1())

20
10

если жизнь такая простая

Если ты нулёвый балабол - это твоя проблема.

то почему стандартом c++ так и не определён порядок вычисления аргументов?

Меня не интересует эта убогая макулатура. Меня интересует реализация. Я тебе конкретно там сказал про конпелятор, без привязки к какому-либо недоязычку.

Если ты без юлежа ответить внятно не можешь, то зачем мне с тобою разговарить?

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

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

Т.е. подход такой - давать гарантии только те, что даются бесплатно и не требует какой-то особой реализации снизу - т.е. и не определяет реализацию и в целом не полагается на существующие.

Теперь подумай, почему же твой вопрос является говном.

а кто сказал, что они безопасно ее шарят?

Чё ты несёшь? К чему ты это сказал?

Треадсейв подразумевает, что безопасно.

не угадал, я ФП ненавижу, просто говорю то что есть.

Меня не интерсует кто ты и что ты. Меня не интресует чего конкретно адепт адепт, меня лишь интересует факт того, что буду нулёвой балаболкой он позволяет себе нести несвязную херню и спорить.

портянка на неведомой, нечитаемой херне. Веб-балаболчтоли?

Что ты хотел ей доказать? Что ты хотел ей показать?

Я хоть такого никогда не говорю, но ты какой-то тотально отбитый - тебя точно врач отпустил, либо сбежал? У тебя явная шизофрения.

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

Без кастылей - это это без кастылей. Точно так же, как и кастыли для эмуляции плоской памяти и прочего.

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

А то, что таких адептов мильёны и они как-то свои кастыли согласовали - это ничего не значит.

Да никто с тобой не спорит, просто интересно было, может ли быдлосишное нечто хоть что-то распарсить. Тут таких статиккукаретиков — 99% лора, как ты умудряешься с такими мозгами еще с ними спорить о чем-то я хз. По идее, вы жопы должны друг другу вылизывать.

Треадсейв подразумевает, что безопасно.

ага, опасное — опасно, а безопасное — безопасно, мужики то и не знали.

И что, эти отдельные фичи прямо массово используются в основном теле кода?

А почему нет? Конкретно у нас в соглашениях прописано предпочитать auto явному указанию и на ревью на это указывают, если кто-то забывает. Проблем из-за этого не замечал.

На С++14 пока не перешли, да. Впрочем, кое-какие библиотечные фичи реализовали сами с перспективой замены на стандартные. Ну и буст используется.

В старых проектах люди озаботились впиливанием новых фич в код, написанный до их появления?

Зависит от проекта, за всех говорить не могу. Но существую инструменты (например, clang modernize) которые подсказывают как старый код можно переписать с учётом новых возможностей.

Хуже?

Было бы хуже - просто не использовали. Однозначно лучше. И если в «обычном коде» без auto худо-бедно обойтись можно, то в шаблонном пользы от вывода гораздо больше.

Ну ладно. Значит, есть у нас теперь пример использования вывода типов. Можно сказать так: раз в С++11 включили её, и раз она используется людьми, можно предполагать, что от неё есть польза.

нулёвый балабол

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

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

я так понял, что ты имел в виду, что в любом нормальном конпеляторе это должно быть реализовано. ну ок, тогда какой компилятор вдруг без явного объявленя чистоты функции оную определяет?

Теперь подумай, почему же твой вопрос является говном.

ага, понял

Проблема в том, что опциональная типизация резко расширяет область применения вывода типов. На самом деле те самые примеры для Common Lisp с «computer benchmark game» как раз в чём-то основаны на выводе типов.

А вообще, даже по примеру из описания С++ 11 в Википедии видно, что новшество неоднозначной полезности

#include <vector>
int main()
{
  const std::vector<int> v(1);
  auto a = v[0];        // тип a - int  
  decltype(v[0]) b = 1; // тип b - const int& (возвращаемое значение
                        // std::vector<int>::operator[](size_type) const)
  auto c = 0;           // тип c - int   
  auto d = c;           // тип d - int            
  decltype(c) e;        // тип e - int, тип сущности, именованной как c 
  decltype((c)) f = c;  // тип f - int&, так как (c) является lvalue
  decltype(0) g;        // тип g - int, так как 0 является rvalue
}

Это в примере подписаны комментарии, а как читать этот код, если комментариев нет? Нужно втыкать в каждую строчку, да ещё и есть шанс ошибиться. Получается, код становится легче писать, но труднее читать. Крайнее проявление этого явления - write only code, как раз от него вроде и Perl умер, насколько я понимаю. Это случилось не сразу, сначал Perl хорошо попёр. Потом эта проблема накопилась и капец. Хотя я не настолько в теме Perl, могу и ошибаться. В случае С++, поскольку стандарт принят 4 года назад, а развитие кода на С++ - это процесс довольно медленный, то можно сказать, что минусы вывода типов в С++ могли ещё не проявиться во всей мере.

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

Я тебе конкретно там сказал про конпелятор, без привязки к какому-либо недоязычку.

А как «конпелятор» может быть не привязан к конкретному языку? Ты уверен, что понимаешь значение слова компилятор?

очевидно, «сказал без привязки», а не «компилятор без привязки».

Да никто с тобой не спорит, просто интересно было

Естественно со мною амёба спорить не может по определению.

Тут таких статиккукаретиков — 99% лора, как ты умудряешься с такими мозгами еще с ними спорить о чем-то я хз. По идее, вы жопы должны друг другу вылизывать.

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

ага, опасное — опасно, а безопасное — безопасно, мужики то и не знали.

И опять по-существу ничего нет, только кукареку. Что ты этим хотел сказать?

Спешите видеть! Анонiмус против царя!

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

Делайте ваши ставки, господа!

Можно сказать так: раз в С++11 включили её, и раз она используется людьми

Перед включением, как правило, происходит множество обсуждений и зачастую за основу берутся уже существующие реализации (в том же бусте, например). Это, конечно, не даёт гарантии о том, что результат будет идеальным, но совсем бесполезные вещи в стандарт попадают редко.

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

Домохозяек вижу то же я, кстати. И нулёвых балаболок тоже. Да и не вижу я - у меня есть доказательная база. Если ты будешь вести себя подобающе - я тебя балаболкой называть не буду.

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

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

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

Про конпеляторы было конкретное уточнение, сверх того, что «это не нужно».

ну ок, тогда какой компилятор вдруг без явного объявленя чистоты функции оную определяет?

Умеют - гцц и шланг. Так же есть атрибуты.

Опять же попытки съехать с темы - причём тут дают чистоту. Они дают тот профит, что ты описал. Чистота твоя нахрен никому не упала.

Типичное си:

#define lambda(ret, arglist, body) ({\
  typeof(ret) __f arglist {\
    body;\
  }\
  __f;\
})

int main(void) {
  __auto_type add = lambda(uint64_t, (uint64_t a, uint64_t b), {
    return a + b;
  });
  
  void _do(typeof(add) f, uint64_t a, uint64_t b) {
    __auto_type i = 0ul;
    do {
      fprintf(stderr, "%lu\n", i);
    } while(++i != f(a, b));
  }
  _do(add, 10, 5);
}

.L2:
	movq	stderr(%rip), %rdi
	movq	%rbx, %rcx
	movl	$.LC0, %edx
	xorl	%eax, %eax
	movl	$1, %esi
	addq	$1, %rbx
	call	__fprintf_chk
	cmpq	$15, %rbx//вот она
	jne	.L2

Ты мне лучше объясни - почему сектанты-модераторы трут все мои комменты с кодом, с моим уничтожением лалок и прочим, а с лютый оффтом и мусор не трут.

Тут типичная и жалкая попытка выставить меня кем-то, кем я не являюсь. Я чую, что ты находишься в анальном владении сих питушков, либо сам и есть анонимный властелин. Ты должен знать ответ.

И да, ты пропустил. Это уже уже был 2-3-й пост такого содержания.

А вообще, даже по примеру из описания С++ 11 в Википедии видно, что новшество неоднозначной полезности

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

а как читать этот код, если комментариев нет?

Точно так же, как остальной. Ведь когда ты видишь, скажем, «int», то мысли «а как читать код, если не знаешь о существовании такого типа» почему-то не возникает.

Есть определённые правила, да местами они запутанные. Тем не менее, в большинстве случаев проблемы не возникает и хватает простого auto. decltype - он для шаблонов и без него раньше было ещё хуже.

Нужно втыкать в каждую строчку, да ещё и есть шанс ошибиться.

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

Ещё раз обращаю внимание на то, что с auto никаких неожиданностей не получилось.

Насчёт «write only» кода - посмотри внутренности буста и прочие извращения на шаблонах. Читать такое всегда было сложно, а стало наоборот легче.

поскольку стандарт принят 4 года назад, а развитие кода на С++ - это процесс довольно медленный, то можно сказать, что минусы вывода типов в С++ могли ещё не проявиться во всей мере.

Ну ведь ты фантазируешь и всячески подгоняешь результат. Во первых, поддержка auto в майкросовтовском компиляторе была уже в 2010 году. В GCC с версии 4.4, а это 2009 год. Но даже не в этом дело.

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

мы должны этот минус тоже иметь в виду.

Какой минус? Меня не оставляет ощущение, что ты подгоняешь факты под желаемый результат.

Это в примере подписаны комментарии, а как читать этот код, если комментариев нет?

Легко - если ты пишешь на крестах - ты знаешь, где rvalue, а где lvalue и какие типы возвращают операторы(функции) - почему там ссылка с decltype.

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

Нет, так всё логично, кроме этого:

decltype((c)) f = c; // тип f - int&, так как (c) является lvalue

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

Т.е. рассуждения чистого балабола.

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

Нет вася, ты просто нулёвый балабол и эти всё сказано. Естественно можно из системы типов, как в недоязычках, убрать указатели/ссылки и прочее и оставить только значения и функции.

Тебе никто не мешает их(указатели/ссылки) не юзать в с++ и будет твой хацкель. Система типов в с++ намного шире и мощнее, чем убожество в недоязычках. Естественно она сложнее.

Можешь не трудиться писать хню в мой адрес :) Я уже давно не общаюсь с анонимусом, по причине того, что он хуже электрона в металле: не имеет идентичности. Соответственно, твой пост покоится в /dev/null :)

Я, кажется, разгадал загадку царя - он вырос в женской колонии. Отсюда его уголовные повадки, бабские треп и спонтанные превращения в японских школьниц.

Как всегда нулёвая балаболка обосралась. Типичный представитель.

И да, я не анонимус. Моя идентичность на грани фантастики, поэтому идентифицировать меня может любой балабол. Даже тут ты обосрался.

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

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

Типичная коррупция. За полизать жопу всё что угодно.

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

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

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

Это так мило, но не фортанёт. Уже давно пора понять. Я так и не понял - вы либо неимоверное тупые, что до сих пор это не доходит, либо я чего-то не понимаю в вашей мотивации и вы просто обезьяны.

Объясни мне.

Ведь когда ты видишь, скажем, «int», то мысли «а как читать код, >если не знаешь о существовании такого типа» почему-то не возникает.

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

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

В коде не напишу. По смыслу: два типа, для которых определены одинаковые методы с одинаковыми параметрами. Далее программист неверно парсит auto и думает, что он имеет дело с одним типом, а на самом деле тип другой.

Ну ведь ты фантазируешь и всячески подгоняешь результат. Во первых, поддержка auto в майкросовтовском компиляторе была уже в 2010 году. В GCC с версии 4.4, а это 2009 год. Но даже не в этом дело.

Ну конкретно по С++ - я не то, что фантазирую, а просто пока я не убеждён в том, что нововведение оказалось удачным. Если ты в этом уверен, то ок. Пусть будет.

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

Спасибо, буду знать.

Меня не оставляет ощущение, что ты подгоняешь факты под желаемый результат

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

Никакой коррупции, чисто научный интерес.

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

И сам ты говорил, что среди нормальных людей не рос и в нормальной школе не учился.

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

А современные IDE ещё и ошибки в коде подсвечивают до компиляции, это ещё больший объём работы. Вообще важно знать _смысл_ типа, а не его конкретное имя. Тебе сильно поможет имя типа в духе:

transform_iterator<std::vector<std::basic_string<char, std::char_traits<char>, std::allocator<char>>, std::allocator<std::basic_string<char, std::char_traits<char>, std::allocator<char>>::const_iterator, std::function<std::basic_string<char, std::char_traits<char>, std::allocator<char>> (std::basic_string<char, std::char_traits<char>, std::allocator<char>> const&)>

По смыслу: два типа, для которых определены одинаковые методы с одинаковыми параметрами. Далее программист неверно парсит auto и думает, что он имеет дело с одним типом, а на самом деле тип другой

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

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

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

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

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

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

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

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

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

Никакой коррупции, чисто научный интерес.

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

А почему? Даже не потому, что вы тупые. Среди вас есть же люди со способностями и мозгом, но вы продукт общества. Т.е. принимая устои этого общества - пацан уничижал свою волю, т.е. априори он не был отучен сопротивляться внешнему воздействию - его приучили его потреблять и соответствовать, иначе он ламался.

Это могло бы исправить разница во мнениях, но тут то же засада. Все вы выходцы с одного конвейра, со знаниями из одной и той же макулатуры. А т.к. у 99.98% адептов «понимание» основано тупо на подражании, т.е. он не трансформирует знания в своё понимание.

Они у него в башке как набор шаблонов и использует он их как каталог с доступом по ключевым словам. Я уже рассказывал, почему у вас жопа не способно выдерживать смену терминологии и прочее.

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

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

Твой лексикон выдает в тебе представителя уголовного мира

Типичная брехня.

«пацанцы»

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

«питухи»

Там петухи - это раз. Во-вторых питухи пошли не от петухов, а от кукарекать. Чего в тюремном сленге нету, кроме как намёка на петуха.

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

«обосать»

То же никакого отношения к тюремному сленгу не имеет.

но при этом ты «не фильтруешь базар»

Я и не должен его фильтровать. Я могу обосновать свой базар. Поэтому ко мне нет никаких претензий.

и не подчиняешься строгой иерархии

В курятнике нет никакой иерархии.

как в мужских колониях

Да ты прям эксперт.

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

Какая-то брехня не связанная с реальным миром. Пацан спутал своё окружение с колонией.

И сам ты говорил, что среди нормальных людей не рос и в нормальной школе не учился.

Меня не интересует понятие «нормальности» от балаболок. Я конкретно обосновывал это понятие.

И я такого не говорил, типичное враньё. Там, где я это рассказывал - я типично описывал что есть «нормальные люди». Поэтому опять кукареку.

Про «нормальную школу» я то же ничего не говорил - это брехня чистой воды. Я говорил вообще про школу. Без её классификации.

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

Царь.

Может быть, с - это 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 куда как более забористые.

Три тарелки борща на ананiмуса.

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

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

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

Опять враньё. Ты с зоной обосрался, но сделал вид, что это типа так и есть.

Пацан - это не каста антипод петухам, а петухи не антипод пацанам.

Как ты прокомментируешь акты превращения в японскую школьницу

Там не было никакой школьницы. Опять враньё, которое сам придумал и пытаешься форсить. У тебя постоянно какая-то щизофрения. Ты будешь мне продолжать писать херню, в надежде на то, что я её признаю?

непонятный интерес к «старому быдлокодеру и троллю»?

Непонятный интерес был уже давно, но ты это пропустил. Это твоя проблема.

Далее, интерес был никакой не непонятный, а крайне понятный. Я предложил пацану подружиться, а не сраться. Почему?

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

В целом я им доволен. Я хочу дружить с пацанами, а не сраться. Ты можешь быть моим другом, если хочешь. Ты тоже, ничётак. Не совсем кря-кря, даже в своих попытках к шизофрении.

Яж-то не против разговаривать с пацанами нормально и все дела, но с условием вменяемости и осознанности. Если ты способен и согласен - я за.

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