Эта языковая функция уже существует?

Question

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

Позвольте мне объяснить эту особенность объяснением, а затем по определению:

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 "не зависит от платформы". Все изложенное в языке «как есть» и постоянно активно исполняется. Это означает; программист не знает, в каком порядке (если это явно не указано с помощью конструкций), и когда выполняются операторы. Язык полностью отделен от концепции времени, то есть постоянно выполняется:

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, где каждое «с» -состоянием синхронизированный агент работает над определенным «фильтром» объектов. Вместо основанного на типе, это основано на переменных (по сути, то же самое; просто другой способ идентификации объектов).

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

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

Answer 1

Мне, честно говоря, трудно объяснить ваши объяснения и примеры ( обновление: ваш блог намного лучше и читая Заявление о порядке там я еще больше убежден, что вы стремитесь форма программирования потока данных ).

Тем не менее, ваше окончательное описание:

Все, что сказано на языке, "как есть" и постоянно активно казнены. Это означает; программист не знает в каком порядке (если только явно указано с использованием конструкций) элементы, ни когда заявления казнены. Язык полностью отделяется от понятия «время», то есть он постоянно выполняется: говоря, что "а" это "б" и "б" это "а" простая петлевая структура, для экземпляр.

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

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

Реактивное программирование и функциональное реактивное программирование , как I их понимают , вариации на одну и ту же тему.

Целевая оценка Icon более ограничена по объему (см. Краткое введение в Icon : Откат, подразумеваемый механизмом целевой оценки, ограничен выражением, в котором оно происходит ).

См. Также этот вопрос по Stackoverflow: Языки программирования потока данных .

Обновление: Пиндатюх спрашивает в комментариях " Можете ли вы также прокомментировать, является ли этот язык новым вариантом темы потока данных? ". Я так думаю, но вопрос действительно об определениях и, следовательно, о консенсусе. В недавнем обзоре о языках потоков данных Достижения в языках программирования потоков данных (опубликовано в ACM Computing Surveys, том 36, выпуск 1, март 2004 года ), авторы написали (страница 10):

Лучший список функций, которые составлял язык потока данных вперед Аккерманом [1982] и подтверждено Уайтингом и Паско [1994] и Уэйл и Абрамсон [1995]. Этот список включает в себя следующее:

1. свобода от побочных эффектов,
2. место действия,
3. зависимости данных, эквивалентные расписанию,
4. одиночное присвоение переменных,
5. необычная запись для итераций из-за особенностей 1 и 4,
6. отсутствие истории чувствительности в процедурах.

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

Обновление: Я неосознанно пропустил слово "новый" в вашем вопросе " ... этот язык является новым вариантом ... ". Это трудная задача: нужно рассмотреть все изобретенные до сих пор языки потока данных и тщательно изучить их семантику, чтобы определить новизну в вашем подходе. У меня наверняка нет необходимых знаний в это время.

Answer 2

Мне трудно это понять, но вы имеете в виду, что:

x == a | b 

будет синтаксическим сахаром, эквивалентным:

(x == a) || (x == b)

В сообщении блога вы приводите этот пример:

1 + (2|3)

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

4 == (1 + (2|3)
3 == (1 + (2|3)

и оба они оценили бы как истину. Таким образом, оператор == может сравнивать значение с видом вектора значений и будет true, если любое из значений в векторе равно первому значению.

Это может быть реализовано с использованием перегрузки операторов на нескольких языках (хотя вам придется явно "поднять" простые значения в тип-оболочку, прежде чем вы сможете с ними работать).

Разве это не то же самое, что объединение двух множеств, а с == интерпретируется как "является членом"? А операторам нравится, когда + отменяется, поэтому они применяются ко всем членам набора.

И если бы вы сделали (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 означает пересечение двух множеств ... но при каких обстоятельствах if выполняет блок кода? Если пересечение не пусто? Или I на самом деле спрашивает "все ли члены набора справа члены набора слева" И есть подсказки, что userkey заменяется в области видимости блока другим значением, которое на самом деле просто установить справа.

Я иду спать.

Answer 3

Ваш язык похож на переходы в Perl 6.

В Perl 5 есть модуль Quantum :: Superpositions .

Answer 4

C # определенно не обладает теми функциями, которые вы описываете. То, о чем вы говорите, кажется чем-то напоминающим пи-исчисление Робина Милнера; все дело в определении языка для описания параллельных процессов. Вы можете подумать об этом, если вы еще этого не сделали.

Answer 5

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

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

• Модель иконы целенаправленной оценки
• Функциональное реактивное программирование и способ, которым оно моделирует непрерывное время

Answer 6

Вы должны были изобрести свои собственные символы, даже для примера.

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

Не могли бы вы объяснить контекст, управляющий этим необычным методом? Ваша ссылка на блог была не очень полезной. И термин «непрерывное программирование» также не определен и не объяснен.

Обновление:

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

Многие языковые элементы предоставляют или позволяют создавать генератор, который может предложить несколько альтернатив, если их попросят. Основное различие между вашим примером и Icon заключается в том, что вы должны предоставить контекст для языка, чтобы продолжать пробовать альтернативы. Назначение не делает этого, но сравнение будет. Как только у генератора заканчиваются значения, которые он может предоставить, он выходит из строя . Так же работает обычное сравнение, и вся функция прекрасно интегрируется в более широкий язык. (Я иногда описываю это как миниатюрные исключения.)

В Python и Ruby есть механизм yield, который очень похож и, возможно, подвержен влиянию генераторов Icon.

Answer 7

«С» существует в 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;
}

Answer 8

Вы, кажется, возитесь с несколькими идеями одновременно:

• Синтаксис списка, где вы делаете что-то вроде 5 | 6 | 7
• используя внешний продукт, на котором вы писали ::list:: + ::list::
• тщательно определяет значение операторов равенства, неравенства, присваивания и т. Д., Когда один или оба аргумента являются списком. То есть ::scalor:: == ::list:: реализует "является элементом" и т. д.

Я не знаю ни одной синтаксической функции, объединяющей эти идеи, но тогда у меня нет большого опыта ...

Answer 9

Язык разработки Inform IF имеет эту функцию. Из DM :

if (alpha == 3 or 4) print "Scott";

Тем не менее, он не получил широкого распространения, так как анализировать его немного странно (нужно связать каждый оператор or / | с конкретным владельцем == / != компаратором), и в современных языках сценариев это легко заменить чем-то вроде:

if alpha in (3, 4):
    print 'Scott';

(пример Python.)

Answer 10

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

if( x != a ) { ... }