static public int PositionIf(object predicate, object sequence) { if (sequence == null) { return(-1); } Cons list = sequence as Cons; if (list != null) { return(PositionIf(predicate, list)); } throw new NotImplementedException("PositionIf on non-list"); }
static public int PositionIf <T> (Predicate <T> predicate, Cons sequence) { int pos = 0; foreach (T element in sequence) { if (predicate(element)) { return(pos); } pos += 1; } return(-1); }
static public Cons Memq(object item, object list) { if (list == null) { return(null); } Cons pair = list as Cons; if (pair == null) { throw new NotImplementedException(); } return((item == pair.Car) ? pair : Memq(item, pair.Cdr)); }
static int Position(object item, object sequence, bool fromEnd, EqualityTest test, int start, int end, Function1 key) { if (sequence == null) { return(-1); } Cons list = sequence as Cons; if (list != null) { return(Position(item, list, fromEnd, test, start, end, key)); } else { throw new NotImplementedException(); } }
static public object GetArgStar(object list, ConsCollection <Symbol> keys, object defaultValue) { if (list == null) { return(defaultValue); } Cons firstPair = (Cons)list; Cons secondPair = (Cons)(firstPair.Cdr); if (CL.Memq <Symbol> ((Symbol)firstPair.Car, keys) != null) { return(secondPair.Car); } else { return(GetArgStar(secondPair.Cdr, keys, defaultValue)); } }
static public ConsCollection <T> GetArgs <T> (Cons list, object key) { if (list == null) { return(null); } Cons firstPair = (Cons)list; Cons secondPair = (Cons)(firstPair.Cdr); if (firstPair.Car == key) { return(new ConsCollection <T> ((T)secondPair.Car, GetArgs <T> ((Cons)secondPair.Cdr, key))); } else { return(GetArgs <T> ((Cons)secondPair.Cdr, key)); } }
// RECONC static public object Reconc(object tail, object head) { if (tail == null) { return(head); } Cons ctail = tail as Cons; if (ctail != null) { // yeah I'll fix it... return(Reconc(ctail.Cdr, new Cons(ctail.Car, head))); } else { throw new NotImplementedException(); } }
static public object GetArg(object list, object key, object defaultValue) { if (list == null) { return(defaultValue); } Cons firstPair = (Cons)list; Cons secondPair = (Cons)(firstPair.Cdr); if (firstPair.Car == key) { return(secondPair.Car); } else { return(GetArg(secondPair.Cdr, key, defaultValue)); } }
public override ReaderMacroStep NextStep() { Cons head = null; object tail = null; Readtable currentReadtable = CL.Readtable; while (true) { int xx; char x; // Discard whitespace do { xx = this.context.InputStream.Peek(); if (xx == -1) { throw new NotImplementedException(); } else { x = (char)xx; } }while (currentReadtable.IsWhitespaceSyntax(x) && (this.context.InputStream.Read() != -1)); if (x == ')') { this.context.InputStream.Read(); // discard the close paren return((CL.ReadSuppress == true) ? new FinalReaderMacroStep() : new FinalReaderMacroStep(CL.Reconc(head, tail))); } //else if (x == '.') { // throw new NotImplementedException (); //} else { object next = CL.Read(this.context.InputStream, true, null, true); // recursive read if (CL.ReadSuppress != true) { head = CL.Cons(next, head); } } } }
static public Cons RemoveIf(Delegate predicate, Cons sequence) { if (predicate == null) { throw new ArgumentNullException("predicate"); } if (sequence == null) { return(null); } else if ((bool)predicate.DynamicInvoke(sequence.Car)) { return(RemoveIf(predicate, (Cons)sequence.Cdr)); } else { return(new Cons(sequence.Car, RemoveIf(predicate, (Cons)sequence.Cdr))); } }
static public int Position(object item, object sequence) { if (sequence == null) { return(-1); } Cons list = sequence as Cons; if (list != null) { return(Position(item, list)); } return(Position(item, sequence, KW.FromEnd, false, KW.Key, new Function1(CL.Identity), KW.Test, new EqualityTest(CL.Eql), KW.Start, 0, KW.End, CL.Length(sequence))); }
public bool MoveNext() { if (current == null) { if (exhausted) { throw new NotImplementedException(); } current = head; return(true); } else { current = (Cons)current.Cdr; if (current == null) { exhausted = true; } return(!exhausted); } }
public static Cons SubvectorToList(object [] vector, int start, int limit) { if (vector == null) { if (start == limit) { return(null); } throw new ArgumentNullException("vector"); } Cons answer = null; int count = 1; for (int i = start; i < limit; i++) { answer = new Cons(vector [limit - count], answer); count += 1; } return(answer); }
static public object RemoveIf(object predicate, object sequence) { if (predicate == null) { throw new ArgumentNullException("predicate"); } if (sequence == null) { return(null); } Cons seq = sequence as Cons; if (seq != null) { return(RemoveIf(ResolveFunctionSpecifier(predicate), seq)); } else { throw new NotImplementedException("RemoveIf"); } }
static public object Eval(object form) { Cons pair = form as Cons; if (pair != null) { object op = pair.Car; object operands = pair.Cdr; object sym = op as Symbol; if (sym != null) { return(CL.Apply(CL.SymbolFunction(sym), Evlis(operands))); } else { throw new NotImplementedException("Operator not a symbol"); } } else { Symbol identifier = form as Symbol; if (identifier != null) { return(CL.SymbolValue(form)); } else { string literal = form as String; if (literal != null) { return(literal); } else { throw new NotImplementedException("No lambda functions yet"); } } } }
static Cons Evlis(object formlist) { Cons evaluated = null; while (true) { Cons formpair = formlist as Cons; if (formpair != null) { evaluated = new Cons(Eval(formpair.Car), evaluated); formlist = formpair.Cdr; } else if (formpair == null) { return((Cons)CL.Reverse(evaluated)); } else { throw new NotImplementedException(); } } }
static Cons MapListToList1(object functionSpecifier, Cons sequence) { Delegate function = ResolveFunctionSpecifier(functionSpecifier); Cons answer = null; while (sequence != null) { answer = new Cons(function.DynamicInvoke(sequence.Car), answer); object temp = sequence.Cdr; if (temp == null) { break; } Cons next = temp as Cons; if (next == null) { throw new NotImplementedException(); } sequence = next; } return((Cons)CL.Reverse(answer)); }
static Cons MapToList1(object functionSpecifier, object sequence) { if (sequence == null) { return(null); } object [] sa = sequence as object []; if (sa != null) { return(MapVectorToList1(functionSpecifier, sa)); } else { Cons sc = sequence as Cons; if (sc != null) { return(MapListToList1(functionSpecifier, sc)); } else { throw new NotImplementedException(); } } }
public ConsEnumerator(Cons head) { this.head = head; this.current = null; this.exhausted = false; }
static public Cons Reverse(Cons list) { return((Cons)CL.Reconc(list, null)); }
// CDAR public static object Cdar(Cons thing) { return((thing == null) ? null : CL.Cdr(thing.Car)); }
// CDR public static object Cdr(Cons thing) { return((thing == null) ? null : thing.Cdr); }
public void Reset() { current = null; exhausted = false; }