updatedocs (#125)

* fix broken example

* only show static parameter examples with where syntax

* avoid verbose code example

* simplify rebuild function definition example

Author: aviatesk

docs/src/pattern-matching.md

@@ -48,7 +48,7 @@ Because `@capture` doubles as a test as well as extracting values, you can
 easily handle unexpected input (try writing this by hand):
 
 ```julia
-@capture(ex, f_{T_}(xs__) = body_) ||
+@capture(ex, f_(xs__) where {T_} = body_) ||
   error("expected a function with a single type parameter")
 ```
 
@@ -97,18 +97,18 @@ which will match e.g. `struct Foo ...` but not `struct Foo{V} ...`
 for example:
 
 ```julia
-@capture(ex, f_(args__) = body_ | function f_(args__) body_ end)
+@capture(ex, (f_(args__) = body_) | (function f_(args__) body_ end))
 ```
 
 will match both kinds of function syntax (though it's easier to use
 `shortdef` to normalise definitions). You can also do this within
 expressions, e.g.
 
 ```julia
-@capture(ex, (f_{T_}|f_)(args__) = body_)
+@capture(ex, (f_(args__) where {T_}) | (f_(args__)) = body_)
 ```
 
-matches a function definition, with a single type parameter bound to `T` if possible.
+matches a function definition like `func(a::T) where {T<:Number} = supertype(T)`, with a single type parameter bound to `T` if possible.
 If not, `T = nothing`.
 
 ## Expression Walking

docs/src/utilities.md

@@ -35,7 +35,7 @@ the full range of function syntax.
 `splitdef(def)` matches a function definition of the form
 
 ```julia
-function name{params}(args; kwargs)::rtype where {whereparams}
+function name(args; kwargs)::rtype where {whereparams}
    body
 end
 ```
@@ -45,11 +45,10 @@ calling `MacroTools.combinedef(dict)`, or explicitly with
 
 ```julia
 rtype = get(dict, :rtype, :Any)
-all_params = [get(dict, :params, [])..., get(dict, :whereparams, [])...]
-:(function $(dict[:name]){$(all_params...)}($(dict[:args]...);
-                                            $(dict[:kwargs]...))::$rtype
-      $(dict[:body])
-  end)
+:(function $(dict[:name])($(dict[:args]...);
+                          $(dict[:kwargs]...))::$rtype where {$(dict[:whereparams]...)}
+  $(dict[:body].args...)
+end)
 ```
 
 `splitarg(arg)` matches function arguments (whether from a definition or a function call)