Question: I thought I knew a thing or two... then I met RegEx.
So what I am trying to do is a multistring negative look-ahead? Is that a thing?
Basically I want to find when a 3rd string exists BUT two precursory strings do NOT.

```
(?i:<!((yellow thing)\s(w+\s+){0,20}(blue thing))\s(\w+\s+){0,100}(green thing))

```

Target String:

* Here we have a yellow thing. Here we have a blue thing. Clearly the green thing is best though. (Should NOT match)
* You wanna buy some death sticks? I have a green thing. (MATCH)
* We are on a yellow thing submarine? Look at that green thing over there! (MATCH)

Answer: 
The error message is misleading. The problem is that the compiler has
no information what type the values `.Zero`, `.NotZero` refer to.

The problem is also unrelated to managed objects or the `valueForKey`
method, you would get the same error message for

```
func foo(value: Int) {
    let eltType = value == 0 ? .Zero : .NotZero // Ambiguous reference to member '=='
    // ...
}

```

The problem can be solved by specifying a fully typed value

```
let eltType = value == 0 ? MyEnum.Zero : .NotZero

```

or by providing a context from which the compiler can infer the type:

```
let eltType: MyEnum = value == 0 ? .Zero : .NotZero

```
Remove the bracelet seems to works : 

`let eltType = (object.valueForKey("type")! as! Int) == 0 ? .Zero : .NotZero`