public static void DumpDictionary(object stream, PrototypeDictionary dict)
{
if (dict != null)
{
foreach (var key in ToIter(SeqBase.Sort(dict.Keys, CompareApply, IdentityApply)))
{
object val = dict[key];
string line = string.Format("{0} => ", key);
Write(line, Symbols.Escape, false, Symbols.Stream, stream);
PrettyPrintLine(stream, line.Length, null, val);
}
}
}
public static bool EvalFeatureExpr(object expr)
{
if (expr == null)
{
return(false);
}
else if (expr is bool)
{
return((bool)expr);
}
else if (expr is Symbol)
{
return(HasFeature(((Symbol)expr).Name));
}
else if (expr is Cons)
{
var list = (Cons)expr;
var oper = First(list) as Symbol;
if (oper != null)
{
if (oper.Name == "and")
{
return(SeqBase.Every(EvalFeatureExpr, list.Cdr));
}
else if (oper.Name == "or")
{
return(SeqBase.Any(EvalFeatureExpr, list.Cdr));
}
else if (oper.Name == "not")
{
return(!EvalFeatureExpr(Second((Cons)expr)));
}
}
}
throw new LispException("Invalid feature expression");
}
public static Cons Cycle(IEnumerable seq)
{
return(AsLazyList(SeqBase.Cycle(seq)));
}
public static Cons TakeWhile(IApply predicate, IEnumerable seq)
{
return(AsLazyList(SeqBase.TakeWhile(predicate, seq)));
}
public static Cons Take(int count, IEnumerable seq)
{
return(AsLazyList(SeqBase.Take(count, seq)));
}
public static Cons Shuffle(IEnumerable seq)
{
return(AsLazyList(SeqBase.Shuffle(seq)));
}
public static Cons Repeatedly(int count, IApply func)
{
return(AsLazyList(SeqBase.Repeatedly(count, func)));
}
public static Cons Repeat(object value)
{
return(AsLazyList(SeqBase.Repeat(-1, value)));
}
public static Cons Interpose(object separator, IEnumerable seq)
{
return(AsLazyList(SeqBase.Interpose(separator, seq)));
}
public static Cons Interleave(params IEnumerable[] seqs)
{
return(AsLazyList(SeqBase.Interleave(seqs)));
}
public static Cons GroupBy(IApply key, IEnumerable seq)
{
return(AsLazyList(SeqBase.GroupBy(key, seq)));
}
public static Cons Flatten(IEnumerable seq, int depth)
{
return(AsLazyList(SeqBase.Flatten(seq, depth)));
}
public static Cons Flatten(IEnumerable seq)
{
return(AsLazyList(SeqBase.Flatten(seq, int.MaxValue)));
}
public static Cons DropWhile(IApply predicate, IEnumerable seq)
{
return(MakeCons(SeqBase.DropWhile(predicate, seq).GetEnumerator()));
}
public static Cons Drop(int count, IEnumerable seq)
{
return(MakeCons(SeqBase.Drop(count, seq)));
}
public static Cons Range(int start, int end, int step)
{
return(AsLazyList(SeqBase.Range(start, end, step)));
}
public static Cons Repeat(int count, object value)
{
return(AsLazyList(SeqBase.Repeat(count, value)));
}
public static Cons Iterate(IApply func, object value)
{
return(AsLazyList(SeqBase.Iterate(-1, func, value)));
}
public static Cons Repeatedly(IApply func)
{
return(AsLazyList(SeqBase.Repeatedly(-1, func)));
}
public static Cons Map(KeyFunc func, params IEnumerable[] seqs)
{
return(AsLazyList(SeqBase.Map(func, seqs)));
}
public static Cons Reverse(IEnumerable seq)
{
return(AsLazyList(SeqBase.Reverse(seq)));
}
public static Cons ParallelMap(IApply action, IEnumerable seq)
{
return(AsLazyList(SeqBase.ParallelMap(action, seq)));
}
public static Cons Subseq(IEnumerable seq, int start, params object[] args)
{
return(AsLazyList(SeqBase.Subseq(seq, start, args)));
}
public static Cons Append(params IEnumerable[] seqs)
{
return(AsLazyList(SeqBase.Append(seqs)));
}
public static Cons TakeNth(int step, IEnumerable seq)
{
return(AsLazyList(SeqBase.TakeNth(step, seq)));
}
public static Cons Partition(int size, int step, IEnumerable seq)
{
return(AsLazyList(SeqBase.Partition(false, size, step, null, seq)));
}
public static Cons Zip(params IEnumerable[] seqs)
{
return(AsLazyList(SeqBase.Zip(seqs)));
}
public static Cons PartitionAll(int size, IEnumerable seq)
{
return(AsLazyList(SeqBase.Partition(true, size, size, null, seq)));
}
public static Cons PartitionBy(IApply func, IEnumerable seq)
{
return(AsLazyList(SeqBase.PartitionBy(func, 0, seq)));
}
public static IEnumerable SeriesEnumerator(int start, int end, int step)
{
return(SeqBase.Range(start, end + step, step));
}
