Мое новое изобретение.

[windows]
window_caption = ""

[linux]
window_caption = ""

и этот ненавидимый мною delphi/pascal синтаксис := (присваивание)

Тебе срочно надо к врачу.

Но такое несложно обрабатывать специальным парсером без всяких Lua

Авторы луа предлагают не изобретать парсер, а использовать луа, это тоже несложно)

Зачем например циклы нужны в конфигах — не понятно. А они могут повесить программу на этапе чтения конфигов и надо будет долго искать что не так.

Да мало ли? Файлы из каталога перебрать или диапазон значений перепробовал. Портов, там. Например настройка: «использовать порт Х, а если занят, то Х+1 или плюс два и так далее» именно как возможное значение параметра порт. Имеет право быть. Тебе дают такую возможность, хочешь, не используй. И это все без дополнительных трудозатрат для автора основной программы.

А насчёт повешать: ты ж из си вызываешь. Читай с тайаутом или в отдельном потоке, если хочешь

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

ненавидимый мною delphi/pascal синтаксис := (присваивание) если есть общий формат операции присваивания просто =

:= для присвоения нисколько не более упорото, чем == (и, тем более ===), для сравнения. Странная претензия

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

Щас оброню немного мудрости: в языках программирования есть условия

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

И размер кода раздувается в два раза

Сейчас я оброню еще немного мудрости: можно в одном месте написать функцию проверки и потом многократно ее использовать, не проверяя каждый раз можно ли умножать эти данные, не строка ли это :) таким образом код не разбухнет

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

Поэтому C + Lua, ибо оба-два простые в доску и там нет неожиданностей. В этих ваших ЖСах и прочих плюсах все время все меняется постоянно что-то новое: если всю жизнь учить – все равно не выучишь. Оттого и неожиданности возникают. Луа – он ожиданный

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

Спасибо.

Анон уже скинул.

Шоб не обосраться в условии поставив = вместо ==

В этих ваших ЖСах и прочих плюсах все время все меняется постоянно что-то новое: если всю жизнь учить – все равно не выучишь.

Да ничего там не меняется уже. После async уже не было ничего ломающего, добавили сахарка и всё.

Луа – он ожиданный

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

+n медитаций (енумерейты не нужно)

(function()
  local base = CroApp.GetBank():GetVocabulary():GetBase("XX")  if !base then return nil end
  local v=0,rst = base.RecordSet  if !rst then return nil end
  rst:Sort{{field=5,descent=true},{field=7},{field=10}}
  for rec in rst.Records do v = v + 1
    arrSimpleConv[v] = { 
                         Type = rec:GetValue(5),
                         LegName = rec:GetValue(10),
                         PickName = rec:GetValue(11),
                         FlagHierarch = tonumber(rec:GetValue(30)),
                         Rules = (function(B) local a={}
                                for i,p in ipairs(B) do a[i] = table.unserialize(p)end
                                return a end)(rec:GetValue(20, 0))
                       }
  end  
end)()	

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

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

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

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

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

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

Анон уже скинул.

И как, заходит ?

Да ничего там не меняется уже. После async уже не было ничего ломающего, добавили сахарка и всё

То ли еще будет. Ну JS ладно еще(не считая фреймверков), но плюсы поехали кукухой – выучить анрил.

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

да не надо ему развиваться. Он готов. Одной из киллерфич позиционируется минималистичность, расширять == вредить.

На дистанции выпрут или жсники, или еще кто-нибудь с более удобным синтаксисом

ЖСники – может быть потеснят, но бьюти оф симплисити ЖСники не потянут. В Луа влюбляются, в ЖС – ну да.. норм, но не то :)

а луа станет как паскаль, который есть, ну потому что всегда тут был

не самая плохая судьба, даже если и так.

Не очень дальновидная стратегия, кмк.

вот давай встетимся через 10 лет и через 20. посмотрим на ЖС и на Луа. ЖС, конечно будет, но будет совсем не тот, что сегодня (вспомни его 10, 20 лет назад), а Луа как был Луой так и останется (вспомни его 10, 20 лет назад)

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

тогда какие вопросы к := ?

кроме того в написании := тоже возможны опечатки.

это как? при присвоении компилятор заругает, если = вставишь

В скриптах нумеруются с 1, в коре – с 0. В результате пляски с бубном. Найс интеграция.

Не то, чтобы критично, просто если нумерация с 1 ниоткуда не следует, то она не нужна, а нужна такая какая в основном коде (а он или на C или C++ чаще всего).

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

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

Проблема как бы даже не в том, что K&R с бухты-барахты решили использовать знак тождественности для присваивания (чего до них никто не делал), а в том, что в Си и производных у присвоения есть результат. Так-то можно привыкнуть и к «=», и к «<-», и к ":=", но привыкнуть к возврату значения присвоением практически невозможно.

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

Почему?

то можно привыкнуть и к «=», и к «<-», и к «:=», но привыкнуть к возврату значения присвоением практически невозможно.

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

но привыкнуть к возврату значения присвоением практически невозможно

Почему?

Потому что оператор сравнения имеет такой же символ, но более длинный. Поди разбери при поверхностном чтении, один там знак тождества, два, или три, как в JS.

Это потому-что это императивщина. В языках цивилизованных же, каждое выражение что-то возвращает

Мы сейчас обсуждаем оператор присвоения — в «цивилизованных» языках его просто нет, потому сравнение не имеет смысла.

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

