Question about this based on reading the MSDN doc: http://msdn.microsoft.com/en-us/library/hh229425(v=vs.103).aspx

Is it supposed to have ONLY a single element that then must match the predicate, or can you have a sequence of N items as long as only 1 item matches the predicate?

Right now this implementation expects the sequence to only have 1 item and the predicate just validates it matches what's expected.

Here is the part that makes me think it should be the second definition:

"Returns the only element of an observable sequence that matches the predicate"

That suggests that a sequence will be filtered with the predicate and then throw an exception if there is more than one.

Thus, single with a predicate would be somewhat like this:

```java
that.filter(predicate).single()
```

Here is code from the Javascript implementation that confirms my understanding if I'm reading it right (https://rx.codeplex.com/SourceControl/changeset/view/7881e17c060b#Rx/JS/rx.aggregates.js):

```javascript
    /**
     * Returns the only element of an observable sequence that satisfies the condition in the optional predicate, and reports an exception if there is not exactly one element in the observable sequence.
     * 
     * 1 - res = source.single();
     * 2 - res = source.single(function (x) { return x === 42; });
     * 
     * @param {Function} [predicate] A predicate function to evaluate for elements in the source sequence.
     * @return Sequence containing the single element in the observable sequence that satisfies the condition in the predicate.
     */
    observableProto.single = function (predicate) {
        if (predicate) {
            return this.where(predicate).single();
        }
        return singleOrDefaultAsync(this, false);
    };
```