标签: syntactic-sugar

而不是写作

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

我想写点类似的东西

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

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

难道是有意义的有一个" constify"操作C/C++,使一个变量const？

这是一个可能有用的示例,显然我们不想const在第一行声明它:

std::vector<int> v;
v.push_back(5);
constify v; // now it's const

目前,没有这种可能性,你必须引入另一个变量来获得相同的效果:

std::vector<int> v0;
v0.push_back(5);
const std::vector<int>& v = v0;

这更令人困惑,因为它在范围中添加了一个新名称,你需要使它成为一个参考,以避免复制整个向量(或使用swap？).

对于这里的核心C#编码器,这看起来似乎是一个完全愚蠢的问题 - 但是,我刚刚在AWS SDK论坛中遇到了一段示例代码,并且完全被它所取代:

   RunInstancesRequest runInstance = new RunInstancesRequest()
    .WithMinCount(1)
    .WithMaxCount(1)
    .WithImageId(GetXMLElement("ami"))
    .WithInstanceType("t1.micro");

这很让人联想到旧的VB6 With ... End With语法,我一直对C#中没有这种语法感到遗憾 - 我已经在我的VS2008项目中编译了它,并且它可以节省许多独立的行,分别引用这些属性.

我确定我在过去读过文章解释为什么VB6样式的With块不在C#中,所以我的问题是:这种语法是否总是存在于语言中,或者它是最近的.NET更改启用了吗？我们可以覆盖所有对象实例化,然后在同一糖中进行属性更改吗？

Scala中是否有替代的"List"语法？是否可以定义一个名为'['和']'的aditional类/类型/运算符*？

我知道'方括号'用于表示类型,但它们对于声明列表的重复性任务是完美的.

一个 ';' 要么 '？' 作为最后的资源,也会很好.

谢谢

obs:经过多次搜索,我找到的唯一选择是使用'cons':

val list = 1 :: 2 :: 3 :: Nil

但它根本不会减少任何键输入.

• 我仍然在Scala中学习这些东西

编辑:只是为了澄清:在我的情况下,性能不是优先考虑的问题.是的,转变不受欢迎.:P动机幕后:我喜欢Haskell风格,但不能直接用Java.

编辑2:基于Rex Kerr解决方案的最终解决方案

实现对象类型:

package a
object Types {
  type \[z] = List[z]
  implicit def make_lists[A](z: A) = new ListMaker(z)

  class ListMaker[A](a0: A) {
    private[this] val buffer = List.newBuilder[A]
    buffer += a0
    def \(z: A) = {
      buffer += z;
      this
    }
    def \\ = buffer.result
  }
}

使用对象类型:

package a
import a.Types._

object Whatever {
  def listInListOut (l: …

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

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()

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

我一直在使用:_*转换Seq[String]到String*,我意识到,我不明白这是如何工作的引擎盖下.

有没有一种简单的方法来考虑这个？

Haskell如何翻译[并]进入列表定义？他们是否重视构造者或其他什么？他们是新类型吗？有没有办法定义一个outfix语法,而不是一个中缀语法？

我希望在C#中看到的是关于元组的更好的语法,例如.

var rgb = (1.0f, 1.0f, 1.0f);
// Inferred to be Tuple<float, float, float>
// Translated to var rgb = Tuple.Create(1.0f, 1.0f, 1.0f)

和

var x, y, z = rgb;

// Translated to:
//    float x = rgb.Item1;
//    float y = rgb.Item2;
//    float z = rgb.Item3;

C#语言中有什么禁止这个,或者实现它太难/不现实吗？也许还有其他语言功能会与此直接冲突？

请注意,我不是在询问这是否在微软雷达上,或者即使它与他们对C#的愿景保持一致,只是理论上它有明显的阻挡剂.

编辑 以下是其他CLI语言的一些示例

// Nemerle - will use a tuple type from a language specific runtime library
def colour = (0.5f, 0.5f, 1.0f);
def (r, g, b) = colour;

// F# …

这篇文章解释了foreach循环直接对应于使用迭代器.如果我写一个foreach循环,它真的会转换成for for iterator？特别是给定的循环:

for(Integer i : createList()){
    System.out.println(i);
}

createList()无论如何,我保证总是只打一次电话吗？它被重写为:

for(Iterator<Integer> i = createList().iterator(); i.hasNext(); ) {
    System.out.println(i.next());
}

在某种中间步骤或恰好产生与上述相同的字节码？

考虑这个template函数,调用一个对象的方法class T.

template<class T, void (T::*Method)()>
void circuitousInvoke(T* callee) {
    (callee->*Method)();
}

例:

struct A {
    void test() {};
}

circuitousInvoke<A, &A::test>(new A);

由于参数中的circuitousInvoke已经知道类型T callee,有没有办法避免输入这种类型？

circuitousInvoke<&A::test>(new A);

编辑

此问题仅涉及模板功能.在这种情况下,继承和其他基于类的解决方案不适用.(在我的项目中使用包装器对象会比输入其他名称更糟糕.)