// APPLY public static object Apply(object op, params object [] operands) { if (operands == null) { return(ResolveFunctionSpecifier(op).DynamicInvoke()); } else if (operands.Length == 0) { return(ResolveFunctionSpecifier(op).DynamicInvoke()); } Cons arglist = (Cons)operands [operands.Length - 1]; for (int i = operands.Length - 2; i > -1; i--) { arglist = CL.Cons(operands [i], arglist); } int limit = CL.Length(arglist); object [] argarray = new object [limit]; for (int i = 0; i < limit; i++) { argarray [i] = arglist.Car; arglist = (Cons)arglist.Cdr; } return(ResolveFunctionSpecifier(op).DynamicInvoke((object)argarray)); }
static Cons MapVectorToList1(object functionSpecifier, object [] sequence) { Delegate function = ResolveFunctionSpecifier(functionSpecifier); Cons answer = null; foreach (object element in sequence) { answer = Cons(function.DynamicInvoke(element), answer); } return((Cons)CL.Reverse(answer)); }
public override ReaderStep NextStep() { if (this.package == null) { return(new FinalReaderStep(new Symbol(token))); } else { return(new FinalReaderStep(CL.Intern(token, package))); } }
static System.Collections.Generic.IList <T> MapVectorToList1 <I, T> (object functionSpecifier, I [] sequence) { Delegate function = ResolveFunctionSpecifier(functionSpecifier); ConsCollection <T> answer = null; foreach (I element in sequence) { answer = new ConsCollection <T> ((T)function.DynamicInvoke(element), answer); } return(CL.Reverse <T> (answer)); }
static System.Collections.Generic.IList <T> MapCollectionToList1 <T> (object functionSpecifier, ICollection sequence) { Delegate function = ResolveFunctionSpecifier(functionSpecifier); ConsCollection <T> reverseAnswer = null; foreach (object element in sequence) { T item = (T)function.DynamicInvoke(element); reverseAnswer = new ConsCollection <T> (item, reverseAnswer); } return(CL.Reverse <T> (reverseAnswer)); }
static public Cons RemArgs(object [] ra, object key) { Cons reversedAnswer = null; for (int i = 0; i < ra.Length; i += 2) { if (ra [i] != key) { reversedAnswer = new Cons(ra [i + 1], new Cons(ra [i], reversedAnswer)); } } return(CL.Reverse(reversedAnswer)); }
public override ReaderStep NextStep() { if (CL.ReadSuppress) { // Toss the symbol and read the next thing. return(new InitialReaderStep(this.context)); } // handle numbers here else { return(new TokenToSymbol(this.packagePrefix == null ? CL.Package : CL.FindPackage(packagePrefix), this.token)); } }
static public ConsCollection <O> Mapcar <O, I> (object functionSpecifier, System.Collections.Generic.ICollection <I> input) { if (input == null) { return(null); } Function1 <O, I> function = ResolveFunctionSpecifier <Function1 <O, I> > (functionSpecifier); ConsCollection <O> answer = null; foreach (I element in input) { answer = new ConsCollection <O> (function(element), answer); } return(CL.Reverse(answer)); }
static public ConsCollection <T> RemoveDuplicates <T> (System.Collections.Generic.IList <T> list) { if (list == null) { return(null); } ConsCollection <T> answer = null; foreach (T element in list) { if ((answer == null) || !((System.Collections.Generic.IList <T>)answer).Contains(element)) { answer = new ConsCollection <T> (element, answer); } } return(CL.Reverse(answer)); }
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)); } }
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 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))); }
static int Position(object item, object sequence, object [] arguments) { KeywordArgument <bool> fromEnd = new KeywordArgument <bool> (KW.FromEnd); KeywordArgument <object> test = new KeywordArgument <object> (KW.Test); KeywordArgument <int> start = new KeywordArgument <int> (KW.Start); KeywordArgument <int> end = new KeywordArgument <int> (KW.End); KeywordArgument <object> key = new KeywordArgument <object> (KW.Key); KeywordArgumentBase.ProcessKeywordArguments( new KeywordArgumentBase [] { fromEnd, test, start, end, key }, arguments, false); return(Position(item, sequence, fromEnd.Supplied ? fromEnd.Value : false, test.Supplied ? ResolveFunctionSpecifier <EqualityTest> (test.Value) : new EqualityTest(CL.Eql), start.Supplied ? start.Value : 0, end.Supplied ? end.Value : CL.Length(sequence), key.Supplied ? ResolveFunctionSpecifier <Function1> (key.Value) : new Function1(CL.Identity))); }
public Delegate SymbolFunction(Symbol id) { ILocation <Delegate> binding; if (functions.TryGetValue(id, out binding)) { return(binding.Value); } if (id.NamesDotnetMethod()) { Delegate gf = (Delegate)CL.EnsureGenericFunction(id, KW.GenericFunctionClass, CLOS.DotnetGenericFunction, KW.Environment, this, KW.StudlyName, id.Name); binding = new ValueCell <Delegate> (gf); return(binding.Value); } 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 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 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 System.Collections.Generic.IList <T> MapListToList1 <I, T> (object functionSpecifier, ConsCollection <I> sequence) { Delegate function = ResolveFunctionSpecifier(functionSpecifier); ConsCollection <T> answer = null; while (sequence != null) { answer = new ConsCollection <T> ((T)function.DynamicInvoke(sequence.Car), answer); object temp = sequence.Cdr; if (temp == null) { break; } ConsCollection <I> next = temp as ConsCollection <I>; if (next == null) { throw new NotImplementedException(); } sequence = next; } return(CL.Reverse <T> (answer)); }
static TItem Find <TItem, Tkey> (Tkey item, System.Collections.Generic.ICollection <TItem> sequence, object [] arguments) { KeywordArgument <bool> fromEnd = new KeywordArgument <bool> (KW.FromEnd); KeywordArgument <object> test = new KeywordArgument <object> (KW.Test); KeywordArgument <int> start = new KeywordArgument <int> (KW.Start); KeywordArgument <int> end = new KeywordArgument <int> (KW.End); KeywordArgument <object> key = new KeywordArgument <object> (KW.Key); KeywordArgumentBase.ProcessKeywordArguments( new KeywordArgumentBase [] { fromEnd, test, start, end, key }, arguments, false); if (!key.Supplied) { throw new NotImplementedException(); } return(Find <TItem, Tkey> (item, sequence, fromEnd.Supplied ? fromEnd.Value : false, test.Supplied ? ResolveFunctionSpecifier <EqualityTest <Tkey> > (test.Value) : new EqualityTest <Tkey> (CL.Eql <Tkey>), start.Supplied ? start.Value : 0, end.Supplied ? end.Value : CL.Length(sequence), ResolveFunctionSpecifier <Function1 <Tkey, TItem> > (key.Value))); }
static public ConsCollection <T> Reverse <T> (System.Collections.Generic.IList <T> list) { return(CL.Reconc <T> (list, null)); }
static public object Reverse(object list) { return(CL.Reconc(list, null)); }
// Append public static object Append(object left, object right) { return(CL.Reconc(CL.Reverse(left), right)); }
public static object Cddr(object thing) { return((thing == null) ? null : CL.Cdr(CL.Cdr(thing))); }
public static ConsCollection <T> Append <T> (System.Collections.Generic.IList <T> left, ConsCollection <T> right) { return(CL.Reconc <T> (CL.Reverse <T> (left), right)); }
// CDDR public static object Cddr(Cons thing) { return((thing == null) ? null : CL.Cdr(thing.Cdr)); }
static public Cons Reverse(Cons list) { return((Cons)CL.Reconc(list, null)); }