Not-endless Recursion without a base case Write a recursive function/program, to calculate either the Factorial or the Fibonacci number of a given non-negative integer, without explicitly implementing the base case(s).

Your program/function must return/output the correct value in a reasonable time.

You cannot


Use if statement anywhere in your program/function, nor switch
nor short-if-syntax (?:). Not even loops. Basically all
control-flow statements are forbidden.
Use try, catch or exceptions of any kind.
Terminate the program (anything like exit(1)).
Use external sources (file, web, etc.)
Avoid recursion and return the proper value otherwise. (Your function must be recursive).
Use any of the standard loopholes.


You can


Use polymorphism, create threads, wrap the Integer type with your own class, or use any other mechanism your language or runtime has. (I can think of a solution that uses the lazy-evaluation, for instance). The function/program can be written as more than one function, using Mutual Recursion, if it helps you.


Please provide a short explanation of what you did.

Be creative! The winning answer is the one with the most upvotes by 2014-06-23 (a week from today).

EDIT:

Some clarifications:

Using Pattern Matching in Functional Programming Languages is OK since it's considered as Polymorphism. The solution should be trivial though, so I guess it won't have the chance to win, since it is a popularity-contest. It is still a legitimate answer.

Although some may say it's flow control in disguise, using lazy evaluation, (or short circuit evaluation) is allowed as well.
C - factorial
simple as that
int not_factorial(int n){return 1;}
int factorial(int n)
{
    int (*maybe_factorial[])(int) = {factorial, not_factorial};
    return n*maybe_factorial[!(n-1)](n-1);
}

the function factorial is almost like a basic recursive approach but not_factorial only returns 1.If I create an array of function pointers
(0: fac, 1: not_fac), then I can control which one should be executed at the next call:
maybe_factorial[0](n-1) calls factorial
maybe_factorial[1](n-1) calls not_factorial.
!(n-1) means if n &gt; 1 return 0 else return 1