История изменений

как по мне плюсовый вариант :: не надо, слишком жирное написание, а foo::bar::baz::camaz выглядит вообще ужасно.

Согласен.

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

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

ну просто такой подход тупо быстрее работает.

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

То есть если это:

struct Foo
	void bar(this; int x);
end

то foo:bar(10) в машинном коде ничем не отличается от прямого вызова функции.

А вот если:

struct Foo
	void bar@(this; int x);
end

то здесь в структуре определенно поле bar, являющееся указателем на функцию. И вызов foo:bar(10) требует чтения этого поля.

То есть общий смысл такой, что запись x:y(...) это сахар для x.y(@x, ...), независимо от того, чем является y.

нужно ключевое слово обращения к неявному аргументу

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

struct X {
	void bar(int i) const;
};

Я думаю, что this следует указывать явно, но в упрощенном синтаксисе. Пример с константным this будет выглядеть так:

struct X of
	void bar(const this; int i);
end

И аналогично использование внутри самой функции. Обращения к полям через this.что_то, вызов методов через this:что_то() и т.п. Без «неявного this».

И при желании можно вообще не использовать сахар this в сигнатуре функции, а назвать первый аргумент хоть that, хоть self, просто тогда еще и тип ему нужно указать явным образом, чтобы компилятор понял. Типа такого

struct X of
        /* Эти объявления эквивалентны: */
	void bar1(const this; int i);
	void bar2(const X @that; int i);
end

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

Будет выполнена попытка преобразования типа по общим правилам языка.

можно ли через : вызывать функцию которая не является полем, а просто левой функцией

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

А вот для того, чтобы засовывать первый аргумент «конвеером» вообще в любую функцию, в современных языках придумали оператор |>, типа такого:

int foo(float x, int y);
int a = 100.0 |> foo(20);

Его я наверное тоже добавлю, пока просто руки не дошли.

как по мне плюсовый вариант :: не надо, слишком жирное написание, а foo::bar::baz::camaz выглядит вообще ужасно.

Согласен.

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

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

ну просто такой подход тупо быстрее работает.

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

То есть если это:

struct Foo
	void bar(int x);
end

то foo:bar(10) в машинном коде ничем не отличается от прямого вызова функции.

А вот если:

struct Foo
	void bar@(int x);
end

то здесь в структуре определенно поле bar, являющееся указателем на функцию. И вызов foo:bar(10) требует чтения этого поля.

То есть общий смысл такой, что запись x:y(...) это сахар для x.y(@x, ...), независимо от того, чем является y.

нужно ключевое слово обращения к неявному аргументу

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

struct X {
	void bar(int i) const;
};

Я думаю, что this следует указывать явно, но в упрощенном синтаксисе. Пример с константным this будет выглядеть так:

struct X of
	void bar(const this; int i);
end

И аналогично использование внутри самой функции. Обращения к полям через this.что_то, вызов методов через this:что_то() и т.п. Без «неявного this».

И при желании можно вообще не использовать сахар this в сигнатуре функции, а назвать первый аргумент хоть that, хоть self, просто тогда еще и тип ему нужно указать явным образом, чтобы компилятор понял. Типа такого

struct X of
        /* Эти объявления эквивалентны: */
	void bar1(const this; int i);
	void bar2(const X @that; int i);
end

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

Будет выполнена попытка преобразования типа по общим правилам языка.

можно ли через : вызывать функцию которая не является полем, а просто левой функцией

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

А вот для того, чтобы засовывать первый аргумент «конвеером» вообще в любую функцию, в современных языках придумали оператор |>, типа такого:

int foo(float x, int y);
int a = 100.0 |> foo(20);

Его я наверное тоже добавлю, пока просто руки не дошли.

как по мне плюсовый вариант :: не надо, слишком жирное написание, а foo::bar::baz::camaz выглядит вообще ужасно.

Согласен.

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

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

ну просто такой подход тупо быстрее работает.

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

То есть если это:

struct Foo
	void bar(int x);
end

то foo:bar(10) в машинном коде ничем не отличается от прямого вызова функции.

А вот если:

struct Foo
	void bar@(int x);
end

то здесь в структуре определенно поле bar, являющееся указателем на функцию. И вызов foo:bar(10) требует чтения этого поля.

То есть общий смысл такой, что запись x:y(...) это сахар для x.y(@x, ...), независимо от того, чем является y.

