Здравствуйте, Sheridan, Вы писали:

Ф>>При наведении на переменную курсора мыши в нормальном редакторе тебе покажут что это такое и каков его тип.
S>А сразу, без наведений этих вот уже законами запрещено чтоли? Нет, я понимаю какой нибудь итератор списка словарей — тут и правда понятнее будет auto использовать. Но, блин, на ровном месте то зачем?

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

        for(auto i=1; i < pMem->dwOSDArrSize; i++)
        {
            //calc offset of entry
            auto pEntry = (RTSS_SHARED_MEMORY::LPRTSS_SHARED_MEMORY_OSD_ENTRY)( (LPBYTE)pMem + pMem->dwOSDArrOffset + (i * pMem->dwOSDEntrySize) );

Во-вторых, явное указание типов затрудняет рефакторинг: если тебе понадобиться заменить тип возвращаемого значения, то в случае auto/var тебе достаточно сохранить интерфейс, чтобы не поломать код, который использует твою функцию или метод. А в случае явного указания типов, тебе может понадобиться поменять трилиард файлов.

Здравствуйте, vaa, Вы писали:

Ф>>>При наведении на переменную курсора мыши в нормальном редакторе тебе покажут что это такое и каков его тип.
S>>А сразу, без наведений этих вот уже законами запрещено чтоли? Нет, я понимаю какой нибудь итератор списка словарей — тут и правда понятнее будет auto использовать. Но, блин, на ровном месте то зачем?
vaa>А разве автовывод типов запрещает явное указание?
vaa>на самом деле это же высший абстракции. подразумевает что код может работать с различными подходящими типами.
При чом тут автовывод и абстраакции? Разговор про читабельность кода.

Здравствуйте, Философ, Вы писали:

Ф>>>При наведении на переменную курсора мыши в нормальном редакторе тебе покажут что это такое и каков его тип.
S>>А сразу, без наведений этих вот уже законами запрещено чтоли? Нет, я понимаю какой нибудь итератор списка словарей — тут и правда понятнее будет auto использовать. Но, блин, на ровном месте то зачем?

Ф>Во-первых, бо ́льшую часть времени оно вообще не нужно: инетесно имя переменной и её значение в текущем месте. Ну вот, например:
И как всегда мыслью по древу растекаемся, ага. А вот если бы, а вот рефакторинг, а вот представь...
Речь про читабельность и понятность кода. В строготипизированном языке типы — важны. ( ТипыТожэВажны, ага ). Скрывать типы в строготипизированном языке под автотип в ущерб читабельности и понятности, для того чтобы гиту было проще дифф выводить.... Ну, такое себе.

Ну а если уж к примеру...

        for(auto i=1; i < pMem->dwOSDArrSize; i++)
        {
            //calc offset of entry
            auto pEntry = (RTSS_SHARED_MEMORY::LPRTSS_SHARED_MEMORY_OSD_ENTRY)( (LPBYTE)pMem + pMem->dwOSDArrOffset + (i * pMem->dwOSDEntrySize) );

Давай посмотрим на оригинал (я хз оригинал ли, но явно с этого списано)

    for (DWORD dwEntry=1; dwEntry<pMem->dwOSDArrSize; dwEntry++)
    //allow primary OSD clients (i.e. EVGA Precision / MSI Afterburner) to use the first slot exclusively, so third party
    //applications start scanning the slots from the second one
    {
        RTSS_SHARED_MEMORY::LPRTSS_SHARED_MEMORY_OSD_ENTRY pEntry = (RTSS_SHARED_MEMORY::LPRTSS_SHARED_MEMORY_OSD_ENTRY)((LPBYTE)pMem + pMem->dwOSDArrOffset + dwEntry * pMem->dwOSDEntrySize);

1. Тебе пришлось дополнительно скобками оборачивать чтобы считало правильно. Вангую signed/unsigned ворнинги на этом месте.
2. Второй auto вообще только для укорачивания кода. Всё равно приводится к явному типу выражение.
3. Это работа с памятью, арифметика. DWORD тут будет всегда и всегда применяется при арифметике подобной. Менять на auto тут глупо. Ни к чему не приведет, а только ухудшит читаемость.

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

Здравствуйте, Sheridan, Вы писали:

S>Здравствуйте, vaa, Вы писали:

Ф>>>>При наведении на переменную курсора мыши в нормальном редакторе тебе покажут что это такое и каков его тип.
S>>>А сразу, без наведений этих вот уже законами запрещено чтоли? Нет, я понимаю какой нибудь итератор списка словарей — тут и правда понятнее будет auto использовать. Но, блин, на ровном месте то зачем?
vaa>>А разве автовывод типов запрещает явное указание?
vaa>>на самом деле это же высший абстракции. подразумевает что код может работать с различными подходящими типами.
S>При чом тут автовывод и абстраакции? Разговор про читабельность кода.
так абстрагирование и помогает уменьшить сложность. разве нет?
Читабельность точно не хуже, иначе бы динамические ЯП типа js, python, clojure, common lisp уже давно бы вымерли.
Если код функции умещается на экран, то вы видите всю картину целиком и ориентируетесь не только на типы но и на содержание функции.

Здравствуйте, Sheridan, Вы писали:

S>Речь про читабельность и понятность кода. В строготипизированном языке типы — важны.

Важны. И важно, что переменные получают тип при компиляции. А что автоматом — так это даже хорошо. И на читабельность кода auto (в моем случае var) не влияет никак. Вот имя переменной влияет. Я это еще после лазания по километровой распечатке программы с грузинмкими именами усвоил.

S>Скрывать типы в строготипизированном языке под автотип в ущерб читабельности и понятности, для того чтобы гиту было проще дифф выводить.... Ну, такое себе.

Причем тут версионник?

S>Давай посмотрим на оригинал (я хз оригинал ли, но явно с этого списано)

Я думал, ты Генту чинишь, а ты снова подтвердил, что являешься профессиональным виндовозом. Причем код довольно древний, еще с венгерской нотацией. Я не знаю, применяют ли ее сегодня. Но венгерская нотация и auto не очень совместимы.

S>3. Это работа с памятью, арифметика. DWORD тут будет всегда и всегда применяется при арифметике подобной. Менять на auto тут глупо. Ни к чему не приведет, а только ухудшит читаемость.

Принцип разумной достаточности никто не отменял. auto (или var) ставим, где нам удобно. Мне var при доработке програм немало времени экономила.

Ты точно не путаешь var с dynamic? Или что там в плюсах, голый void-указатель?

Здравствуйте, Privalov, Вы писали:

S>>Речь про читабельность и понятность кода. В строготипизированном языке типы — важны.
P>Важны. И важно, что переменные получают тип при компиляции. А что автоматом — так это даже хорошо. И на читабельность кода auto (в моем случае var) не влияет никак. Вот имя переменной влияет. Я это еще после лазания по километровой распечатке программы с грузинмкими именами усвоил.
Тип тоже влияет на читабельность. Точно так же придётся по коду гулять чтобы выяснить тип как ты гулял с именами.

S>>Скрывать типы в строготипизированном языке под автотип в ущерб читабельности и понятности, для того чтобы гиту было проще дифф выводить.... Ну, такое себе.
P>Причем тут версионник?
При том

Автор: Философ
Дата: 03.05.22

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


S>>Давай посмотрим на оригинал (я хз оригинал ли, но явно с этого списано)
P>Я думал, ты Генту чинишь, а ты снова подтвердил, что являешься профессиональным виндовозом. Причем код довольно древний, еще с венгерской нотацией. Я не знаю, применяют ли ее сегодня. Но венгерская нотация и auto не очень совместимы.
auto вообще с здравым смыслом несовместимо.

S>>3. Это работа с памятью, арифметика. DWORD тут будет всегда и всегда применяется при арифметике подобной. Менять на auto тут глупо. Ни к чему не приведет, а только ухудшит читаемость.
P>Принцип разумной достаточности никто не отменял. auto (или var) ставим, где нам удобно. Мне var при доработке програм немало времени экономила.
Где удобно, я так и писал. Но не везде подряд.

P>Ты точно не путаешь var с dynamic? Или что там в плюсах, голый void-указатель?
Точно.

Здравствуйте, vsb, Вы писали:

vsb>fmt.Errorf не добавляет стектрейса. Есть всякие старые пакеты, которые добавляют, но они типа unmaintainable. В общем гоферам стектрейсы не нужны. Что им мешает сделать какой-нибудь GO_FMT_ERRORF_ADD_STACKTRACE_PRETTY_PLEASE=IUNDERSTANDPERFORMANCEIMPLICATIONS я не понимаю.

А куда он должен его добавлять?

vsb>:= абсолютно упоротая конструкция. Зачем она нужна в текущем виде — я вообще не понимаю.

Для автовывода типа переменной.

vsb>Вот только что столкнулся. Угадайте, чем отличается log.Print от log.Println. На стековерфлу не подглядывать, только в godoc-и:

log — какой-то бессмысленный пакет. Плохо продуманный.

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

Здравствуйте, vaa, Вы писали:

S>>При чом тут автовывод и абстраакции? Разговор про читабельность кода.
vaa>так абстрагирование и помогает уменьшить сложность. разве нет?
Нет. Вспомни как тут не любят плюсовые шаблоны. А уж про define так вообще лучше не напоминать — вонь будет обеспечена.

vaa>Читабельность точно не хуже, иначе бы динамические ЯП типа js, python, clojure, common lisp уже давно бы вымерли.
ВНЕЗАПНО, в них есть типы.

vaa>Если код функции умещается на экран, то вы видите всю картину целиком и ориентируетесь не только на типы но и на содержание функции.
Ну не всем везёт писать скрипты. Многие тут пишут довольно объёмный софт.

Здравствуйте, Sheridan, Вы писали:

S>А что за мода везде auto пихать? Всё настолько плохо что нет понимания какой тип будет у переменной?

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

S>Нет, я понимаю что тот же тип итератора может полторы строки занимать, но есть же typedef или даже #define в конце концов.
S>Почему auto? Почему код запутываете специально?

А то, что в C++ иные типы на экране в ширину не помещаются, добавляет дополнительного смысла.

Я бы, правда, убил авторов C++ за то, что переменная типа auto не становится в точности того типа, какой ей присваивают при инициализации, а вместо этого компилятор умничает — если тип выражения int&, то переменная будет int.

Здравствуйте, Pzz, Вы писали:

S>>А что за мода везде auto пихать? Всё настолько плохо что нет понимания какой тип будет у переменной?
Pzz>Потому, что чем меньше у тебя в тексте копий одного и того же знания (в данном случае, знания о типе выражения, которое ты пытаешься засунуть в переменную), тем проще потом этот код будет менять.
Код менять проще когда он понятный и читабельный. Автотипы наоборот, делают код менее понятным. Иногда более читабельным, но далеко не всегда.


S>>Нет, я понимаю что тот же тип итератора может полторы строки занимать, но есть же typedef или даже #define в конце концов.
S>>Почему auto? Почему код запутываете специально?
Pzz>А то, что в C++ иные типы на экране в ширину не помещаются, добавляет дополнительного смысла.
Вот сюда можно и auto, хотя лично я предпочитаю typedef или define. Но не везде же подряд.


Pzz>Я бы, правда, убил авторов C++ за то, что переменная типа auto не становится в точности того типа, какой ей присваивают при инициализации, а вместо этого компилятор умничает — если тип выражения int&, то переменная будет int.
Ещо один аргумент против автотипов.

Здравствуйте, Pzz, Вы писали:

vsb>>fmt.Errorf не добавляет стектрейса. Есть всякие старые пакеты, которые добавляют, но они типа unmaintainable. В общем гоферам стектрейсы не нужны. Что им мешает сделать какой-нибудь GO_FMT_ERRORF_ADD_STACKTRACE_PRETTY_PLEASE=IUNDERSTANDPERFORMANCEIMPLICATIONS я не понимаю.

Pzz>А куда он должен его добавлять?

В создаваемую ошибку.

vsb>>:= абсолютно упоротая конструкция. Зачем она нужна в текущем виде — я вообще не понимаю.

Pzz>Для автовывода типа переменной.

Для этого есть var.

Здравствуйте, vsb, Вы писали:

Pzz>>А куда он должен его добавлять?

vsb>В создаваемую ошибку.

Ты имеешь ввиду в строку, или куда?

vsb>>>:= абсолютно упоротая конструкция. Зачем она нужна в текущем виде — я вообще не понимаю.

Pzz>>Для автовывода типа переменной.

vsb>Для этого есть var.

На практике, слово var встречается довольно редко. Когда переменную продекларивовать надо, а проинициализировать нечем.

Здравствуйте, Sheridan, Вы писали:

Pzz>>Потому, что чем меньше у тебя в тексте копий одного и того же знания (в данном случае, знания о типе выражения, которое ты пытаешься засунуть в переменную), тем проще потом этот код будет менять.
S>Код менять проще когда он понятный и читабельный. Автотипы наоборот, делают код менее понятным. Иногда более читабельным, но далеко не всегда.

Ну так всюду и не надо. Предполагается, что человек — разумное существо.

Pzz>>Я бы, правда, убил авторов C++ за то, что переменная типа auto не становится в точности того типа, какой ей присваивают при инициализации, а вместо этого компилятор умничает — если тип выражения int&, то переменная будет int.
S>Ещо один аргумент против автотипов.

Против C++, он весь такой

Здравствуйте, night beast, Вы писали:

НС>>А ты попробуй без, может это иллюзия.

NB>в данный момент в основном на питоне работаю, так что есть возможность сравнить.

В питоне даже компилятор не знает тип. А вот если кто-то из вас знает (ты или компилятор), то возможно именно тебе-то знать и не обязательно

Здравствуйте, Ночной Смотрящий, Вы писали:

НС>У тебя часто так бывало, что int стал float? У тебя вообще часто тип float в программах встречается? Какой процент от общего количества использований типов составляет float?

В JS такое бывает. Там все числа — float.

Здравствуйте, Sheridan, Вы писали:

S>Ты пойди пойми какой тип когда все они определены через var/auto все и инициализируются в "момент присваивания" (да, да в момент компиляции, но глазами видно именно так). Предлагаешь ковырять код вверх по вызовам до места где будет понятно какой тип будет у переменной? Вместо того чтобы посмотреть в начало этой же строки — копать? Спасибо, можно без соли. Всё равно несъедобно.

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

Здравствуйте, Pzz, Вы писали:

Pzz>>>А куда он должен его добавлять?

vsb>>В создаваемую ошибку.

Pzz>Ты имеешь ввиду в строку, или куда?

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

https://pkg.go.dev/golang.org/x/xerrors вот этот пакет был прототипом этого функционала в стандартной библиотеке го, можно посмотреть, как там сделано. На предложение использовать этот или подобный пакет сразу отвечу, что я не люблю писать не-идиоматический код, а в го — особенно.

vsb>>>>:= абсолютно упоротая конструкция. Зачем она нужна в текущем виде — я вообще не понимаю.

Pzz>>>Для автовывода типа переменной.

vsb>>Для этого есть var.

Pzz>На практике, слово var встречается довольно редко. Когда переменную продекларивовать надо, а проинициализировать нечем.

var x = value это валидный го-код. И var x1, x2 = value1, value2. Одно из отличий в том, что с := можно объявить одну переменную, когда вторая уже объявлена, ну ок, это может быть удобно. Но удобно это было бы, если бы := в принципе работала, как универсальная конструкция, позволяющая либо объявлять, либо присваивать значение. Но она так не работает. И порой приходится проходить по коду и заменять := на = из-за того, что сверху объявили переменную с таким именем. В общем единственное отличие и то наполовину бесполезное.

Здравствуйте, Ночной Смотрящий, Вы писали:

НС>Все, очевидно, не могут быть определены через var, хотя бы в одном месте должен быть указан тип. А вот вся остальная цепочка, если ее можно вывести формально — забота компилятора. Зачем ты непременно за компилятор поработать хочешь — непонятно.

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

Здравствуйте, vsb, Вы писали:

vsb>Errorf возвращает объект, в котором есть строка с описанием ошибки и ссылка на предыдущую ошибку. Вот в этот объект надо добавить еще поле со стектрейсом, полным или хотя бы caller. И распечатывать это при форматировании.

Если ты имеешь ввиду удобства, добавленные пакетом errors, то этот пакет появился сильно позже, чем fmt.Errorf.

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

vsb>var x = value это валидный го-код. И var x1, x2 = value1, value2. Одно из отличий в том, что с := можно объявить одну переменную, когда вторая уже объявлена, ну ок, это может быть удобно. Но удобно это было бы, если бы := в принципе работала, как универсальная конструкция, позволяющая либо объявлять, либо присваивать значение. Но она так не работает. И порой приходится проходить по коду и заменять := на = из-за того, что сверху объявили переменную с таким именем. В общем единственное отличие и то наполовину бесполезное.

Ну да, бывает иногда. Раздражает немного, но не так уж, чтобы ужас-ужас-ужас.

Наверное, еще пятью языками позже Пайк придумает, как и эту проблему обойти

Здравствуйте, Pzz, Вы писали:

НС>>>А ты попробуй без, может это иллюзия.
NB>>в данный момент в основном на питоне работаю, так что есть возможность сравнить.
Pzz>В питоне даже компилятор не знает тип.

в питоне есть аннотации. ну и в дебагере тоже может показывать.

Pzz>А вот если кто-то из вас знает (ты или компилятор), то возможно именно тебе-то знать и не обязательно

или нет