这种语言功能是否已经存在？

时间：2010-03-24 23:10:26

标签： operators language-features dataflow

我目前正在为连续环境中的编程开发一种新语言（与电子工程相比），我对某种语言结构有一些想法。

让我通过解释然后按照定义解释这个特征：

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.
}

更新2：更多示例和更多上下文。 

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 Platform的Lookup非常相似，其中每个“with” - 陈述是一个同步代理，正在处理对象的特定“过滤器”。而不是基于类型，这是基于变量的（基本上完全相同;只是一种识别对象的不同方式）。

我非常感谢大家为我提供了非常有见地的信息和链接/提示我可以研究的重要主题。感谢。

我不知道这种结构是否已经存在，所以这是我的问题：这种语言功能是否已经存在？

10 个答案:

答案 0 :(得分：4)

我发现这很难说，但你的意思是：

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
}

其中||是传统的布尔OR。这正是我第一次提出的问题。

好的，还有一次......你现在改变了语法，表明你正在做工会和交叉。但那时：

if(userkey I ("shift" U "a")) {
    // pressed both "shift" and the "a" key.

所以I意味着取两个集合的交集......但if在什么情况下执行代码块？如果交叉点非空？或者I实际上是在询问“是左侧集合中右侧成员的集合的所有成员”并且有一些提示userkey在块的范围内被另一个值替换实际上只是右边的设置。

我要去睡觉了。

答案 1 :(得分：4)

老实说，我发现你的解释和例子难以理解（更新：你的博客更好，阅读Statement Ordering我更确信你的目标是一种形式数据流编程）。

但是，你的最终描述是：

  

语言中陈述的一切都是   “按原样”，并持续积极   执行。这意味着;程序员   不知道以哪种顺序（除非   使用结构明确声明）   元素是，也不是陈述   执行。语言是完全的   与“时间”分开 - 概念，   即它不断执行：   说“a”是“b”而“b”是“a”   是一个简单的循环结构，用于   实例

..诱使我认为您要搜索的一般术语是 dataflow programming （即使在更简单的数据流编程实例中不允许循环）。引自维基百科：

  

数据流是一种基于这种想法的软件架构   改变变量的值   应该自动强制   重新计算的价值   变量取决于它的价值。

Reactive programming和functional reactive programming是 我了解他们，相同主题的变体。

Icon的目标导向评估在范围上受到更多限制（请参阅此A Brief Introduction to Icon：目标导向评估机制所隐含的回溯仅限于其发生的表达）。

另请参阅Stackoverflow上的这个问题：Dataflow Programming Languages。

更新：Pindatjuh在评论中提问“你能评论一下，这种语言是否是数据流主题的新变种？”。我是这么认为的，但问题实际上是关于定义以及共识。最近一项关于数据流语言的调查Advances in dataflow programming languages（发表于ACM Computing Surveys, Volume 36 , Issue 1, March 2004），作者写道（第10页）：

  

最佳功能列表   构成数据流语言   Ackerman [1982]和   Whiting和Pascoe重申了这一点   [1994]和Wail and Abramson [1995]。   此列表包括以下内容：

     
      
  1. 免于副作用，
    2.   
  2. 效果的地方，
    3.   
  3. 数据依赖性等同于调度，
    4.   
  4. 单个变量赋值，
    5.   
  5. 由于功能1和4而导致的异常表示法，
    6.   
  6. 程序缺乏历史敏感性。
    7.   

我没有阅读你的所有博客但只是轻易地阅读它，所以你比我更有资格判断你的编程语言（无论如何这都是一个移动的目标）。

更新：我在你的问题中无意识地错过了“新”这个词“ ...这种语言是新的变体...... ”。这是一项艰巨的任务：需要考虑到目前为止发明的所有数据流语言，并仔细仔细检查它们的语义，以发现您的方法中的新颖性。我当时肯定没有必要的知识。

答案 2 :(得分：3)

您的示例和数学都可以使用一些工作，但至少在您博客上的一个示例中，您对|的使用非常类似于使用相同的运算符（称为“交替”，我相信）Icon programming language。

如果你要在这个领域进行语言设计，你一定要阅读

答案 3 :(得分：3)

C＃当然没有您描述的功能。你所谈论的内容似乎让人想起罗宾米尔纳的pi演算;它是关于定义描述并发进程的语言的全部内容。如果你还没有，你可以考虑对它进行一些研究。

答案 4 :(得分：3)

您的语言功能类似于Perl 6中的junctions。

在Perl 5中，有Quantum::Superpositions模块。

答案 5 :(得分：2)

你应该发明自己的符号，即使只是为了这个例子。

看起来您正在尝试执行动态更改的变量引用，因为范围定义需要。这是一种非常微妙的技术，我不知道任何语言。大多数语言都要求您明确地执行此操作，尽管我可以看到与闭包，生成器和反向跟踪的相似之处。

你能解释推动这种不寻常方法的背景吗？您的博客链接不是很有帮助。并且“连续编程”这个术语也没有定义或解释。

<强>更新

好的，看看你编辑过的例子，我可以指出Icon有类似的东西。它并不是你认为你所要求的，并不常见，但似乎很接近，而且它的定义要好得多。它被称为目标导向评估。

许多语言元素提供或允许您构建一个生成器，如果被要求可以提供许多替代方案。您的示例和Icon之间的主要区别是您必须为语言提供上下文以继续尝试替代方案。作业不会这样做，但比较会。一旦生成器耗尽了它可以提供的值，就会失败。这也是普通比较的工作原理，整个功能很好地融入了更广泛的语言。 （我有时将其描述为微缩异常。）

Python和Ruby有yield机制，它非常相似，可以说受到Icon的生成器的影响。

答案 6 :(得分：0)

我建议你不要添加该语言功能。对于程序员来说，如果你进行“测试”，x的含义就会改变，这是非常不清楚的：

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

答案 7 :(得分：0)

Inform IF-authoring语言具有此功能。来自DM：

if (alpha == 3 or 4) print "Scott";
但是，它并没有真正进一步发展，因为解析时有点奇怪（您必须将每个or / |运算符与特定所有者== /关联起来!=比较器），在现代脚本语言中，很容易用以下内容替换：

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

（Python示例。）

答案 8 :(得分：0)

你似乎一下子想着几个想法：

  • 一种列表语法，用于执行5 | 6 | 7
    • 之类的操作
  • 使用您正在撰写的外部产品::list:: + ::list::
  • 在一个或两个参数是列表时仔细定义相等，不等，赋值等运算符的含义。即::scalor:: == ::list::实现“是”的一个元素，依此类推

我不知道结合这些想法的单一语法特征，但后来我没有真正的广泛经验......

答案 9 :(得分：0)

“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;
}
相关问题
最新问题