нужно ключевое слово обращения к неявному аргументу

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

struct X {
	void bar(int i) const;
};

Я думаю, что this следует указывать явно, но в упрощенном синтаксисе. Пример с константным this будет выглядеть так:

struct X of
	void bar(const this; int i);
end

И аналогично использование внутри самой функции. Обращения к полям через this.что_то, вызов методов через this:что_то() и т.п. Без «неявного this».

И при желании можно вообще не использовать сахар this в сигнатуре функции, а назвать первый аргумент хоть that, хоть self, просто тогда еще и тип ему нужно указать явным образом, чтобы компилятор понял. Типа такого

struct X of /* Эти объявления эквивалентны: */ void bar1(const this; int i); void bar2(const X @that; int i); end

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

Будет выполнена попытка преобразования типа по общим правилам языка.

можно ли через : вызывать функцию которая не является полем, а просто левой функцией

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

А вот для того, чтобы засовывать первый аргумент «конвеером» вообще в любую функцию, в современных языках придумали оператор |>, типа такого:

int foo(float x, int y);
int a = 100.0 |> foo(20);

Его я наверное тоже добавлю, пока просто руки не дошли.

как по мне плюсовый вариант :: не надо, слишком жирное написание, а foo::bar::baz::camaz выглядит вообще ужасно.

Согласен.

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

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

ну просто такой подход тупо быстрее работает.

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

То есть если это:

struct Foo
	void bar(int x);
end

то foo:bar(10) в машинном коде ничем не отличается от прямого вызова функции.

А вот если:

struct Foo
	void bar@(int x);
end

то здесь в структуре определенно поле bar, являющееся указателем на функцию. И вызов foo:bar(10) требует чтения этого поля.

То есть общий смысл такой, что запись x:y(...) это сахар для x.y(@x, ...), независимо от того, чем является y.

нужно ключевое слово обращения к неявному аргументу

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

struct X {
	void bar(int i) const;
};

Я думаю, что this следует указывать явно, но в упрощенном синтаксисе. Пример с константным this будет выглядеть так:

struct X of
	void bar(const this; int i);
end

И аналогично использование внутри самой функции. Обращения к полям через this.что_то, вызов методов через this:что_то() и т.п. Без «неявного this».

То есть при желании можно вообще не писать this, а назвать первый аргумент хоть that, хоть self, просто тогда еще и тип ему нужно указать явным образом.

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

Будет выполнена попытка преобразования типа по общим правилам языка.

можно ли через : вызывать функцию которая не является полем, а просто левой функцией

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

А вот для того, чтобы засовывать первый аргумент «конвеером» вообще в любую функцию, в современных языках придумали оператор |>, типа такого:

int foo(float x, int y);
int a = 100.0 |> foo(20);

Его я наверное тоже добавлю, пока просто руки не дошли.

как по мне плюсовый вариант :: не надо, слишком жирное написание, а foo::bar::baz::camaz выглядит вообще ужасно.

Согласен.

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

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

ну просто такой подход тупо быстрее работает.

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

То есть если это:

struct Foo
	void bar(int x);
end

то foo:bar(10) в машинном коде ничем не отличается от прямого вызова функции.

А вот если:

struct Foo
	void bar@(int x);
end

то здесь в структуре определенно поле bar, являющееся указателем на функцию. И вызов foo:bar(10) требует чтения этого поля.

То есть общий смысл такой, что запись x:y(...) это сахар для x.y(@x, ...), независимо от того, чем является y.

нужно ключевое слово обращения к неявному аргументу

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

struct X {
	void bar(int i) const;
};

Я думаю, что this следует указывать явно, но в упрощенном синтаксисе. Пример с константным this будет выглядеть так:

struct X of
	void bar(const this; int i);
end

И аналогично использование внутри самой функции. Обращения к полям через this.что_то, вызов методов через this:что_то() и т.п. Без «неявного this».

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

Будет выполнена попытка преобразования типа по общим правилам языка.

можно ли через : вызывать функцию которая не является полем, а просто левой функцией

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

А вот для того, чтобы засовывать первый аргумент «конвеером» вообще в любую функцию, в современных языках придумали оператор |>, типа такого:

int foo(float x, int y);
int a = 100.0 |> foo(20);

Его я наверное тоже добавлю, пока просто руки не дошли.