Merge pull request #21 from alexcrichton/update

Update to rust master
Fix building with current rustc
Merge pull request #22 from dotdash/rustup

Fix building with current rustc
remove visible_private_types
Make Argv public

This is required to get docopt compiling on the latest Rust master
Merge pull request #24 from carllerche/master

Make Argv public (track Rust master)
Fix warnings from Rust master.
0.6.4
Fix build break due to removal of struct inheritance
Merge pull request #26 from bkoropoff/build-break

Fix build break due to removal of struct inheritance
Remove reference to libdebug
Merge pull request #29 from renato-zannon/remove-libdebug

Remove reference to libdebug
Allow generic decoding of usage into a type

When writing a generic decode function over any types, one is tempted to write
something along the lines of:

    extern crate serialize;
    extern crate docopt;
    use serialize::Decodable;

    fn foo<'a, T>(usage: &str) -> T
                  where T: Decodable<docopt::Decoder<'a>, docopt::Error> {
        let map = docopt::docopt(usage).unwrap_or_else(|e| e.exit());
        map.decode().unwrap_or_else(|e| e.exit())
    }

Currently there are two problems with this approach.

1. The `docopt::Decoder` structure is private, so it cannot be referenced in a
   function signature.
2. The lifetime parameter on `Decoder` prevents usage of the local variable
   `map`. The `decode` function requires `&'a self`, which requires callers of
   this function to provide a lifetime variable `'a` which is the lifetime of
   the stack frame of `foo` itself. Sadly this cannot currently be done (higher
   ranked trait lifetimes maybe?).

To work around these two problems, I've made the `Decoder` structure public and
changed the `decode` method on `ValueMap` to consume the map, removing the
lifetime parameter on `Decoder`.

There may be some more generic wizardry to get around this problem, but this at
least seems to work for now!
Merge pull request #31 from alexcrichton/decode-consume

Allow generic decoding of usage into a type
docopt! macro can now make struct public and deriving other things.

The new syntax for the macro now looks something like this:

    docopt!([pub] ident [deriving [ident]...],
            USAGE STRING LITERAL
            [, [ident: type]...])

The syntax itself does not introduce any breaking changes, but
all created structs used to automatically derive `Show` and `Decodable`.
Now they only derive `Decodable` (which is necessary for automatic
decoding).

If your code previously relied on an `Args` struct satisfying `Show`,
then change this:

    docopt!(Args, ...)

to this:

    docopt!(Args deriving Show, ...)

Fixes #25.

[breaking-change]
version bump to 0.6.5
Update README with `deriving Show` in the examples.
Removed the `allow(dead_code, unused_imports, ...)` and fixed the fallout.
fail -> panic
Merge pull request #33 from steveklabnik/master

fail -> panic