标签: syntactic-sugar

考虑:

List<String> someList = new ArrayList<String>();
// add "monkey", "donkey", "skeleton key" to someList

for (String item : someList) {
    System.out.println(item);
}

如果for不使用for each语法,等效循环会是什么样的？

我喜欢这个字符串数组的文字表达式:

%w( i can easily create arrays of words )

我想知道是否有一个文字来获得一个符号数组.我知道我能做到

%w( it is less elegant to create arrays of symbols ).map( &:to_sym )

但是使用文字就好了.

这里有一些宝石:

文字:

var obj = {}; // Object literal, equivalent to var obj = new Object();
var arr = []; // Array literal, equivalent to var arr = new Array();
var regex = /something/; // Regular expression literal, equivalent to var regex = new RegExp('something');

默认值:

arg = arg || 'default'; // if arg evaluates to false, use 'default', which is the same as:
arg = !!arg ? arg : 'default';

当然我们知道匿名函数,但能够将它们视为文字并在现场执行它们(作为闭包)很棒:

(function() { ... })(); // Creates an anonymous …

在Scala中,如果我定义一个apply在类或顶级对象中调用的方法,那么每当我将一个圆括号添加到该类的实例时,将调用该方法,并apply()在它们之间放置适当的参数.例如:

class Foo(x: Int) {
    def apply(y: Int) = {
        x*x + y*y
    }
}

val f = new Foo(3)
f(4)   // returns 25

所以基本上,object(args)只是语法糖object.apply(args).

Scala如何进行此转换？

这里是否存在全局定义的隐式转换,类似于Predef对象中的隐式类型转换(但实物类型不同)？或者它是一些更深层次的魔法？我问,因为看起来Scala强烈赞成一套较小的规则的一致应用,而不是许多例外的许多规则.这最初对我来说似乎是个例外.

我开始非常喜欢延伸方法......我想知道是否有人偶然发现了一个真正引起他们注意的人,或者只是发现了聪明.

我今天写的一个例子:

由于其他用户的评论而编辑:

public static IEnumerable<int> To(this int fromNumber, int toNumber) {
    while (fromNumber < toNumber) {
        yield return fromNumber;
        fromNumber++;
    }
}

这允许将for循环写为foreach循环:

foreach (int x in 0.To(16)) {
    Console.WriteLine(Math.Pow(2, x).ToString());
}

我迫不及待想看其他例子!请享用!

我刚刚在C#中工作时遇到此错误消息

属性或索引器不能作为out或ref参数传递

我知道造成这种情况的原因并快速解决了创建正确类型的局部变量的问题,使用它作为out/ ref参数调用函数,然后将其分配回属性:

RefFn(ref obj.prop);

变成

{
    var t = obj.prop;
    RefFn(ref t);
    obj.prop = t;
}

显然,如果属性不支持在当前上下文中获取和设置,则会失败.

为什么C#不能为我这样做？

我能想到这可能导致问题的唯一情况是:

• 穿线
• 例外

对于线程转换影响写入发生时(在函数调用之后与函数调用之间),但我宁愿怀疑任何依赖的代码在它中断时会得到很少的同情.

对于例外,关注的是; 如果函数分配给几个ref参数之一而不是抛出会发生什么？任何一个简单的解决方案都会导致所有参数都被分配给某些参数,而某些参数不应该分配给某些参数.我再次认为这不会支持使用该语言.

注意:我理解为什么会生成此错误消息的机制.我正在寻找的是为什么C#不会自动实现简单的解决方法.

Scala中语法糖的所有实例是什么？

它们很难搜索,因为它们中的大部分/全部都是纯符号,因此在不知道概念名称的情况下难以搜索.

去做:

• 隐含的转换
• _ 匿名函数的语法
• 其他我忘记的事情

Ruby/Rails在谈到基本用品的糖时会做很多很酷的事情,我认为有一种非常常见的情况,我想知道是否有人做过帮手或类似的东西.

   a = Array.new(5, 1)

   a.each_with_index do |x, i|
     if i == 0
       print x+1
     elsif i == (a.length - 1)
       print x*10
     else
        print x
     end
   end

原谅丑陋,但这可以达到人们想要的......是否有一种红宝石的方式来对循环的第一个和最后一个做一些事情？

[编辑]我认为理想情况下这将是带有参数的数组的扩展(数组实例,所有元素函数,第一个元素函数,最后元素函数)......但我对其他想法持开放态度.

正如我所理解的那样,有两种方法可以做Python装饰器,既可以使用__call__类,也可以定义函数作为装饰器.这些方法的优点/缺点是什么？有一种首选方法吗？

例1

class dec1(object):
    def __init__(self, f):
        self.f = f
    def __call__(self):
        print "Decorating", self.f.__name__
        self.f()

@dec1
def func1():
    print "inside func1()"

func1()

# Decorating func1
# inside func1()

例2

def dec2(f):
    def new_f():
        print "Decorating", f.__name__
        f()
    return new_f

@dec2
def func2():
    print "inside func2()"

func2()

# Decorating func2
# inside func2()

由于其丑陋的语法和命名空间污染,许多人认为Haskell的记录语法是一种优雅语言的疣.另一方面,它通常比基于位置的替代方案更有用.

而不是像这样的声明:

data Foo = Foo { 
  fooID :: Int, 
  fooName :: String 
} deriving (Show)

在我看来,这些方面的东西会更有吸引力:

data Foo = Foo id   :: Int
               name :: String
               deriving (Show)

我确信必须有一个很好的理由让我失踪,但为什么采用类似C语言的记录语法采用更简洁的基于布局的方法？

其次,管道中是否有任何东西可以解决命名空间问题,所以我们可以编写id foo而不是fooID foo在Haskell的未来版本中编写？(除了目前可用的基于longwinded类型的变通办法.)