Generic algorithms

Implement a single function that takes two arguments and returns the bigger of the two. Assume you don't know the type of the  arguments and you don't know if the types can be compared. Assume that if a type can be compared, it will always be implemented by following a single standard. Use the latest standard of your language. Write the simplest program
that will pass an integer 1(one) and a float 1.1(one point one) into the function and write the result to standard output.

Post the compiler you used, the code and the result.
Write what will happen if the max function is called with broken syntax (I'm looking at you C macros).
Write what will happen if the objects of a type can't be compared.

I'll start with C and C++.
Compiler: gcc 4.3.2 20081105 (Red Hat 4.3.2-7)
#include <iostream>
template<class F>
F& max(F& a, F& b) { return (a < b) ? b : a; }
int main() { std::cout << max(1, 1.1) << '\n'; }
Results: Compile time error:
max.cpp: In function ‘int main()’:
max.cpp:6: error: no matching function for call to ‘max(int, double)’
Bad syntax: Standard compile-time error
No comparison: Standard compile-time error about undefined operator<

#define max(a, b) (less(a, b) ? b : a)
#include <stdio.h>
int less(int a, int b) { return a < b; }
int main() { printf("%f\n", max(1, 1.1)); }
Result: Bad output
1.000000
Bad syntax: Depends on the error in the syntax. Can either compile and cause undefined behaviour or fail at compile time with strange syntax errors.
No comparison: Standard compile-time error about an undefined function.

>>105
Reflection/RTTI would be the easy way out, but I gathered from the OP's statement that RTTI wouldn't be available.

If you have no type information available, and no way to get it, the byte-level content and size of the data is really all you got to go on.

Ok, so I guess the proper thing to do is to compare each corresponding byte of a and b, even if one is longer than the other, until the smaller entity's size is reached.  At that point, all other things being equal, the larger entity is the maximum.  Correct?

Another solution would be to apply heuristic functions to try to discover the type, like the unix file command except for data types.  Such a function would need to be able to return multiple possible types together with a probability that the data is indeed that type.  Detecting every possible type would be shit slow but that's probably the best way, assuming no reflection/RTTI.