memoize _num_required_args
handle non-hashable args in memoize with try-except
add benchmarks for first/second
Add try seq[0] to first

This makes getting elements from tuples and lists much faster
but significantly slows down getting elements from iterators

I believe that first(indexable) occurs more frequently in common
operations.
memoize _num_required_args
handle non-hashable args in memoize with try-except
add bench/test_curry
speed up curry.__call__ with kwargs check

benchmarking with bench/test_curry.py
Before: Ran 1 test in 0.246s
After:  Ran 1 test in 0.183s
Try calling function before validating in curry

Follows Ask foregiveness, not permission principle

benchmarking with bench/test_curry.py
Before: Ran 1 test in 0.183s
After:  Ran 1 test in 0.122s
add baseline comparison for curry with partial
clean up curry.__call__ error handling
curry invokes partial if it can

If we know that we only need one more argument then we
return a `partial` object rather than a `curry`.

This is done for performance reasons
Curry returns partial even with unsatisfied kwargs

For example the following no longer works

>>> from toolz.curried import get
>>> get(1)(default=None)(data)

But curried get *is* about 20% faster

Before: Ran 1 test in 0.085s
After:  Ran 1 test in 0.067s
Merge branch 'memoize-curry-inspect' of github.com:mrocklin/toolz into memoize-curry-inspect
Merge branch 'performance' into memoize-curry-inspect
remove old code
move iters within tests - was burning up before
try-except common case in get

Get is presumably most often used with a single input where the desired
operation of get(ind, val) is just val[ind].  We do this up front with a
try-except block.

This hurts performance on the list syntax

    get(indicies, val) -> [val[i] for i in indices]
                          if isinstance(indices, list)

But performance there wasn't so great to begin with and it doesn't
degrade as significantly as the single index case improves

Single index
Before: Ran 1 test in 0.058s
After:  Ran 1 test in 0.025s

Multi-index
Before: Ran 1 test in 0.307s
After:  Ran 1 test in 0.408s
curry mimics partial's interface
first and second iterate rather than index

This degrades performance but maintains correctness.  See tests

Benchmarked with bench/test_first.py
Before: Ran 2 tests in 0.285s
After:  Ran 2 tests in 0.705s