И? Как это связано с тем, что НЕВОЗМОЖНО привыкнуть к тому, что у операции присваивания есть результат? У операции сравнения нет результата или что?

По каким критериям ты оцениваешь эту НЕВОЗМОЖНОСТЬ. А так же как это твое представление коррелирует с тем, что у всех нормальных людей никаких проблем с пониманием того, что любые expression statement имеют результат?

Поди разбери при поверхностном чтении, один там знак тождества, два, или три, как в JS.

Ты несешь какую-то дичь. > | >> | >>>, < | <<, ( | (( | (((, | и || , & и && тебя не смущают случаем?

Ты несешь какую-то дичь. > | >> | >>>, < | <<, ( | (( | (((, | и || , & и && тебя не смущают случаем?

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

И? Как это связано с тем, что НЕВОЗМОЖНО привыкнуть к тому, что у операции присваивания есть результат? У операции сравнения нет результата или что?

Нельзя привыкнуть безупречно корретно читать и писать такую программу. Сколько бы ты не тренировался — а все равно напишешь один знако вместо другого. Лично ты, конечно же, скажешь «как я мог допустить такую глупую ошибку — такого больше не повторится», и все равно повторишь ее, потому что язык провоцирует совершение ошибок и ничего с этим не поделать.

язык провоцирует совершение ошибок

Я тебя услышал, выводы о тебе я сделал. Успехов.

Сложно тебе наверное жить в мире с парными буквами в словах.

но привыкнуть к возврату значения присвоением практически невозможно

К a = b = c = 5; долго привыкал?

В Сяшке и причастных проблема(али препятствие свалиться сложную простоту apl|форта|легион_таких) в «спирали» парсинга дефиниции типа терма :)

привнесённая сложность ибо 80% важнее (20%)**7 :)

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

Я пишу на Си уже давно, но все равно раз от раза делаю эту ошибку.

-Wall

Да, а что? Считаю дурным тоном писать так.

Потому что.

Просто уточнение: в Lua нет :=. Не для тебя, для других забредших в этот тред.

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

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

языки с «операторами и операндами», процедурками : наоборот – оператор без побочных эффектов обычно.

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

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

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

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

funnelWeb какой-нибудь это метасистема грамотного программирования на уровне текстов. где текст в текст вместо модель в модель. поскольку сам макроязык фуннельвебовый более мета чем например сивебовый то это мета выражено более. то есть weave/tangle по сути метакомпилятор метамета языка с двумя потоками доки/текста(кода|данных=продуктов в fw) в метаязыки документации и кода/данных.

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

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

векторный гипертекстовый жупитер нотбук какой-то, например. сам на себе

#include <stdbool.h>

int main()
{
        int a = 1;
        int b = 2;
        if (false == (a = b))
                return 1;
        return 0;
}

$ gcc -Wall wall.c
$

Еще скажи, что мне нельзя ставить скобки в булевых выражениях.

Скобки блочат варринг.

Столяров у себя в книжках это сформулировал таким образом

Дальше не читал.

Столяров у себя в книжках это сформулировал таким образом: «язык Си весь построен на побочных эффектах», по сути вся сишка это один мега побочный эффект

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

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

Во-первых, в Си, в отличие от фортрана и кобола, есть истинные локальные переменные. Потому на Си можно писать программы обработки рекурсивных структур, в том числе сам компилятор Си. То, что K&R бездарно реализовали работу с локальными переменными и сделали больше упора на глобальные переменные — это, опять же, совпадение, а не целенаправленный труд.

метасистемный переход Турчина это коэволюция бутстрап системы человекомашинной в такую вот мета среду на мета уровне

Прекращай жрать спиды.

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

У вас он гораздо красивее выглядит, безусловно.

Только что-то не компилируется.
Ни в кроносовском диалекте 5.1, ни в настоящем ArchLinux /usr/bin/lua5.2, /usr/bin/lua5.3, /usr/bin/lua5.4

Наверное у вас какой-то специальный диалект. И оператор ! ему не нравится, и присвоение в local не хочет понимать. Или я что-то совсем не то делаю.

+1 медиация (сохранилась ли? семантика полузабытого кодеца)

«скоропись»

s_\!_not _g

подразумев(ал|ется|атся) :

(function()
  local base = CroApp.GetBank():GetVocabulary():GetBase("XX")  if not base then return nil end
  local v=0,rst = base.RecordSet;  if not rst then return nil end --;?!
   rst:Sort{{field=5,descent=true},{field=7},{field=10}}
  for rec in rst.Records do v = v + 1
    arrSimpleConv[v] = { 
                         Type = rec:GetValue(5),
                         LegName = rec:GetValue(10),
                         PickName = rec:GetValue(11),
                         FlagHierarch = tonumber(rec:GetValue(30)),
                         Rules = (function(B) local a={}
                                for i,p in ipairs(B) do a[i] = table.unserialize(p)end
                                return a end)(rec:GetValue(20, 0))
                       }
  end  
end)()	

тот факт, что где-то там затесались побочные эффекты — это случайность.

нет, закономерность. это всё выражения состоящие в основном из побочных эффектов.

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

не поэтому. а потому что модификатор recurisve не нужен потому что выделение в стеке через alloca/чистка переменных стеком. тоже кстати, побочный эффект. во-вторых, это ещё один способ локализации побочных эффектов – стеком.

вот тут ты замыканием локализуешь побочный эффект какой?