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)); }