Okay, I guess we have to turn to plan B.

What's plan B?

Why wasn't that plan A?

- The Big Bang Theory : "The Lizard-Spock Expansion"

doveryai no proveryai (trust, but verify)

- Russian proverb adopted as signature phrase by Ronald Reagan

Two functions
*
f
*
and
*
g
*
are provided as inputs to
*
checkio
*
. The first function
*
f
*
is
the primary function and the second function
*
g
*
is the backup. Use your coding skills to return a third function
*
h
*
which returns the same output as
*
f
*
unless
*
f
*
raises an exception or returns
*
None
*
.
In this case
*
h
*
should return the same output as
*
g
*
. If both
*
f
*
and
*
g
*
raise exceptions
or return
*
None
*
, then
*
h
*
should return
*
None
*
.

As a second output,
*
h
*
should return a status string indicating whether the function values are the same and
if either function erred. A function errs if it raises an exception or returns a null value (
*
None
*
).

The status string should be set to: "same" if
*
f
*
and
*
g
*
return the same output and neither errs,
"different" if
*
f
*
and
*
g
*
return different outputs and neither errs, "f_error" if
*
f
*
errs
but not
*
g
*
, "g_error" if
*
g
*
errs but not
*
f
*
, or "both_error" if both err.

**
Input:
**
Two functions: f (primary) and g (backup).

**
Output:
**
A function h which takes arbitrary inputs and returns a two-tuple.

**
Example:
**

f = lambda x,y: x+y g = lambda x,y: (x**2 - y**2)/(x-y) checkio(f,g)(1,3) == (4,"same") checkio(f,g)(1,1.01) == (2.01,"different") # numerical precision difference checkio(f,g)(1,1) == (2,"g_error") # g divides by zero

**
How it is used:
**
This is an exercise in working with functions as first class objects.

**
Precondition:
**
hasattr(f,'__call__');

hasattr(g,'__call__')