标签: conditional-binding

我有一个协议定义:

protocol Usable {
    func use()
}

以及符合该协议的类

class Thing: Usable {
    func use () {
        println ("you use the thing")
    }
}

我想以编程方式测试Thing类是否符合Usable协议.

let thing = Thing()

// Check whether or not a class is useable
if let usableThing = thing as Usable { // error here
    usableThing.use()
}
else {
    println("can't use that")
}

但是我得到了错误

Bound value in a conditional binding must be of Optional Type

如果我试试

let thing:Thing? = Thing()

我收到了错误

Cannot downcast from 'Thing?' to non-@objc …

在Ninject 1.0中,我有以下绑定定义:

Bind<ITarget>().To<Target1>().Only(When.Context.Variable("variable").EqualTo(true));
Bind<ITarget>().To<Target2>();

鉴于我有这样的绑定:

ITarget target = kernel.Get<ITarget>(With.Parameters.ContextVariable("variable", true));
ITarget target = kernel.Get<ITarget>(With.Parameters.ContextVariable("variable", false));

第一个调用被解析为Target1的实例,第二个调用被解析为Target2的实例.

如何将其翻译成Ninject 2.0？

我在这里第一次进入 swift 并且我偶然发现了一个闭包语句，根据我目前对闭包是如何编写的理解，它对我来说没有多大意义。这真的是一个由两部分组成的问题，因为我也不太了解这个闭包的条件绑定背后的意图/解释。

我抛出的代码块是这样的：

 FIRAuth.auth()?.createUser(withEmail: email, password: password) {
    (user, error) in if let error = error {
        print(error.localizedDescription)
        return
    }
}

我的理解是，闭包需要根据 docs 定义指定一个返回类型，(something1, something2) -> ()因此从上面的代码位来看，这是否意味着 swift 可以通过不包含-> ()?

我的假设是条件绑定语句只是说'如果一个错误 arg 被传递到这个闭包中，那么打印错误？

请在您的解释中使用尽可能多的细节，以便我进一步理解。干杯!

我想用2个局部变量执行一个函数,但这些变量的值应该取决于某些条件.举例来说,假设我有2个变量x和y,我想里面交换他们let如果y > x.交换应该是暂时的,我不想改变状态rotatef.我的代码看起来像:

(setq x 2)
(setq y 1)
(let (if (> x y) ((x y) (y x)) ((x x) (y y)))
  (cons x y)) ; should return (1 . 2)

但是里面的表达式let并不是有效的Lisp.如何有条件地为本地变量赋值？解决方法是将主体放入flet并使用不同的参数调用它,但它看起来很笨拙:

(flet ((body (x y) (cons x y)))
  (if (< x y)
      (body x y)
      (body y x)))

有没有办法把这个if/ else if/ elseladder写成switch语句？

let x: Any = "123"

if let s = x as? String {
    useString(s)
}
else if let i = x as? Int {
    useInt(i)
}
else if let b = x as? Bool {
    useBool(b)
}
else {
    fatalError()
}

这是我的尝试:

switch x {
case let s where s is String:   useString(s)
case let i where i is Int:      useInt(i)
case let b where b is Bool:     useBool(b)
default: fatalError()
} …