 }
 
 /**
-This function is documented with the FilterFunction type.
-
-:see: FilterFunction
+Builds a filter that takes a single `UInt` argument.
+
+For example:
+
+    let increment = Filter { (x: UInt, _) in
+        return Box(x + 1)
+    }
+
+    let template = Template(string: "{{increment(x)}}")!
+    template.registerInBaseContext("increment", Box(increment))
+
+    // "2"
+    template.render(Box(["x": 1]))!
+
+If the template argument evaluates to a missing value, or a value which is not
+not convertible to UInt, the filter returns an error of domain
+`GRMustacheErrorDomain` and code `GRMustacheErrorCodeRenderingError`:
+
+    // Error evaluating {{increment(x)}} at line 1: Unexpected argument
+    var error: NSError?
+    template.render(Box(), error: &error)
+    template.render(Box(["x": "foo"]), error: &error)
+
+Values which are convertible to UInt are:
+
+    // "2"
+    template.render(Box(["x": 1]))!                     // Int
+    template.render(Box(["x": 1 as UInt]))!             // UInt
+    template.render(Box(["x": 1.0]))!                   // Double
+    template.render(Box(["x": NSNumber(integer: 1)]))!  // NSNumber
+    template.render(Box(["x": NSNumber(bool: true)]))!  // NSNumber (continued)
+    template.render(Box(["x": true]))!                  // Bool
+
+If the filter is given several arguments, an error of domain
+`GRMustacheErrorDomain` and code `GRMustacheErrorCodeRenderingError` is returned
+when the template is rendered.
+
+:param: a function that turns an integer into a MustacheBox
+:returns: a FilterFunction
 */
 public func Filter(filter: (UInt, NSErrorPointer) -> MustacheBox?) -> FilterFunction {
     return { (box: MustacheBox, partialApplication: Bool, error: NSErrorPointer) in

    let template = Template(string: "{{identity(a)}}, {{identity(b)}}")!
    template.registerInBaseContext("identity", Box(identity))

    // "foo,bar"
    template.render(Box(["a": "foo", "b": "bar"]))!

If the filter is given several arguments, an error of domain
`GRMustacheErrorDomain` and code `GRMustacheErrorCodeRenderingError` is returned
when the template is rendered.

### Value extraction

It is likely you want to extract the boxed value and process it.

`MustacheBox` comes with the many properties that let you do that, in a safe
way. If you expect an integer, use `box.intValue`. An array? `box.arrayValue`.
They avoid dangerous type casts, and make sure they work with all compatible
inputs. For example, `box.intValue` returns an Int for boxed ints (obviously),
but also bools, uints, doubles, and NSNumbers. `MustacheBox.arrayValue` works
for all Swift and Objective-C collections. Check `MustacheBox` documentation.

Yet, the `Filter()` function comes with more straightforward variants that help
you process specific classes:

- func Filter<T>(filter: (T?, NSErrorPointer) -> MustacheBox?) -> FilterFunction
- func Filter<T>(filter: (T, NSErrorPointer) -> MustacheBox?) -> FilterFunction
- func Filter(filter: (Int?, NSErrorPointer) -> MustacheBox?) -> FilterFunction
- func Filter(filter: (Int, NSErrorPointer) -> MustacheBox?) -> FilterFunction
- func Filter(filter: (UInt?, NSErrorPointer) -> MustacheBox?) -> FilterFunction
- func Filter(filter: (UInt, NSErrorPointer) -> MustacheBox?) -> FilterFunction
- func Filter(filter: (Double?, NSErrorPointer) -> MustacheBox?) -> FilterFunction
- func Filter(filter: (Double, NSErrorPointer) -> MustacheBox?) -> FilterFunction

Check their documentation.

:param: a function that turns a box in another box
:returns: a FilterFunction
*/
public func Filter(filter: (MustacheBox, NSErrorPointer) -> MustacheBox?) -> FilterFunction {

}

/**
Builds a filter that takes a single `UInt?` argument.

For example:

    let increment = Filter { (x: UInt?, _) in
        if let x = x {
            return Box(x + 1)
        } else {
            return Box()
        }
    }

    let template = Template(string: "{{increment(x)}}")!
    template.registerInBaseContext("increment", Box(increment))

    // "2"
    template.render(Box(["x": 1]))!

If the template argument evaluates to a missing value, or a value which is not
convertible to UInt, the filter is given nil.

    // Both render the empty string
    template.render(Box())!
    template.render(Box(["x": "foo"]))!

Values which are convertible to UInt are:
    
    // "2"
    template.render(Box(["x": 1]))!                     // Int
    template.render(Box(["x": 1 as UInt]))!             // UInt
    template.render(Box(["x": 1.0]))!                   // Double
    template.render(Box(["x": NSNumber(integer: 1)]))!  // NSNumber
    template.render(Box(["x": NSNumber(bool: true)]))!  // NSNumber (continued)
    template.render(Box(["x": true]))!                  // Bool

If the filter is given several arguments, an error of domain
`GRMustacheErrorDomain` and code `GRMustacheErrorCodeRenderingError` is returned
when the template is rendered.

:param: a function that turns an integer into a MustacheBox
:returns: a FilterFunction
*/
public func Filter(filter: (UInt?, NSErrorPointer) -> MustacheBox?) -> FilterFunction {
    return { (box: MustacheBox, partialApplication: Bool, error: NSErrorPointer) in
