/// <summary>
/// Transforms a set of one sort to a set of another sort by invoking a given delegate on each element.
/// If the mapping is injective, then the number of elements in the result will be the same as the number
/// of elements in this. Otherwise, (if not injective) the number of elements will be fewer.
/// </summary>
/// <typeparam name="S">The sort of the result</typeparam>
/// <param name="converter">A pure (side-effect free) function that maps an element of T to an element of S</param>
/// <returns>The set</returns>
public OrderedSet <S> Convert <S>(Converter <T, S> converter)
{
OrderedSet <S> result = new OrderedSet <S>();
foreach (T val in this)
{
result.InPlaceAdd(converter(val));
}
return(result);
}
public static OrderedSet <T> operator +(OrderedSet <T> s, OrderedSet <T> t)
{
OrderedSet <T> r;
if (s.Count > t.Count)
{
r = new OrderedSet <T>(s.count, s.elems);
foreach (T o in t)
{
r.InPlaceAdd(o);
}
}
else
{
r = new OrderedSet <T>(t.count, t.elems);
foreach (T o in s)
{
r.InPlaceAdd(o);
}
}
return(r);
}