标签: syntactic-sugar

而不是写作

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

我想写点类似的东西

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

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

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

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

在Clojure中,方括号是定义向量的简写:

user=> (vector 'a 'b 'c)
[a b c]
user=> ['a 'b 'c]
[a b c]

该文档页面的vector讲的很长的路要走,并确定载体的一小段路.

然而,在defn和doseq那里似乎存在差异.

user=> (doseq [x (range 1 4)] (printf "%d\n" x)) 
1
2
3
nil
user=> (doseq (vector 'x (range 1 4)) (printf "%d\n" x)) 
IllegalArgumentException doseq requires a vector for its binding in user:1 clojure.core/doseq (core.clj:2935)

这种差异的原因是什么？方括号在读者中是否具有特殊地位,或者它们是否具有特定的形式？

我最近在内部javascript库中添加了一个HasValue函数:

function HasValue(item) {
    return (item !== undefined && item !== null);
}

在与同事交流期间,我们提出了添加另一个基本上只是反过来的函数的想法:也许是HasNoValue,或IsNothing如果我们最终做到了这样我们会:

function HasNoValue(item) {
    return (item === undefined || item === null);
}
function HasValue(item) {
    return !HasNoValue(item);
}

但是,我们不确定它们和HasValue是否更具可读性.哪个更具可读性/首选？

A:

if (HasValue(x) && !HasValue(y))

B:

if (HasValue(x) && HasNoValue(y))

在SQL Server上的BETWEEN查询中,v1和v2的顺序是否有差异？

SELECT *
  FROM table
 WHERE col BETWEEN v1 AND v2

如果v1大于v2,目前我没有得到任何结果.这只是语法糖吗？

col >= v1 AND col <= v2

或者它真的取两者之间的所有价值？根据我目前的观察,我猜这是第一种情况.

假设我想向Java添加一些小的语法糖.只是添加正则表达式模式文字,或者可能是base-2文字或多行字符串等等.没有什么主要的语法(至少现在).

怎么会这样做呢？

我是否需要扩展字节码编译器？(那可能吗？)

我可以编写Eclipse插件来进行简单的源代码转换,然后再将其提供给标准的Java编译器吗？

场景:
我想要一个包含标准牌组中所有扑克牌的枚举.对于这个例子,忽略这些笑话.

写作

enum Cards {
    SPADE_1(0, 1),
    SPADE_2(0, 2),
    etc.

感觉不对.

我希望能够做到这样的事情

enum Card {
    for (int suit=0; suit<4; suit++) {
        for (int face=1; face<13; face++) {
            new Card(suit, face);
        }
    }
}

我已经考虑将卡片定义为包含西装和脸部领域的类,其中西装和脸部本身就是枚举.然而,在其他情况下(例如具有红色和黑色的套装的笑话),这将允许创建无效的卡对象(即,钻石的小丑或红色10).

自我回答:
显然我没有足够的代表来回答我自己的问题.

I'm not sure if it's considered good form to answer my own question, but @Paul just gave me a brainwave.

Declare Card to have a private constructor, and use a
    static Card getCard(suit, face)
method to validate combinations before returning them.

我有一组经常使用的函数,所以我想在库中收集它们.在我开始编写库之前,我在考虑在哪里存储影响某些函数行为的常量.

使用该库时我想写的内容如下:

import tools
tools.collect(object_a, object_b, mode=tools.collect.RECURSIVE)

一般来说,函数应该能够接受的常量应该存储在函数本身中.

为了实现这一点,我创建了一个装饰器函数,将传递的属性分配给修饰函数.

def attr_decorator(**attrs):
    def decorator(f):
        for k, v in attrs.iteritems():
            setattr(f, k, v)
        return f
    return decorator

这个装饰器可以像这样使用:

@attr_decorator(
    FLAT = 1 << 0,
    RECURSIVE 1 << 1,
)
def collect(a, b, mode):
    # ...

到目前为止这个工作非常好.

但是默认参数呢？

@attr_decorator(
    FLAT = 1 << 0,
    RECURSIVE 1 << 1,
)
def collect(a, b, mode=collect.RECURSIVE):
    # ...

这不起作用,因为在存储mode参数的default-value时未定义collect函数(因此甚至没有修饰).

这看起来不太好看

我能够提出的唯一解决方案导致了一种笨拙的语法,它看起来并不好看.我给装饰器函数提供了与要装饰的函数相同的属性.

def attr_decorator(**attrs):
    def decorator(f):
        for k, v in attrs.iteritems():
            setattr(f, k, …

我正在捣乱,制作一个泛型类,而且这一次我想使用IComparable使用比较运算符实现的类型.

我知道.CompareTo()可以在功能上执行相同的操作,但我有一种唠叨的感觉,必须有一个实现比较运算符的接口.