(index ("generics" 0) ("define-generic" 88) ("define-generic" 88) ("define-method" 551) ("define-method" 551) ("generic?" 953) ("generic-method-tree" 1029) ("generic-variadic?" 1155) ("generic-arity" 1272) ("selector?" 1423) ("selector" 1505) ("define-selector" 1663) ("selector-parents" 1874) ("any??" 1991) ("number??" 2094) ("integer??" 2171) ("fixnum??" 2251) ("flonum??" 2328) ("list??" 2405) ("pseudo-list??" 2476) ("pair??" 2568) ("vector??" 2639) ("string??" 2716) ("procedure??" 2793) ("index??" 2879) ("method-tree-item" 2967) ("method-tree-item?" 3148) ("method-tree?" 3254) ("method-tree-depth" 3355) ("method-tree-show" 3470) ("method-tree-dispatch" 3585) ("method-tree-insert" 3784) ("generic-helpers" 3952) ("reverse*" 4054) ("reverse*" 4054) ("reverse*" 4054) ("rsplit-with" 4307) ("rsplit-at" 4487) ("repeat" 4630) ("proc-name" 4728) ("map*" 4817) ("project" 4932) ("1+" 5057) ("1-" 5122) ("index?" 5194) ("mfx+" 5283) ("mfx+" 5363) ("named-lambda" 5448))
(def (sig (procedure "(generics sym ..)" (id generics))) (p "documentation procedure"))
(def (sig (syntax "(define-generic (Name (x x??) ....) body ....)" (id define-generic)) (syntax "(define-generic (Name (x x??) ... xs xs??) body ....)" (id define-generic))) (p "defines a new generic function Name with one anonymous method from arguments x .... or x ... . xs, selectors x?? .... or x?? ... xs?? and body .... The state of this generic consists of a cell containing a one-item method tree. This state can be accessed by calling Name as a thunk"))
(def (sig (syntax "(define-method (Name (x x??) ....) body ....)" (id define-method)) (syntax "(define-method (Name (x x??) ... xs xs??) body ....)" (id define-method))) (p "inserts an anonymous method constructed from arguments x .... or x ... . xs, selectors x?? .... or x?? ... xs?? and body .... into the method tree of the generic function Name at the position determined by selector's parents"))
(def (sig (procedure "(generic? xpr)" (id generic?))) (p "type predicate"))
(def (sig (procedure "(generic-method-tree Gen)" (id generic-method-tree))) (p "returns the method-tree of the generic Gen"))
(def (sig (procedure "(generic-variadic? Gen)" (id generic-variadic?))) (p "is the generic function Gen variadic?"))
(def (sig (procedure "(generic-arity Gen)" (id generic-arity))) (p "returns the arity of the generic function Gen i.e. the depth of its method tree"))
(def (sig (procedure "(selector? xpr)" (id selector?))) (p "is xpr a selector?"))
(def (sig (procedure "(selector parent?? pred)" (id selector))) (p "makes a special predicate from predicate pred and selector parent??, which might be #f"))
(def (sig (syntax "(define-selector name?? parent?? pred)" (id define-selector))) (p "defines a special predicate, name??, frome its base pradicate, pred, and its parent selector, parent??, which might be #f"))
(def (sig (procedure "(selector-parents sel??)" (id selector-parents))) (p "returns the parents of selector sel??"))
(def (sig (procedure "(any?? xpr)" (id any??))) (p "selector without parent which always returns #t"))
(def (sig (procedure "(number?? xpr)" (id number??))) (p "number selector"))
(def (sig (procedure "(integer?? xpr)" (id integer??))) (p "integer selector"))
(def (sig (procedure "(fixnum?? xpr)" (id fixnum??))) (p "fixnum selector"))
(def (sig (procedure "(flonum?? xpr)" (id flonum??))) (p "flonum selector"))
(def (sig (procedure "(list?? xpr)" (id list??))) (p "list selector"))
(def (sig (procedure "(pseudo-list?? xpr)" (id pseudo-list??))) (p "pseudo-list selector"))
(def (sig (procedure "(pair?? xpr)" (id pair??))) (p "pair selector"))
(def (sig (procedure "(vector?? xpr)" (id vector??))) (p "vector selector"))
(def (sig (procedure "(string?? xpr)" (id string??))) (p "string selector"))
(def (sig (procedure "(procedure?? xpr)" (id procedure??))) (p "procedure selector"))
(def (sig (procedure "(index?? xpr)" (id index??))) (p "non-negative fixnum selector"))
(def (sig (procedure "(method-tree-item proc sel?? ....)" (id method-tree-item))) (p "returns a method tree item from its arguments a procedure and a non-empty list of selectors"))
(def (sig (procedure "(method-tree-item? xpr)" (id method-tree-item?))) (p "is xpr a method-tree-item?"))
(def (sig (procedure "(method-tree? xpr)" (id method-tree?))) (p "evaluates xpr to a method-tree?"))
(def (sig (procedure "(method-tree-depth tree)" (id method-tree-depth))) (p "returns the depth of a method tree"))
(def (sig (procedure "(method-tree-show tree)" (id method-tree-show))) (p "returns a readable image of the tree"))
(def (sig (procedure "(method-tree-dispatch tree . args)" (id method-tree-dispatch))) (p "searches the tree according to the types of arguments args and returns the matching method, if any, or #f"))
(def (sig (procedure "(method-tree-insert tree item)" (id method-tree-insert))) (p "inserts the item into the tree at the location governed by the selectors in item"))
(def (sig (procedure "(generic-helpers sym ..)" (id generic-helpers))) (p "documentation procedure"))
(def (sig (procedure "(reverse* rhead tail op)" (id reverse*)) (procedure "(reverse* rhead tail)" (id reverse*)) (procedure "(reverse* rhead)" (id reverse*))) (p "a generalisation of reverse rhead is reversed onto tail or '() by means of op or cons."))
(def (sig (procedure "(rsplit-with ok? lst)" (id rsplit-with))) (p "returns two values by splitting the list at the first position where ok? returns true and reversing the head"))
(def (sig (procedure "(rsplit-at k lst)" (id rsplit-at))) (p "returns two values by splitting the list at position k and reversing the head"))
(def (sig (procedure "(repeat k fn)" (id repeat))) (p "applies function fn k times in sequence"))
(def (sig (procedure "(proc-name proc)" (id proc-name))) (p "returns the name of proc"))
(def (sig (procedure "(map* fn xs)" (id map*))) (p "maps the items of the nested pseudo-list xs via function fn"))
(def (sig (procedure "(project k)" (id project))) (p "returns a procedure which chooses the kth item of its argument list"))
(def (sig (procedure "(1+ n)" (id 1+))) (p "add 1 to fixnum n"))
(def (sig (procedure "(1- n)" (id 1-))) (p "subtract 1 from fixnum n"))
(def (sig (procedure "(index? n)" (id index?))) (p "is fixnum n greater or equal to 0"))
(def (sig (procedure "(mfx+ . nums)" (id mfx+))) (p "add all fixnums in nums"))
(def (sig (procedure "(mfx+ . nums)" (id mfx+))) (p "multiply all fixnums in nums"))
(def (sig (syntax "(named-lambda (name . args) xpr . xprs)" (id named-lambda))) (p "a version of lambda which can be used recursively"))
