В настоящее время я разрабатываю новый язык для программирования в непрерывной среде (сравните его с электротехникой), и у меня есть некоторые идеи относительно определенной языковой конструкции.
Позвольте мне объяснить эту функцию по объяснению, а затем по определению:
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 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 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 Platform Lookup, где каждое "с" -условием является синхронизированный агент, работая над ним особым "фильтром" объектов. Вместо основанного на типе, это основано на переменных (принципиально совершенно одинаковое, просто другой способ идентификации объектов).
Я очень благодарю всех вас за предоставленную мне очень проницательную информацию и ссылки/подсказки для отличных тем, которые я могу исследовать. Спасибо.
Я не знаю, существует ли эта конструкция, так что мой вопрос: эта функция языка уже существует?
