Эта функция языка уже существует?
Я в настоящее время разрабатываю новый язык для программирования в непрерывной среде (сравните его с электротехникой), и я получил некоторое представление относительно определенной конструкции языка.
Позвольте мне объяснить функцию объяснением и затем по определению:
x = a U b;
Где x переменная и a и b другие переменные (или статические значения). Это работает как объединение между a и b; никакие дубликаты и никакой определенный порядок.
with(x) {
// regular 'with' usage; using the global interpretation of "x"
x = 5;
// effectively will do:
// x = a U b U 5;
// a = 5;
// b = 5;
// Thus, when "a" or "b" changes, "x" is still equal to "5".
}
with(x = a) {
// this code block is executed when the "x" variable
// has the "a" variable assigned. All references in
// this code-block to "x" are references to "a". So saying:
x = 5;
// would only change the variable "a". If the variable "a"
// later on changes, x still equals to 5, in this fashion:
// 'x = a U b U 5;'
// '[currentscope] = 5;'
// thus, 'a = 5;'
}
with(x = b) {
// same but with "b"
}
with(x != a) {
// here the "x" variable refers to any variable
// but "a"; thus saying
x = 5;
// is equal to the rewriting of
// 'x = a U b U 5;'
// 'b = 5;' (since it was the scope of this block)
}
with(x = (a U b)) {
// guaranteed that "x" is 'a U b'; interacting with "x"
// will interact with both "a" and "b".
x = 5;
// makes both "a" and "b" equal to 5; also the "x" variable
// is updated to contain:
// 'x = a U b U 5;'
// '[currentscope] = 5;'
// 'a U b = 5;'
// and thus: 'a = 5; b = 5;'.
}
// etc.
В вышеупомянутом все блоки кода выполняются, но изменения "объема" в каждом блоке как x интерпретируется. В первом блоке, x как гарантируют, будет a: таким образом взаимодействие с x в том блоке будет взаимодействовать на a. Второе и третий блок кода только равны по этой ситуации (потому что not a: затем там только остается b). Последний блок гарантирует это x по крайней мере, a или b.
Далее больше; U не "поразрядный или оператор", но я назвал его "и/или" - оператор. Его определение:
"U" = "and" U "or"
(На моем блоге, http://cplang.wordpress.com/2009/12/19/binop-and-or/, существует больше (математической) справочной информации об этом операторе. Это свободно основано на наборах. Используя другой синтаксис, измененный это в этом вопросе.)
Обновление: больше примеров.
print = "Hello world!" U "How are you?"; // this will print
// both values, but the
// order doesn't matter.
// 'userkey' is a variable containing a key.
with(userkey = "a") {
print = userkey; // will only print "a".
}
with(userkey = ("shift" U "a")) {
// pressed both "shift" and the "a" key.
print = userkey; // will "print" shift and "a", even
// if the user also pressed "ctrl":
// the interpretation of "userkey" is changed,
// such that it only contains the matched cases.
}
with((userkey = "shift") U (userkey = "a")) {
// same as if-statement above this one, showing the distributivity.
}
x = 5 U 6 U 7;
y = x + x; // will be:
// y = (5 U 6 U 7) + (5 U 6 U 7)
// = 10 U 11 U 12 U 13 U 14
somewantedkey = "ctrl" U "alt" U "space"
with(userkey = somewantedkey) {
// must match all elements of "somewantedkey"
// (distributed the Boolean equals operated)
// thus only executed when all the defined keys are pressed
}
with(somewantedkey = userkey) {
// matches only one of the provided "somewantedkey"
// thus when only "space" is pressed, this block is executed.
}
Update2: больше примеров и еще некоторый контекст.
with(x = (a U b)) {
// this
}
// can be written as
with((x = a) U (x = b)) {
// this: changing the variable like
x = 5;
// will be rewritten as:
// a = 5 and b = 5
}
Некоторая справочная информация: я создаю язык, который "независим от времени", как Java "платформа-independant". Все указанное в языке, "как" и непрерывно активно выполняется. Это означает; программист не знает, в котором порядке (если явно не указано с помощью конструкций) элементы, ни когда операторы выполняются. Язык полностью разделяется со "времени" - понятие, т.е. это непрерывно выполняется:
with(true) {
a = 0; // only runs once (lazy execution)
}
with(a < 5) {
a++;
} // this is a loop-structure;
// how and when it's executed isn't known however.
with(a) {
// everytime the "a" variable changes, this code-block is executed.
with(true) {
b = 3; // only 5 times (again lazy execution, but it's a sub-with)
}
with(b < 2) { // dependent on "b"
// runs only 3 times * 5 times = 15 times.
}
with(b > 1) { // dependent on "b"
b = b - 1; // runs 4 times * 5 times = 20 times.
}
}
Обновление 3:
После размышляющий о типе этой функции языка; это тесно подобия Поиск Платформы Netbeans, где каждый "с" - оператор синхронизируемый агент, продолжая работать, это - определенный "фильтр" объектов. Вместо основанного на типе это основано на переменной (существенно вполне то же; просто другой способ объектов identifiying).
Я значительно благодарен за то, что все Вы предоставляют мне очень проницательную информацию и ссылки/подсказки на большие темы, которые я могу исследовать.Спасибо.
Я не знаю, существует ли эта конструкция уже, таким образом, это - мой вопрос: эта функция языка уже существует?
10 ответов
Честно говоря, я считаю, что ваши объяснения и примеры трудны для понимания ( обновление: ваш блог намного лучше, и вы читаете Порядок утверждений там я еще больше убежден, что вы стремитесь к форме программирования потока данных ).
Однако ваше окончательное описание:
Все, что указано на языке, "как есть" и постоянно активно выполняется. Это означает; программист не знает, в каком порядке (если явно не указано с помощью конструкций) элементы и когда выполняются операторы . Язык полностью отделен от концепции "времени", т.е. он выполняется непрерывно: говоря, что "a" равно "b", а "b" равно "a" - это простая структура цикла для экземпляра .
... наводит меня на мысль, что общий термин, который вы ищете, - это программирование потока данных (даже если циклы не разрешены в более простых примерах программирования потока данных). Цитата из Википедии:
Dataflow - это программная архитектура, основанная на идее, что изменение значения переменной должно автоматически вызывать пересчет значений { {1}} переменные, которые зависят от его значения.
Реактивное программирование и функциональное реактивное программирование являются, как я их понимаю , вариациями на одну и ту же тему.
Целенаправленная оценка Icon более ограничена по объему (см. Это Краткое введение в Icon : Отслеживание назад, подразумеваемое механизмом целенаправленной оценки, ограничено выражением, в котором оно происходит ).
См. Также этот вопрос на Stackoverflow: Языки программирования потока данных .
Обновление: Пиндатюх спрашивает в комментариях: « Можете ли вы также прокомментировать, является ли этот язык новой вариацией на тему потока данных? ». Я так думаю, но на самом деле вопрос касается определений и консенсуса. В недавнем обзоре языков потоков данных Достижения в языках программирования потоков данных (опубликовано в ACM Computing Surveys, том 36, выпуск 1, март 2004 г. ) авторы писали (стр. 10):
Лучший список функций, которые составляют язык потока данных, был предложен Акерманом [1982] и повторен Уайтингом и Паско [1994] и Wail and Abramson [1995]. Этот список включает следующее:
- свобода от побочных эффектов,
- локальность эффекта,
- зависимости данных, эквивалентные планированию,
- однократное присвоение переменных,
- необычное обозначение итераций из-за особенностей 1 и 4,
- отсутствие чувствительности к истории в процедурах.
Я не читал весь ваш блог, просто внимательно его просмотрел, так что вы более компетентны, чем я, чтобы судить о своем языке программирования (который в любом случае является подвижной целью).
Обновление: Я бессознательно пропустил слово «новый» в вашем вопросе « ... этот язык является новым вариантом ... ». Это сложная задача: нужно рассмотреть все языки потока данных, изобретенные до сих пор, и тщательно изучить их семантику в деталях, чтобы обнаружить новизну в вашем подходе. У меня точно нет необходимых знаний в настоящее время.
Мне трудно понять, но вы имеете в виду, что:
x == a | b
будет синтаксическим сахаром, эквивалентным:
(x == a) || (x == b)
В сообщении в блоге вы приводите этот пример:
1 + (2|3)
Итак, тип этого выражения - пара целых чисел со значениями 3 и 4, каждое из которых представляет одно из возможных значений. Таким образом, мы также можем сказать:
4 == (1 + (2|3)
3 == (1 + (2|3)
и оба из них будут оценивать как истину. Таким образом, оператор == может сравнивать значение с своего рода вектором значений и будет истинным , если любое из значений в векторе равно первому значению.
Это может быть реализовано с помощью перегрузки операторов на нескольких языках (хотя вам придется явно «поднять» простые значения в тип оболочки, прежде чем вы сможете с ними работать).
Разве это не то же самое, что объединение двух множеств, и с == интерпретируется как «является членом»? И операторы вроде отмены +, поэтому они применяются ко всем членам набора.
И если бы вы сделали (1 | 2) + (4 | 8), вы бы получили эквивалент (5 | 9 | 6 | 10), потому что это четыре возможных результата.
Хорошо, из дополнительных примеров, которые вы добавили, я вижу, что == на самом деле требует, чтобы левая и правая стороны были одним и тем же набором, а не просто перекрывались. Но у меня все еще создается впечатление, что ваш | - это просто объединение двух множеств. Что это влечет за собой (или означает), будет зависеть от того, что вы делаете со всеми другими функциями вашего языка для работы с наборами.
По поводу вашего утверждения:
Язык полностью отделен от концепции "времени"
Вы много смотрели на чистые функциональные языки, такие как Haskell? Программы представляют собой серию определений без известного порядка выполнения, вы можете писать только чистые функции без побочных эффектов, и, следовательно, интерпретатор может упорядочивать выполнение, как ему нравится, пока значения доступны, когда это действительно необходимо.
Обновление:
Вы добавили это к своему вопросу:
if(x == a | b) {
// this
}
// can be written as
if((x == a) | (x == b)) {
// this
}
// which can be written as
if(x == a) {
// this
}
if(x == b) {
// with this
}
Интересно, как вы думаете, что это будет проливать свет!
Дело в том, что первые две версии имеют один блок кода под условием if. Таким образом, если третья расширенная версия имеет два блока, они должны быть одним и тем же блоком . Другими словами, это просто другой способ записи:
if (x == a || x == b) {
// this
}
Где || это традиционное логическое ИЛИ. Это именно тот вопрос, который я задал первым.
Хорошо, еще раз ... Теперь вы изменили синтаксис, чтобы указать, что вы выполняете объединения и пересечения. Но тогда:
if(userkey I ("shift" U "a")) {
// pressed both "shift" and the "a" key.
Итак I означает пересечение двух множеств ...но , если выполняет блок кода, при каких обстоятельствах? Если перекресток не пустой? Или Я на самом деле спрашиваю: «Все ли элементы набора справа членами набора слева». И есть подсказки, что userkey заменяется в рамках заблокировать другим значением, которое на самом деле просто установлено справа.
Я иду спать.
Ваши примеры и математика могут потребовать доработки, но по крайней мере в одном из примеров в вашем блоге использование | очень напоминает использование того же оператора (там он называется "чередование", я полагаю) в языке программирования Icon.
Если вы собираетесь заняться разработкой языка в этой области, вам определенно стоит прочитать о
- модели оценки, направленной на достижение цели в языке Icon
- Функциональное реактивное программирование и о том, как он моделирует непрерывное время
Эту функцию имел язык разработки Inform IF. Из DM :
if (alpha == 3 or 4) print "Scott";
На самом деле он не получил особого распространения, однако, поскольку это немного странно разбирать (вы должны связать каждый или / | Оператор с конкретным владельцем == / ! = компаратор), а в современных языках сценариев его легко заменить на что-то вроде:
if alpha in (3, 4):
print 'Scott';
(пример Python.)
Кажется, вы обдумываете сразу несколько идей:
- Синтаксис списка, в котором вы выполняете что-то вроде
5 | 6 | 7 - с использованием внешнего продукта, в котором вы писали
:: list :: + :: list :: - , тщательно определяя значение операторов равенства, неравенства, присваивания и т. Д., Когда один или оба аргументы - это список. Т.е. что
:: scalor :: == :: list ::реализует "является элементом" и т. д.
Я не знаю ни одной синтаксической особенности, которая объединяет эти идеи, но тогда У меня нет большого опыта ...
Ваш язык похож на переходов в Perl 6.
В Perl 5 есть модуль Quantum :: Superpositions .
Вам следовало бы придумать свои собственные символы, даже просто для примера.
Похоже, что вы пытаетесь сделать ссылки на переменные, которые динамически изменяются в зависимости от определения области видимости. Это очень тонкая техника, и я не знаю ни одного языка, который бы так делал. Большинство языков требуют, чтобы вы делали это явно, хотя я вижу сходство с закрытиями, генераторами и обратным отслеживанием.
Не могли бы вы объяснить, в каком контексте используется этот необычный метод? Ваша ссылка на блог не очень помогла. И термин "непрерывное программирование" тоже не определен и не объяснен.
Обновление:
Хорошо, глядя на ваш отредактированный пример, я могу указать на Icon как на имеющий нечто подобное. Это не совсем то, о чем вы просите, и это не распространено, но это кажется близким, и это гораздо лучше определено. Это называется "Целенаправленная оценка".
Многие элементы языка предоставляют или позволяют построить генератор, который может выдать несколько альтернатив, если его спросить. Основное различие между вашим примером и Icon заключается в том, что вы должны обеспечить контекст для языка, чтобы он продолжал пробовать альтернативы. Назначение не делает этого, но сравнение сделает. Когда генератор исчерпывает все значения, которые он может предоставить, он терпит неудачу. Так же работает обычное сравнение, и вся эта функция хорошо интегрируется в более широкий язык. (Я иногда описываю это как миниатюрные исключения.)
В Python и Ruby есть механизм yield, который очень похож и, возможно, на него повлияли генераторы Icon.
Я не советую вам добавлять эту особенность языка. Программисту будет очень неясно, что значение x меняется, если вы сделаете "тест" типа:
if( x != a ) { ... }
В C # определенно нет функций, которые вы описываете. То, о чем вы говорите, чем-то напоминает исчисление пи Робина Милнера; все дело в определении языка для описания параллельных процессов. Вы можете подумать о том, чтобы изучить это, если вы еще этого не сделали.
«with» существует в as3:
private var _a:Number = 0.0;
public function get a():Number{
// Do stuff
return _a;
}
public function set a(value:Number):void{
// Do stuff
_a=value;
}