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.

Is the challenge to use some old faggy language with a weak set of libraries?

If you used a modern development framework like .Net you would just use the Math.Max function. That only works for numeric types though. If you want to compare non-numeric or dissimilar types you just implement the iComparable or iComparable<T> interfaces and maybe a TypeConverter.

public class Compare<T> where T : IComparable<T>
{
     public static T Max(T a, T b)
     {
         return (a.CompareTo(b)) ? b : a;
     }
}

Call it like:
Compare.Max<double>(1, 1.1);

Although int and double are not the same type, it will compile and run just fine. int implements a TypeConverter to convert from int to double for the comparison. So this function can be used for any type implementing the standard iComparable interface and if they are dissimilar types, one type needs a TypeConver implemented to convert to the other type.

Why anyone continues to use the abortion that is C++ for anything except legacy maintenance is beyond any sane developer.