小编whe*_*ies的帖子

在C++中,我可以执行以下操作:

template<typename T, typename V>
struct{
    void operator()(T _1, V _2){
        _2.foo( _1 );
    }
};

这让我随意决定使用任何有一些名为"foo"的方法的对象,它采用某种类型"T",而不事先指定"foo"函数的参数类型和所述函数的返回类型.

当我看到Scala时,看到像Function1这样的特征,并且正在使用像.这样的函数定义

def foo[T<:{def foo():Unit}]( arg:T ) = //something
def bar( x:{def foo():Unit} ) = //something
def baz[T,V<:Function1[T,_]]( x:T, y:V ) = y( x )

我看着自己,想想为什么我不能做同样的事情？为什么"baz"会返回Any？它不能在编译时推断出实际的返回类型吗？如果我甚至不使用它,为什么我必须声明返回类型"foo"？

我希望能够做到

def biff[T,V:{def foo( x:T ):Unit}] = //something

要么

def boff[T<:{def foo( x:Double ):_}]( y:T ) = y.foo _

你能做到这一点,我只是错过了一些东西吗？如果没有,为什么不呢？

SurfaceView首次启动应用程序时,我想打开一个带有图标的图标放在屏幕中央.我正在唤起图标创建,使用一个实现SurfaceHolder.Callback来跟踪'Canvas'对象何时准备就绪.我的问题是有更好的方法吗？是否有不那么繁琐的方法来启动SurfaceView一些Drawables加载创建而不必诉诸于在回调对象中放置绘制逻辑？

这是我的代码供参考.首先绘制的对象:

public class CanvasDraw{
    protected final SurfaceHolder mHolder;
    protected final Drawable mDrawable;

    public interface DrawLogic{
        void draw(Rect _surface);
    }

    public CanvasDraw(SurfaceView _view, Drawable _drawable){
        mHolder = _view.getHolder();
        mDrawable = _drawable;
    }

