public static void Apply(LispList <T> list, Action <T> action)
{
for (; list != null; list = list.tail)
{
action(list.Head);
}
}
public static LispList <S> Select <S> (LispList <T> list, Func <T, S> selector)
{
if (list == null)
{
return(null);
}
return(list.tail.Select(selector).Cons(selector(list.Head)));
}
public static int LengthOf(LispList <T> list)
{
if (list == null)
{
return(0);
}
return(list.count);
}
public IImmutableMap <K, V> Add(K key, V value)
{
int hashCode = key.GetHashCode();
LispList <Pair <K, V> > list1 = this.immutable_int_map [hashCode];
LispList <Pair <K, V> > newList = Remove(list1, key).Cons(new Pair <K, V> (key, value));
int diff = newList.Length() - list1.Length();
LispList <K> newKeys = diff == 0 ? this.keys : this.keys.Cons(key);
return(new ImmutableMap <K, V> (this.immutable_int_map.Add(hashCode, newList), this.count + diff, newKeys));
}
public static LispList <T> Reverse(LispList <T> list)
{
LispList <T> rest = null;
for (; list != null; list = list.tail)
{
rest = rest.Cons(list.element);
}
return(rest);
}
public static IEnumerable <T> PrivateGetEnumerable(LispList <T> list)
{
LispList <T> current = list;
while (current != null)
{
T next = current.Head;
current = current.tail;
yield return(next);
}
}
public static LispList <T> Append <T> (this LispList <T> list, LispList <T> append)
{
if (list == null)
{
return(append);
}
if (append == null)
{
return(list);
}
return(Cons(list.Tail.Append(append), list.Head));
}
private static LispList <K> RemoveKey(K key, LispList <K> keys)
{
if (keys == null)
{
throw new InvalidOperationException();
}
if (key.Equals(keys.Head))
{
return(keys.Tail);
}
return(RemoveKey(key, keys.Tail).Cons(keys.Head));
}
private LispList <Pair <K, V> > Remove(LispList <Pair <K, V> > from, K key)
{
if (from == null)
{
return(null);
}
if (key.Equals(from.Head.Key))
{
return(from.Tail);
}
LispList <Pair <K, V> > tail = Remove(from.Tail, key);
return(tail == from.Tail ? from : tail.Cons(from.Head));
}
public static T Last <T> (this LispList <T> list)
{
if (list == null)
{
return(default(T));
}
while (LispList <T> .LengthOf(list) > 1)
{
list = list.Tail;
}
return(list.Head);
}
public static bool Any <T> (this LispList <T> list, Predicate <T> predicate)
{
if (list == null)
{
return(false);
}
if (predicate(list.Head))
{
return(true);
}
return(list.Tail.Any(predicate));
}
public V this [K key]
{
get
{
for (LispList <Pair <K, V> > list = this.immutable_int_map [key.GetHashCode()]; list != null; list = list.Tail)
{
K k = list.Head.Key;
if (key.Equals(k))
{
return(list.Head.Value);
}
}
return(default(V));
}
}
public static LispList <T> Where <T> (this LispList <T> list, Predicate <T> keep)
{
if (list == null)
{
return(null);
}
LispList <T> rest = list.Tail.Where(keep);
if (!keep(list.Head))
{
return(rest);
}
if (rest == list.Tail)
{
return(list);
}
return(Cons(rest, list.Head));
}
public static bool Contains(LispList <T> l, T o)
{
if (l == null)
{
return(false);
}
var equatable = o as IEquatable <T>;
if (equatable != null)
{
if (equatable.Equals(l.element))
{
return(true);
}
}
else if (o.Equals(l.element))
{
return(true);
}
return(Contains(l.tail, o));
}
public IImmutableMap <K, V> Remove(K key)
{
int hashCode = key.GetHashCode();
LispList <Pair <K, V> > from = this.immutable_int_map [hashCode];
if (from == null)
{
return(this);
}
LispList <Pair <K, V> > newList = Remove(from, key);
if (newList == from)
{
return(this);
}
LispList <K> newKeys = RemoveKey(key, this.keys);
if (newList == null)
{
return(new ImmutableMap <K, V> (this.immutable_int_map.Remove(hashCode), this.count - 1, newKeys));
}
return(new ImmutableMap <K, V> (this.immutable_int_map.Add(hashCode, newList), this.count - 1, newKeys));
}
public static LispList <T> Cons <T> (this LispList <T> rest, T elem)
{
return(LispList <T> .Cons(elem, rest));
}
public static LispList <T> Coerce <S, T> (this LispList <S> list)
where S : T
{
return(list.Select(l => (T)l));
}
private LispList(T elem, LispList <T> tail)
{
this.element = elem;
this.tail = tail;
this.count = LengthOf(tail) + 1;
}
public static LispList <S> Select <T, S> (this LispList <T> list, Func <T, S> selector)
{
return(LispList <T> .Select(list, selector));
}
private ImmutableMap(IImmutableIntMap <LispList <Pair <K, V> > > map, int count, LispList <K> keys)
{
this.keys = keys;
this.count = count;
this.immutable_int_map = map;
}
public static void Apply <T> (this LispList <T> list, Action <T> action)
{
LispList <T> .Apply(list, action);
}
public static IEnumerable <T> AsEnumerable <T> (this LispList <T> list)
{
return(LispList <T> .PrivateGetEnumerable(list));
}
public static bool IsEmpty <T> (this LispList <T> list)
{
return(list == null);
}
public static int Length <T> (this LispList <T> list)
{
return(LispList <T> .LengthOf(list));
}
public static LispList <T> Cons(T elem, LispList <T> tail)
{
return(new LispList <T> (elem, tail));
}
