标签: syntactic-sugar

我刚在网上注意到这个构造:

val list = List(someCollection: _*)

什么_*意思？这是一些方法调用的语法糖吗？我的自定义类应满足哪些约束才能利用这种语法糖？

我有一段时间一直在困惑这个问题,我看了一下,无法找到关于这个问题的任何讨论.

让我们假设我想实现一个简单的例子,比如一个新的循环结构:do..until

写得非常类似于do..while

do {
    //Things happen here
} until (i == 15)

这可以通过这样做转换为有效的csharp:

do {
    //Things happen here
} while (!(i == 15))

这显然是一个简单的例子,但有没有办法添加这种性质的东西？理想情况下,作为Visual Studio扩展,以启用语法突出显示等.

有没有办法可以用另一个名字导入一个类？就像我有一个名为javax.C的类和另一个名为java.C的类一样,我可以在名称C1下导入javax.C并以名称C2导入java.C.

我们可以在C#中做这样的事情:

using Sys=System;

或Vb:

Imports Sys=System

在VB.NET中,有一个WITH命令可以省略对象名称,只访问所需的方法和属性.例如:

With foo
   .bar()
   .reset(true)
   myVar = .getName()
End With

Java中是否有这样的语法？

谢谢!

对于百万分之一的时间,我本来希望IN在Java中使用运算符,类似于INSQL中的运算符.它可以作为编译器语法糖实现.所以这

if (value in (a, b, c)) {
}
else if (value in (d, e)) {
}

......真的很棒.事实上,上面的内容与这里相当冗长(并且不适用于原语)的构造相同:

if (Arrays.asList(a, b, c).contains(value)) {
}
else if (Arrays.asList(d, e).contains(value)) {
}

或者这样的int,long和类似的形式:

switch (value) {
  case a:
  case b:
  case c:
    // ..
    break;

  case d:
  case e:
    // ..
    break;
 }

或者可能有更高效的实现.

题:

这样的东西会成为Java 8的一部分吗？如果没有,我怎么能提出这样的建议呢？或者,我现在可以使用任何等效的构造吗？

我一直在研究Ruby并发现它的关键字"直到"和"除非"非常有趣.所以我认为在C/C++中添加类似关键字的好方法是什么.这就是我想出的:

#define until(x)    while(!(x))
#define unless(x)   if(!(x))

我正在寻找一些建议.谁能提出更好的选择？

这是我编写的一个程序示例,用于说明我打算做什么:

#include <stdio.h>
#include <stdlib.h>

#define until(x)    while(!(x))
#define unless(x)   if(!(x))

unsigned int factorial(unsigned int n) {
    unsigned int fact=1, i;
    until ( n==0 )
        fact *= n--;
    return fact;    
}

int main(int argc, char*argv[]) {
    unless (argc==2)
        puts("Usage: fact <num>");
    else {
        int n = atoi(argv[1]);
        if (n<0)
            puts("please give +ve number");
        else
            printf("factorial(%u) = %u\n",n,factorial(n));
    }
    return 0;
}

如果你能指出一些可以在C或C++中使用的类似技巧的参考文献,那将是很棒的.

在大多数主流编程语言中,从函数返回多个值似乎是一件非常尴尬的事情.

典型的解决方案是使任一个结构或一个普通的旧数据类和返回,或者通过引用传递至少一些参数或代替指针返回它们的.

使用引用/指针非常尴尬,因为它依赖于副作用,意味着你还有另一个参数要传递.

类/结构解决方案也是恕我直言,因为你最终得到了一百万个小类/结构,它们只用于从函数返回值,产生不必要的混乱和冗长.

此外,很多时候总是需要一个返回值,其余的只在某些情况下由调用者使用.这些解决方案都不允许调用者忽略不需要的返回类型.

我知道的一种优雅处理多个返回值的语言是Python.对于那些不熟悉的人,它使用元组解包:

a, b = foo(c)  # a and b are regular variables.
myTuple = foo(c)  # myTuple is a tuple of (a, b)

有没有人对这个问题有任何其他好的解决方案？除了Python之外,现有主流语言中的两种习语以及您在非主流语言中看到的语言级解决方案都是受欢迎的.

有没有人知道在实际尝试在REPL(或编译器)中编译之前如何获取(仅Scala部分)desgoared for for/comprehension表达式？

到目前为止,我唯一发现的是编译器"-print"标志,但它为您提供了完整的Scala转换...

所以我一直对这个感兴趣？运营商,但仍然无法使用它.当我做的事情时,我通常会想到:

var x = (someObject as someType).someMember;

如果someObject有效且someMember为null,我可以这样做

var x = (someObject as someType).someMember ?? defaultValue;

但是当someObject为null时,我几乎总是遇到问题,而且?? 并没有帮助我使这个更清洁,而不是自己做空检查.

你们找到了什么用途？在实际情况？

因此,感谢C++ 11,现在可以将宏,用户定义的文字,lambdas等组合起来,以创建最接近"语法糖"的方法.一个例子是

 if (A contains B)

当然这很容易.

cout <<("hello"_s contains "ello"_s)<<endl;

表达式转换为bool,其中contains是一个自定义结构,它将左侧和右侧作为参数.当然结构重载operator +以首先获取自定义字符串文字,返回自身,然后是结构本身的operator +.

struct contains_struct {
    string lhs;
    string rhs;
    void set_lhs(string lhs) { this->lhs = lhs; }
    void set_rhs(string rhs) { this->rhs = rhs; }
    operator bool() const {
        return string::npos != lhs.find(rhs);
    }
} contains_obj;

contains_struct& operator+(const string& lhs, const contains_struct& rhs) {
    contains_obj.set_lhs(lhs);
    return contains_obj;
}

contains_struct& operator+(const contains_struct& lhs, const string& rhs) {
    contains_obj.set_rhs(rhs);
    return contains_obj;
}

#define contains +contains_obj+

现在我决定要进一步.关于什么

(x in a) perform …