    public void draw(DrawLogic _logic){
        Canvas canvas = null;
        try{
            canvas = mHolder.lockCanvas();
            if( canvas != null ){
                Log.i("DRAWABLE", "Drawing " + mDrawable.toString());
                _logic.draw( mHolder.getSurfaceFrame() );
                mDrawable.draw(canvas);
            }
            else{
                Log.i("DRAWABLE", "Canvas null valued");
            }
        }
        finally{
            if( canvas != null ){
                mHolder.unlockCanvasAndPost(canvas); …

我已经尝试了一些似乎可以编译但在单元测试期间抛出NullPointer异常的东西,所以我想知道如何可能克服单元测试中的限制.我有一个看起来像这样的课:

class LogWriter extends Actor{
  def receive{
    case x:Timing => log.info(x toString)
    case x:Event => log.info(x toString)
    case x:Any => log.warning("Improper message sent to LogWriter, %s".format(x toString))
  }
}

但是尝试使用Specs2和Mockito支持进行单元测试,其中包括以下内容:

class LogWriterSpec extends Mokito with Specification{
  val mockedLog = mock[Logger]

  class MockedLogWriter extends LogWriter{
    @transient override val log = mockedLog
  }

  val writer = actorOf(new MockedLogWriter).start

  def testTiming = {
    val message = Timing("testTiming", 15 seconds)
    writer !! (message, 400)
    there was one(mockedLog).info(message toString)
  }

  def is = "A LogWriter" …

我有一个从数据库中的表中提取的元组列表,它们看起来像(键,外键,值).key和foreignkeys之间有多对一的关系,我想将它转换为由foreignkey索引的dict,其中包含所有值与该外键的总和,即{ foreignkey,sumof ( value ) }.我写了一些相当冗长的东西:

myDict = {}
for item in myTupleList:
    if item[1] in myDict:
        myDict [ item[1] ] += item[2]
    else:
        myDict [ item[1] ] = item[2]

但在看到这个问题的答案或者这 两个问题之后,我必须更简洁地表达我想做的事情.如果这是重复,我错过了它,并将删除问题,如果你可以提供链接.

我编写了一个扩展Iterator [A]的自定义特性,我希望能够使用我在另一个方法返回的迭代器[A]上编写的方法.这可能吗？

trait Increment[+A] extends Iterator[A]{
    def foo() = "something"
}

class Bar( source:BufferedSource){
    //this ain't working
    def getContents():Increment[+A] = source getLines
}

我仍然试图绕过整个隐含的东西而不是在Bar对象定义中编写方法.我将如何以上述方式包装这样的物品？

因为我还在学习Android(而且看起来亚马逊说我要花2个月才拿到Hello,Android书)我仍然在做着简单的事情.使用ImageView点击RelativeLayout上的按钮,即可显示图标.创建它的代码如下:

private int mIconIdCounter = 1;
private ImageView addIcon(){
    ImageView item = new ImageView(this);
    item.setImageResource( R.drawable.tiles );
    item.setAdjustViewBounds(true);
    RelativeLayout.LayoutParams params = new RelativeLayout.LayoutParams( LayoutParams.WRAP_CONTENT, LayoutParams.WRAP_CONTENT );
    if( mIconIdCounter != 1 ){
        params.addRule(RelativeLayout.RIGHT_OF, 1 );
    }
    item.setLayoutParams( params );
    item.setId( mIconIdCounter );
    ++m_IconIdCounter;
    return item;
}

并且添加项目的代码是:

Button addButton = (Button)findViewById(R.id.add_new);
addButton.setOnClickListener( new OnClickListener(){
    @Override
    public void onClick(View view) {
        addContentView( addIcon(), new RelativeLayout.LayoutParams( LayoutParams.WRAP_CONTENT, LayoutParams.WRAP_CONTENT ) );
    }
});

当我点击我的按钮时会发生什么,所有新创建的视图都放在另一个上面.我希望它们被放置在下一个元素的右侧.我在SO上快速搜索了与RelativeLayout相关的文章,并发现了一些相似的内容(这里,这里,这里,这里),但是这些内容解决了将内容引入RelativeView的问题,他们似乎没有解决定位问题. …

假设我有以下结构(使用Flask-SqlAlchemy):

class User(db.Model):
    id = db.Column(db.Integer, primary_key=True)
    name = db.Column(db.String, nullable=False, index=True)
    # The following line throws an error at runtime.
    variant = db.Column(db.Integer, nullable=False, index=True,
                        default=select(func.count(User.id)).where(User.name == self.name))

    def __init__(self, name):
        super(User, self).__init__()
        self.name = name

    @property
    def clause(self):
        return '/'.join([str(self.variant), self.name])

问题是,"用户未定义".我想建模一个系统,用户可以选择相同的名称,但添加一个字段,以系统的方式区分用户,而不使用(从而暴露)"id"字段.

任何人都知道如何使用自引用查询来填充默认值？

星期五下午，我炸了。因此，SQL爱好者同胞介绍了如何在PostgreSQL中采用以下WHERE子句并将其转换为SQLite3而不使用已编译的扩展名：

WHERE
  DATE_TRUNC('day', c.start_date) <= DATE_TRUNC('day', q.date) AND
  DATE_TRUNC('day', c.end_date) >= DATE_TRUNC('day', q.date)

查看SQLite3中的日期/时间函数，似乎它们仅用于字符串格式。希望我看到了问题。

在使用Java或C++进行编程时,有很多次我遇到了一个简单的模式,自定义控件结构可以减少代码中的样板.它类似于:

 if( Predicate ){
     Action

     return Value
 }

也就是说,"return if"类型语句.我已经尝试过制作带有签名的功能foo[A,B]( pred:((A,A)=>Boolean), value:Option[B] )但是我最终会检查我是否已经返回了Some或None.我被return声明绊倒了.

是否有继承方式在函数式语言或更具体的Scala中创建这样的控制结构？

编辑:

我的描述并不那么清楚,而且那些试图帮助我的人会感到困惑.我foo不工作的关键原因是它不能使包含函数的评估短路.那是

def intersect( geometry:Geometry, reference:Geometry ):Geometry = {
    return_if( withinBounds( geometry, projection ), logToString( logger, "Geometry outside " + projection.toString ), EmptyGeometry() )
    return_if( topologicallyCorrect( geometry ), intersect( correct( geometry ), reference )
    //rest of the function
}

并且仍允许在内部进行尾递归return_if.

def white():
    print
print ("First line")
white()
print ("Second line")

这是我的第一个脚本之一.当我按下"F5"键时,结果如下:

First line
Second line

哪里出错了？