标签: syntactic-sugar

我想为现有的类库创建一些简单的包装类.为了使语法很好阅读和猜测很好(通过代码完成)我想删除java.lang.Object的方法.

问题是java中的所有非原子事物都继承自Object,因此具有这些方法.我已经尝试通过枚举和接口创建包装器语法,但没有成功; 因为枚举和接口也是java.lang.Objects.

java.lang.Object有九个方法,我不希望在我的接口的代码完成中看到.这是我要删除的内容(红色)和我想要保留的内容(绿色):

alt text http://ju.venile.de/upload/java-lang-object-methods.png

下面是一些用于在现有类周围创建漂亮包装器的示例代码(Builder模式):

public interface IMySyntax{
  public IMySyntax myMethod1();
  public IMySyntax myMethod2();
}

public class MyBuilder implements IMySyntax{
  public static IMySyntax build(){ return (IMySyntax) new MyBuilder() }
  public IMySyntax myMethod1(){ /* do something */ return (IMySyntax) this }
  public IMySyntax myMethod2(){ /* do something */ return (IMySyntax) this }     
}

新包装器代码的用法应如下所示:

MyBuilder.build()
         .myMethod1()
         .myMethod2();

this将构建器的所有语句强制转换为接口将降低方法可见性,例如,如果构建器实现了多个接口.遗憾的是,所有java.lang.Object方法都将保留.

如果这种方法隐藏在Java中是可能的(可能使用Annotations？),我可以创建一个与IDE无关的好库(各处都有很好的代码完成).如果不是,那么至少Eclipse IDE(可能是一个插件？)可以提供一个可以提供java.lang.Object方法隐藏的技巧.

让我们说一下,C#允许最纯粹意义上的多个返回值,我们希望看到类似的东西:

string sender = message.GetSender();
string receiver = message.GetReceiver();

压缩到:

string sender, receiver = message.GetParticipants();

在这种情况下,在实际调用方法之前,我不必理解方法的返回值.也许我依靠Intellisense来告诉我我正在处理什么样的返回值,或者我正在寻找一种从我不熟悉的类中返回我想要的方法.

同样,我们目前在C#中有类似的东西:

string receiver;
string sender = message.GetParticipants(out receiver);

GetParticipants的参数是out字符串参数.但是,这与上面的有点不同,因为这意味着我必须先抢占,或者至少返回并编写创建变量以保存out参数结果的代码.这有点违反直觉.

我的问题是,当前C#中是否存在任何语法糖,它允许开发人员在与方法调用相同的行中进行此声明？我认为它会使开发变得更加流畅,并且如果我做了类似的事情,也会使代码更具可读性:

string sender = message.GetParicipants(out string receiver);

表明接收器是在现场宣布和分配的.

var obj = {}
obj.__setitem__ = function(key, value){
  this[key] = value * value
}
obj.x = 2  // 4
obj.y = 3  // 9

JavaScript没有__setitem__,这个例子显然不起作用.

在python __setitem__中的工作方式如下:

class CustomDict(dict):
  def __setitem__(self, key, value):
    super(CustomDict, self).__setitem__(key, value * value)

d = CustomDict()
d['x'] = 2  # 4
d['y'] = 3  # 9

是否可以在JavaScript中实现__setitem__行为？所有棘手的解决方法都会有所帮助.

我不知道这是否可行,但在我的一些单元测试中,我最终用相同的参数初始化不同的对象.我希望能够将这些参数存储在某个变量中,并使用该变量初始化多参数对象构造函数,而不是执行以下操作:

Thing thing1 = new Thing(arg1, arg2, arg3, arg4);
Thing thing2 = new Thing(arg1, arg2, arg3, arg4);
Thing thing3 = new Thing(arg1, arg2, arg3, arg4);

我可以做以下事情:

MagicalArgumentsContainer args = (arg1, arg2, arg3, arg4);
Thing thing1 = new Thing(args);
Thing thing2 = new Thing(args);
Thing thing3 = new Thing(args);

有没有办法在没有覆盖Thing的构造函数的情况下执行此操作来获取一个手动爆炸并从中获取参数的列表？也许一些C#语法糖？

你会欣赏以下两种句法糖:

lock(obj)
{
//Code
}

same as:

Monitor.Enter(obj)
try
{
//Code
}
finally
{
Monitor.Exit(obj)
}

和

using(var adapt = new adapter()){
//Code2
}

same as:

var adapt= new adapter()
try{
//Code2
}
finally{
adapt.Dispose()
}

显然,每种情况下的第一个例子都更具可读性.有没有办法自己定义这种东西,无论是在C#语言中,还是在IDE中？我问的原因是,有很多类似的用法(长篇)可以从中受益,例如.如果您正在使用ReaderWriterLockSlim,那么您需要一些非常相似的东西.

编辑1:

我被要求提供一个例子,所以我会试一试:

myclass
{
ReaderWriterLockSlim rwl = new ReaderWriterLockSlim();

void MyConcurrentMethod()
{
  rwl.EnterReadLock();
  try{
    //Code to do in the lock, often just one line, but now its turned into 8!
  }
  finally
  {
    rwl.ExitReadLock();
  }
}
}

//I'd rather have:
void MyConcurrentMethod()
{ …

考虑以下会话.如何解释差异？我认为这a += b是一种语法糖(因而相当于)a = a + b.显然我错了.

>>> import numpy as np
>>> a  = np.arange(24.).reshape(4,6)
>>> print a
[[  0.   1.   2.   3.   4.   5.]
 [  6.   7.   8.   9.  10.  11.]
 [ 12.  13.  14.  15.  16.  17.]
 [ 18.  19.  20.  21.  22.  23.]]
>>> for line in a:
...     line += 100
...
>>> print a #a has been changed
[[ 100.  101.  102.  103.  104.  105.]
 [ 106.  107.  108.  109. …

我注意到当我反映到一个程序集时,对属性访问器的调用有时看起来像方法

// "Reflected" example
class Class1 {
   public bool Boolean { get; set;}
}

class Class2 {
   public Class2() {
       var class1 = new Class1();
       var boolean = class1.get_Boolean();
   }
}

现在我很好奇,我把一个带有类似签名的方法Class1看作是访问者的标准约定.

// "Hacked" example
class Class1 {
   public bool get_Boolean() { return true; }
}

不知何故,C#编译器仍将其视为get_Boolean一种方法.

获得一种方法成为财产的神奇之处是什么？

在Common Lisp中,显然有一些特殊字符可以作为某些表单的快捷方式.'x手段(quote x).#'f手段(function f).我曾经认为那些(以及反击)是唯一的,但后来我了解到#(),这显然是一个载体,就在今天有人提到过#.,这显然与评估时间有关.

尽我所能,我似乎无法找到一个完整的列表,其中的前缀符号意味着什么,他们做什么？这是由实施决定的东西,还是有人可以指向我在标准中的某个地方全面列出这些快捷方式？

是否有应用和分配对象变量方法调用的惯用方法，但前提是它已定义（方法和结果）？

就像使用安全调用运算符.?和定义或运算符//，以及“DRY 原则”——在操作中只使用一次变量？

像这样（但使用另一个变量感觉像是在作弊）：

my $nicevariable = "fobar";

# key step
(my $x := $nicevariable) = $x.?possibly-nonexistent-meth // $x;

say $nicevariable;  # => possibly-nonexistent-meth (non-Nil) result or "foobar"

... 并避免andthen，如果可能的话。

我想知道在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中有可能吗？