标签: syntactic-sugar

例如C#中属性的语法糖:

private int x;

public int X{
    get { return x; }
    set { x = value; }
}

或者干脆

 public int X{ get; set; }

我在java中错过了逐字符串... @"C:\ My Documents \"而不是"C:\\ My Documents \\"

你是否同意Java需要更多"糖"？任何人都知道下一个Java版本中会有糖吗？

大多数看起来像运算符的东西都是Ruby中的方法; 1 + 2是语法糖1.+(2).

尽管+并且*是程序可以重新定义的方法,但Ruby具有特殊的魔力来评估1 + 2 * 3,1.+(2.*(3))而不是1.+(2).*(3).

我想知道这个特殊魔法在Ruby中的位置 - 如果它与解释器连接起来很困难.

阿里.

是否可以在不使用typedef的情况下将prepreious声明的函数类型用作函数指针？

功能声明:

int myfunc(float);

通过某种语法将函数声明用作函数指针

myfunc* ptrWithSameTypeAsMyFunc = 0;

如果我有十几个CSS选择器,并希望:hover为所有这些选择器分配属性,我习惯这样做:

selector, selector2, someOtherSelector, someSelector div {
    //some properties
}
selector:hover, selector2:hover, someOtherSelector:hover, someSelector div:hover {
    //some properties
}

打字:hover四次似乎是多余的.有没有办法将选择器分组

(selector, selector2, someOtherSelector, someSelector div):hover {
     //some properties
}

代替？

我想知道在java(纯代码,而不是一些Eclipse的东西)中是否有一种方法可以将"语法糖"重复尝试捕获代码.也就是说,我必须包装一堆函数

public void foo(){
  try{
        // bla
  } catch (Exception e) {
            System.out.println("caught exception:");
            e.printStackTrace();
  }
}

public void bar(){
  try{
        // other bla
  } catch (Exception e) {
            System.out.println("caught exception:");
            e.printStackTrace();
  }
}

等等.我想写

@excepted public void foo(){
// bla
}

@excepted public void bar(){
// other bla
}

我认为这种类型的糖在python中是可能的.在Java中有可能吗？

请考虑以下Java代码:

Integer foo = bar();
if(foo == 5) ...;
if(5 == foo) ...;

这些是比较平等的-尤其是在的可能性foo是null？他们是扩展到foo.getValue() == 5和5 == foo.getValue()/或更类似于foo.equals(new Integer(5))和new Integer(5).equals(foo)/或其他东西？NPM中可能有一个或两个或两个都没有？

在Python中,可以创建一个字典并将其序列化为JSON对象,如下所示:

example = { "key1" : 123, "key2" : "value2" }
js = json.dumps(example)

Go是静态类型的,所以我们必须先声明对象模式:

type Example struct {
    Key1 int
    Key2 string
}

example := &Example { Key1 : 123, Key2 : "value2" }
js, _ := json.Marshal(example)

有时只需要在一个地方而不是其他地方需要具有特定模式(类型声明)的对象(struct).我不想产生许多无用的类型,我不想为此使用反射.

Go中是否有任何语法糖提供更优雅的方法来做到这一点？

我有一个结构:

struct A {
  ComplicatedType1 f();
  ComplicatedType2 f(int);
};

我想获得f()使用编译时助手的返回类型.我正在努力std::result_of<>:

using Type = std::result_of<decltype(&A::f)()>::type;

但是编译器给了我一个合理的错误:"无法解决对重载函数的引用".

所以我去了SO,并看到了这个被接受和赞成的答案,这建议做出一个static_cast<ComplicatedType1 (A::*)()>(&A::f)- 但我现在没有ComplicatedType1.我陷入了递归之中.

如何用最少的代码ComplicatedType1进入我的using表达式？

而不是写作

((x: Double) => (((y: Double) => y*y))(x+x))(3)

我想写点类似的东西

((x: Double) => let y=x+x in y*y)(3)

在Scala中有类似的这种语法糖吗？

我有一个父类,有一堆类方法:

class Parent():

    @classmethod
    def methodA(cls):
        pass

    @classmethod
    def methodB(cls):
        pass

在我的子类中,我想将一个方法的子集包装在"with"中.它应该达到这个效果:

class Child(Parent):

    @classmethod
    def methodA(cls):
        with db.transaction:
            super(Child, cls).methodA()

我有一堆遵循这种模式的方法,我宁愿不重复自己.有更清洁的方法吗？