История изменений
Исправление LINUX-ORG-RU, (текущая версия) :
Не, в lua получится вот такое
bla "con" "cat" "en" "at" "ion"
Тут можно сделать так что bla это функция которая может принимать строку «con» без указания скобок(``) обработать и вернуть саму себя или функцию которая примет «cat» и так далее до и включая «ion». А как всё это интерпретировать дело десятое.
А вот такое нельзя
bla "con" "cat" | "grep" "lala" | "grep" "lolo"
Тут bla это отметатабленная таблица, которая может быть вызвана как функция и принять «con» обработать и вернуть функцию которая примет «cat» вернёт отметатабленную таблицу которая изменит поведение (только в случае наличия себя) ‘|’ а вот дальше всё «grep» примется и будет обработан отметатабленным ‘|’ но вот на «lala» всё дрёпнется ибо оно ни к селу ни к городу.
Вот у тебя в рубях всё склеит, а у меня заругает мол это твоё «lala» это вообще куда? Всё получится если grep будет перегруженной таблицей.
Либо, делать вереницу возвратов функций и всё в строки облрачивать
bla "a" "|" "blu" "ble" "|" "e"
Либо, делать как со строками но с таблицами явными
bla {"a"} {"|"} {"blu"} {"ble"} {"|"} {"e"}
Или так, тут шило/мыло
bla {"a"} | blu {"ble"} | e
Либо, делать вызовы таблиц как функций с переопределённым оператором, как выше изначально
bla "a" | blu "ble" | e"
Может ещё как можно, но там будет своё но. В целом достаточно вариативно и гибко, но не в абсолюте конечно. А у тебя, ну значит тебе придётся какой то синтаксический разделитель на уровне языка использовать. Так же как и тут в луашке, просто выглядеть будет по другому.
Ну тут видишь как, у тебя конкатенация строковых литтералов прям как в Сишке, на этапе компиляции
printf("%s","hello\n"
"world\n");
Но вот такой побочный эффект для твоей текущей задаче что эта конкатенация мешает, а у меня наоборот вот так в луа нельзя
print("hello""world")
Но зато не мешает делать прикол что выше. Так и живём, либо-либо.
Как я обязан для конкатенации делать .. так и ты обязан наоборот разделять. Ни хорошо, ни плохо, просто по разному. Это я к тому пусть напрямую то что в голове родилось нельзя, но наверняка есть компромисс. Я вот лично предпочту мирится с некой особенностью чем из за некой особенности каждый раз менять инструмент.
И вообще, можно просто сделать как дед волосатый, прямолинейно, просто и понятно и на любом языке
resultat = pipe(command_a,command_b)
И скрыть все кишки внутри и норм и никакого извращения с DSLями, хаками и прочим. Вот у меня так часто, мудрю, мудрю, кручу верчу, запутать хочу, а потом всё сводится к просто дрыганию процедурок, а всё иное экстравагантное идёт в утиль, ну или самому себе в заметки типа «а вот так тоже можна гыыы»
Исправление LINUX-ORG-RU, :
Не, в lua получится вот такое
bla "con" "cat" "en" "at" "ion"
Тут можно сделать так что bla это функция которая может принимать строку «con» без указания скобок(``) обработать и вернуть саму себя или функцию которая примет «cat» и так далее до и включая «ion». А как всё это интерпретировать дело десятое.
А вот такое нельзя
bla "con" "cat" | "grep" "lala" | «grep» «lolo»`
Тут bla это отметатабленная таблица, которая может быть вызвана как функция и принять «con» обработать и вернуть функцию которая примет «cat» вернёт отметатабленную таблицу которая изменит поведение (только в случае наличия себя) ‘|’ а вот дальше всё «grep» примется и будет обработан отметатабленным ‘|’ но вот на «lala» всё дрёпнется ибо оно ни к селу ни к городу.
Вот у тебя в рубях всё склеит, а у меня заругает мол это твоё «lala» это вообще куда? Всё получится если grep будет перегруженной таблицей.
Либо, делать вереницу возвратов функций и всё в строки облрачивать
bla "a" "|" "blu" "ble" "|" "e"
Либо, делать как со строками но с таблицами явными
bla {"a"} {"|"} {"blu"} {"ble"} {"|"} {"e"}
Или так, тут шило/мыло
bla {"a"} | blu {"ble"} | e
Либо, делать вызовы таблиц как функций с переопределённым оператором, как выше изначально
bla "a" | blu "ble" | e"
Может ещё как можно, но там будет своё но. В целом достаточно вариативно и гибко, но не в абсолюте конечно. А у тебя, ну значит тебе придётся какой то синтаксический разделитель на уровне языка использовать. Так же как и тут в луашке, просто выглядеть будет по другому.
Ну тут видишь как, у тебя конкатенация строковых литтералов прям как в Сишке, на этапе компиляции
printf("%s","hello\n"
"world\n");
Но вот такой побочный эффект для твоей текущей задаче что эта конкатенация мешает, а у меня наоборот вот так в луа нельзя
print("hello""world")
Но зато не мешает делать прикол что выше. Так и живём, либо-либо.
Как я обязан для конкатенации делать .. так и ты обязан наоборот разделять. Ни хорошо, ни плохо, просто по разному. Это я к тому пусть напрямую то что в голове родилось нельзя, но наверняка есть компромисс. Я вот лично предпочту мирится с некой особенностью чем из за некой особенности каждый раз менять инструмент.
И вообще, можно просто сделать как дед волосатый, прямолинейно, просто и понятно и на любом языке
resultat = pipe(command_a,command_b)
И скрыть все кишки внутри и норм и никакого извращения с DSLями, хаками и прочим. Вот у меня так часто, мудрю, мудрю, кручу верчу, запутать хочу, а потом всё сводится к просто дрыганию процедурок, а всё иное экстравагантное идёт в утиль, ну или самому себе в заметки типа «а вот так тоже можна гыыы»
Исправление LINUX-ORG-RU, :
Не, в lua получится вот такое
bla "con" "cat" "en" "at" "ion"
Тут можно сделать так что bla это функция которая может принимать строку "con" без указания скобок(``)` обработать и вернуть саму себя или функцию которая примет «cat» и так далее до и включая «ion». А как всё это интерпретировать дело десятое.
А вот такое нельзя
bla "con" "cat" | "grep" "lala" | «grep» «lolo»`
Тут bla это отметатабленная таблица, которая может быть вызвана как функция и принять «con» обработать и вернуть функцию которая примет «cat» вернёт отметатабленную таблицу которая изменит поведение (только в случае наличия себя) ‘|’ а вот дальше всё «grep» примется и будет обработан отметатабленным ‘|’ но вот на «lala» всё дрёпнется ибо оно ни к селу ни к городу.
Вот у тебя в рубях всё склеит, а у меня заругает мол это твоё «lala» это вообще куда? Всё получится если grep будет перегруженной таблицей.
Либо, делать вереницу возвратов функций и всё в строки облрачивать
bla "a" "|" "blu" "ble" "|" "e"
Либо, делать как со строками но с таблицами явными
bla {"a"} {"|"} {"blu"} {"ble"} {"|"} {"e"}
Или так, тут шило/мыло
bla {"a"} | blu {"ble"} | e
Либо, делать вызовы таблиц как функций с переопределённым оператором, как выше изначально
bla "a" | blu "ble" | e"
Может ещё как можно, но там будет своё но. В целом достаточно вариативно и гибко, но не в абсолюте конечно. А у тебя, ну значит тебе придётся какой то синтаксический разделитель на уровне языка использовать. Так же как и тут в луашке, просто выглядеть будет по другому.
Ну тут видишь как, у тебя конкатенация строковых литтералов прям как в Сишке, на этапе компиляции
printf("%s","hello\n"
"world\n");
Но вот такой побочный эффект для твоей текущей задаче что эта конкатенация мешает, а у меня наоборот вот так в луа нельзя
print("hello""world")
Но зато не мешает делать прикол что выше. Так и живём, либо-либо.
Как я обязан для конкатенации делать .. так и ты обязан наоборот разделять. Ни хорошо, ни плохо, просто по разному. Это я к тому пусть напрямую то что в голове родилось нельзя, но наверняка есть компромисс. Я вот лично предпочту мирится с некой особенностью чем из за некой особенности каждый раз менять инструмент.
И вообще, можно просто сделать как дед волосатый, прямолинейно, просто и понятно и на любом языке
resultat = pipe(command_a,command_b)
И скрыть все кишки внутри и норм и никакого извращения с DSLями, хаками и прочим. Вот у меня так часто, мудрю, мудрю, кручу верчу, запутать хочу, а потом всё сводится к просто дрыганию процедурок, а всё иное экстравагантное идёт в утиль, ну или самому себе в заметки типа «а вот так тоже можна гыыы»
Исправление LINUX-ORG-RU, :
Не в lua получится вот такое
bla "con" "cat" "en" "at" "ion"
Тут можно сделать так что bla это функция которая может принимать строку "con" без указания скобок(``)` обработать и вернуть саму себя или функцию которая примет «cat» и так далее до и включая «ion». А как всё это интерпретировать дело десятое.
А вот такое нельзя
bla "con" "cat" | "grep" "lala" | «grep» «lolo»`
Тут bla это отметатабленная таблица, которая может быть вызвана как функция и принять «con» обработать и вернуть функцию которая примет «cat» вернёт отметатабленную таблицу которая изменит поведение (только в случае наличия себя) ‘|’ а вот дальше всё «grep» примется и будет обработан отметатабленным ‘|’ но вот на «lala» всё дрёпнется ибо оно ни к селу ни к городу.
Вот у тебя в рубях всё склеит, а у меня заругает мол это твоё «lala» это вообще куда? Всё получится если grep будет перегруженной таблицей.
Либо, делать вереницу возвратов функций и всё в строки облрачивать
bla "a" "|" "blu" "ble" "|" "e"
Либо, делать как со строками но с таблицами явными
bla {"a"} {"|"} {"blu"} {"ble"} {"|"} {"e"}
Или так, тут шило/мыло
bla {"a"} | blu {"ble"} | e
Либо, делать вызовы таблиц как функций с переопределённым оператором, как выше изначально
bla "a" | blu "ble" | e"
Может ещё как можно, но там будет своё но. В целом достаточно вариативно и гибко, но не в абсолюте конечно. А у тебя, ну значит тебе придётся какой то синтаксический разделитель на уровне языка использовать. Так же как и тут в луашке, просто выглядеть будет по другому.
Ну тут видишь как, у тебя конкатенация строковых литтералов прям как в Сишке, на этапе компиляции
printf("%s","hello\n"
"world\n");
Но вот такой побочный эффект для твоей текущей задаче что эта конкатенация мешает, а у меня наоборот вот так в луа нельзя
print("hello""world")
Но зато не мешает делать прикол что выше. Так и живём, либо-либо.
Как я обязан для конкатенации делать .. так и ты обязан наоборот разделять. Ни хорошо, ни плохо, просто по разному. Это я к тому пусть напрямую то что в голове родилось нельзя, но наверняка есть компромисс. Я вот лично предпочту мирится с некой особенностью чем из за некой особенности каждый раз менять инструмент.
И вообще, можно просто сделать как дед волосатый, прямолинейно, просто и понятно и на любом языке
resultat = pipe(command_a,command_b)
И скрыть все кишки внутри и норм и никакого извращения с DSLями, хаками и прочим. Вот у меня так часто, мудрю, мудрю, кручу верчу, запутать хочу, а потом всё сводится к просто дрыганию процедурок, а всё иное экстравагантное идёт в утиль, ну или самому себе в заметки типа «а вот так тоже можна гыыы»
Исправление LINUX-ORG-RU, :
Не в lua получится вот такое
bla "con" "cat" "en" "at" "ion"
Тут можно сделать так что bla это функция которая может принимать строку "con" без указания скобок(``)` обработать и вернуть саму себя или функцию которая примет «cat» и так далее до и включая «ion». А как всё это интерпретировать дело десятое.
А вот такое нельзя
bla "con" "cat" | "grep" "lala" | «grep» «lolo»
Тут bla это отметатабленная таблица, которая может быть вызвана как функция и принять «con» обработать и вернуть функцию которая примет «cat» вернёт отметатабленную таблицу которая изменит поведение (только в случае наличия себя) ‘|’ а вот дальше всё «grep» примется и будет обработан отметатабленным ‘|’ но вот на «lala» всё дрёпнется ибо оно ни к селу ни к городу.
Вот у тебя в рубях всё склеит, а у меня заругает мол это твоё «lala» это вообще куда? Всё получится если grep будет перегруженной таблицей.
Либо, делать вереницу возвратов функций и всё в строки облрачивать
bla "a" "|" "blu" "ble" "|" "e"
Либо, делать как со строками но с таблицами явными
bla {"a"} {"|"} {"blu"} {"ble"} {"|"} {"e"}
Или так, тут шило/мыло
bla {"a"} | blu {"ble"} | e
Либо, делать вызовы таблиц как функций с переопределённым оператором, как выше изначально
bla "a" | blu "ble" | e"
Может ещё как можно, но там будет своё но. В целом достаточно вариативно и гибко, но не в абсолюте конечно. А у тебя, ну значит тебе придётся какой то синтаксический разделитель на уровне языка использовать. Так же как и тут в луашке, просто выглядеть будет по другому.
Ну тут видишь как, у тебя конкатенация строковых литтералов прям как в Сишке, на этапе компиляции
printf("%s","hello\n"
"world\n");
Но вот такой побочный эффект для твоей текущей задаче что эта конкатенация мешает, а у меня наоборот вот так в луа нельзя
print("hello""world")
Но зато не мешает делать прикол что выше. Так и живём, либо-либо.
Как я обязан для конкатенации делать .. так и ты обязан наоборот разделять. Ни хорошо, ни плохо, просто по разному. Это я к тому пусть напрямую то что в голове родилось нельзя, но наверняка есть компромисс. Я вот лично предпочту мирится с некой особенностью чем из за некой особенности каждый раз менять инструмент.
И вообще, можно просто сделать как дед волосатый, прямолинейно, просто и понятно и на любом языке
resultat = pipe(command_a,command_b)
И скрыть все кишки внутри и норм и никакого извращения с DSLями, хаками и прочим. Вот у меня так часто, мудрю, мудрю, кручу верчу, запутать хочу, а потом всё сводится к просто дрыганию процедурок, а всё иное экстравагантное идёт в утиль, ну или самому себе в заметки типа «а вот так тоже можна гыыы»
Исходная версия LINUX-ORG-RU, :
Не в lua получится вот такое
bla "con" "cat" "en" "at" "ion"
Тут можно сделать так что bla это функция которая может принимать строку "con" без указания скобок(``)` обработать и вернуть саму себя или функцию которая примет «cat» и так далее до и включая «ion». А как всё это интерпретировать дело десятое.
А вот такое нельзя
bla "con" "cat" | "grep" "lala" | «grep» «lolo»
Тут bla это отметатабленная таблица, которая может быть вызвана как функция и принять «con» обработать и вернуть функцию которая примет «cat» вернёт отметатабленную таблицу которая изменит поведение (только в случае наличия себя) ‘|’ а вот дальше всё «grep» примется и будет обработан отметатабленным ‘|’ но вот на «lala» всё дрёпнется ибо оно ни к селу ни к городу.
Вот у тебя в рубях всё склеит, а у меня заругает мол это твоё «lala» это вообще куда? Всё получится если grep будет перегруженной таблицей.
Либо, делать вереницу возвратов функций и всё в строки облрачивать
bla "a" "|" "blu" "ble" "|" "e"
Либо, делать как со строками но с таблицами явными
- bla {«a»} {«|»} {«blu»} {«ble»} {«|»} {«e»}`
Или так, тут шило/мыло
- bla {«a»} | blu {«ble»} | e`
Либо, делать вызовы таблиц как функций с переопределённым оператором, как выше изначально
bla "a" | blu "ble" | e"
Может ещё как можно, но там будет своё но. В целом достаточно вариативно и гибко, но не в абсолюте конечно. А у тебя, ну значит тебе придётся какой то синтаксический разделитель на уровне языка использовать. Так же как и тут в луашке, просто выглядеть будет по другому.
Ну тут видишь как, у тебя конкатенация строковых литтералов прям как в Сишке, на этапе компиляции
printf("%s","hello\n"
"world\n");
Но вот такой побочный эффект для твоей текущей задаче что эта конкатенация мешает, а у меня наоборот вот так в луа нельзя
print("hello""world")
Но зато не мешает делать прикол что выше. Так и живём, либо-либо.
Как я обязан для конкатенации делать .. так и ты обязан наоборот разделять. Ни хорошо, ни плохо, просто по разному. Это я к тому пусть напрямую то что в голове родилось нельзя, но наверняка есть компромисс. Я вот лично предпочту мирится с некой особенностью чем из за некой особенности каждый раз менять инструмент.
И вообще, можно просто сделать как дед волосатый, прямолинейно, просто и понятно и на любом языке
resultat = pipe(command_a,command_b)
И скрыть все кишки внутри и норм и никакого извращения с DSLями, хаками и прочим. Вот у меня так часто, мудрю, мудрю, кручу верчу, запутать хочу, а потом всё сводится к просто дрыганию процедурок, а всё иное экстравагантное идёт в утиль, ну или самому себе в заметки типа «а вот так тоже можна гыыы»