Well, in my scenario, I am implementing a method similar to Left Outer
Join. I want all the elements from the outer list, even if there is
not a matching inner list element. I can easily make one of the types
Nullable, but then the rest of the arguments become more difficult.
For instance, I can't pass in Comparer<int>.Default.Compare anymore
because one of the arguments is Nullable. So I have to write method
like this:

delegate(int lhs, int? rhs)
{
   return lhs < rhs ? -1 : rhs < lhs ? 1 : 0;
}

and instead of passing in two int[] I have to pass in an int?[] which
is just cumbersome.

That is why I was hoping for the overloading. There is no point in
making a generic method if it is so complicated to get the syntax
right that it ends up being longer than writing the method over again.
Here is my example method:

       /// <summary>
       /// Performs a left outer join on ranges sorted by the key
value.
       /// </summary>
       /// <remarks>The collections must be sorted by key.</remarks>
       public static IEnumerable<KeyValuePair<TFirst, TSecond>>
LeftOuterJoin<TFirst, TSecond>(IList<TFirst> lhs,
           IList<TSecond> rhs,
           Comparison<TFirst, TSecond> keyComparison)
       {
           Debug.ArgumentNull(lhs, "lhs");
           Debug.ArgumentNull(rhs, "rhs");
           Debug.ArgumentNull(keyComparison, "keyComparison");
           int lhsFirst = 0;
           int rhsFirst = 0;
           int position = rhsFirst;
           bool found = false;
           while (lhsFirst != lhs.Count)
           {
               int result = keyComparison(lhs[lhsFirst],
rhs[position]);
               if (result < 0)
               {
                   if (!found)
                   {
                       yield return new KeyValuePair<TFirst,
TSecond>(lhs[lhsFirst], default(TSecond));
                   }
                   else
                   {
                       found = false;
                   }
                   ++lhsFirst;
                   position = rhsFirst;
               }
               else if (result > 0)
               {
                   ++position;
                   rhsFirst = position;
               }
               else
               {
                   yield return new KeyValuePair<TFirst,
TSecond>(lhs[lhsFirst], rhs[position]);
                   ++position;
                   found = true;
               }
               if (position == rhsCount)
               {
                   position = rhsFirst;
                   if (!found)
                   {
                       yield return new KeyValuePair<TFirst,
TSecond>(lhs[lhsFirst], default(TSecond));
                   }
                   else
                   {
                       found = false;
                   }
                   ++lhsFirst;
               }
           }
       }

To call this with char, char? looks like this:

           char[] lhs = new char[] { 'A', 'B', 'E', 'F' };
           char?[] rhs = new char?[] { 'A', 'A', 'B', 'C', 'D',
'F' };
           IEnumerable<KeyValuePair<char, char?>> pairs
               = Algorithms.LeftOuterJoin<char, char?>(lhs, rhs,
               delegate(char l, char? r)
               {
                   return l < r ? -1 : r < l ? 1 : 0;
               });
           List<KeyValuePair<char, char?>> result = new
List<KeyValuePair<char, char?>>(pairs);

It's very uncomfortable.

What about having different method names . . . is that a good idea? I
don't think it is. People using my code don't really want to have to
distinguish between one or the other. Sigh . . . I guess I will stick
to the ugly formatting.