         return Rendering(string)
     }
 
-    let template = Template(string: "I have {{ cats.count }} {{# pluralize(cats.count) }}cat{{/ }}.")!
+    let template = try! Template(string: "I have {{ cats.count }} {{# pluralize(cats.count) }}cat{{/ }}.")
     template.registerInBaseContext("pluralize", Box(pluralize))
 
     // Renders "I have 3 cats."
     let data = ["cats": ["Kitty", "Pussy", "Melba"]]
-    template.render(Box(data))!
+    try! template.render(Box(data))
 
 The argument is converted to `T` using the built-in `as?` operator before being
 given to the filter.

they are about to render.

    let logTags: WillRenderFunction = { (tag: Tag, box: MustacheBox) in
        println("\(tag) will render \(box.value!)")
        return box
    }

    // By entering the base context of the template, the logTags function
    // will be notified of all tags.
    let template = Template(string: "{{# user }}{{ firstName }} {{ lastName }}{{/ user }}")!
    template.extendBaseContext(Box(willRender))

    // Prints:
    // {{# user }} at line 1 will render { firstName = Errol; lastName = Flynn; }
    // {{ firstName }} at line 1 will render Errol
    // {{ lastName }} at line 1 will render Flynn
    let data = ["user": ["firstName": "Errol", "lastName": "Flynn"]]
    template.render(Box(data))!

`WillRenderFunction` don't have to enter the base context of a template to
perform: they can enter the context stack just like any other value, by being
attached to a section. In this case, they are only notified of tags inside that
section.

    let template = Template(string: "{{# user }}{{ firstName }} {{# spy }}{{ lastName }}{{/ spy }}{{/ user }}")!

    // Prints:
    // {{ lastName }} at line 1 will render Flynn
    let data = [
        "user": Box(["firstName": "Errol", "lastName": "Flynn"]),
        "spy": Box(willRender)
    ]
    template.render(Box(data))!
*/
public typealias WillRenderFunction = (tag: Tag, box: MustacheBox) -> MustacheBox


For example:

    // `sum(x, ...)` evaluates to the sum of provided integers
    let sum = VariadicFilter { (boxes: [MustacheBox]) in
        // Extract integers out of input boxes, assuming zero for non numeric values
        let integers = boxes.map { (box) in (box.value as? Int) ?? 0 }
        let sum = integers.reduce(0, combine: +)
        return Box(sum)
    }

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

    // Renders "6"
    try! template.render(Box(["a": 1, "b": 2, "c": 3]))

If your filter is given too many or too few arguments, you should return nil and
set error to an NSError of domain `GRMustacheErrorDomain` and code
`GRMustacheErrorCodeRenderingError`.

- parameter filter: a function `([MustacheBox]) throws -> MustacheBox`
- returns: a FilterFunction
*/
public func VariadicFilter(filter: ([MustacheBox]) throws -> MustacheBox) -> FilterFunction {
