Generic BigList Utilities `#13`

Parent #79Owner #36Flags read, fertileSource QuestCore.db

Aliases: Generic BigList Utilities, ghblu, biglist_utils

25 verbs · 7 properties · 0 children

Verbs

Verb Spec Flags Definer Lines

length this none this rxd #13 2

find_nth this none this rxd #13 2

find_ord this none this rxd #13 4

set_nth this none this rxd #13 8

kill this none this rxd #13 7

insert_after insert_before this none this rxd #13 22

extract_range this none this rxd #13 2

delete_range this none this rxd #13 6

keep_range this none this rxd #13 6

insert_last this none this rxd #13 33

start this none this rxd #13 24

next this none this rxd #13 19

_find_nth this none this rxd #13 18

_find_ord this none this rxd #13 25

_set_nth this none this rxd #13 17

_skill this none this rxd #13 18

_extract this none this rxd #13 32

_merge this none this rxd #13 16

_smerge this none this rxd #13 47

_split this none this rxd #13 67

_rmerge this none this rxd #13 43

_scrunch this none this rxd #13 13

_listfind_nth this none this rxd #13 10

_insertfirst this none this rxd #13 3

debug this none this rxd #13 1

Verb	Spec	Flags	Definer	Lines
`length`	`this none this`	`rxd`	#13	2
`find_nth`	`this none this`	`rxd`	#13	2
`find_ord`	`this none this`	`rxd`	#13	4
`set_nth`	`this none this`	`rxd`	#13	8
`kill`	`this none this`	`rxd`	#13	7
`insert_after insert_before`	`this none this`	`rxd`	#13	22
`extract_range`	`this none this`	`rxd`	#13	2
`delete_range`	`this none this`	`rxd`	#13	6
`keep_range`	`this none this`	`rxd`	#13	6
`insert_last`	`this none this`	`rxd`	#13	33
`start`	`this none this`	`rxd`	#13	24
`next`	`this none this`	`rxd`	#13	19
`_find_nth`	`this none this`	`rxd`	#13	18
`_find_ord`	`this none this`	`rxd`	#13	25
`_set_nth`	`this none this`	`rxd`	#13	17
`_skill`	`this none this`	`rxd`	#13	18
`_extract`	`this none this`	`rxd`	#13	32
`_merge`	`this none this`	`rxd`	#13	16
`_smerge`	`this none this`	`rxd`	#13	47
`_split`	`this none this`	`rxd`	#13	67
`_rmerge`	`this none this`	`rxd`	#13	43
`_scrunch`	`this none this`	`rxd`	#13	13
`_listfind_nth`	`this none this`	`rxd`	#13	10
`_insertfirst`	`this none this`	`rxd`	#13	3
`debug`	`this none this`	`rxd`	#13	1

Properties

Property Definer Flags Owner Value

Property	Definer	Flags	Owner	Value
`about`	#13	`rc`	#36	list of 15 {"Implementation notes", "--------------------", "Each biglist is actually a tree (a kind of B-tree, actually).", "The routines above pass around handles of the form", "", " {root_node, size, leftmost_ord}", "", "where root_node is the (string) name of a property that holds the root of the tree, size is the number of leaves in the tree, and leftmost_ord is the :_ord value of the leftmost element of the list (i.e., the leftmost leaf).", "Each node property has a value of the form ", "", " {height,list of subtrees}.", "", "where the each of the subtrees is itself a 3-element list as above unless", "the height is 0, in which case the subtrees are actually biglist elements of the arbitrary form determined by the home object.", "At every level, each node except the rightmost has between this.maxfanout/2 and this.maxfanout subtrees; the rightmost is allowed to have as few as 1 subtree."}
`maxfanout`	#13	`rc`	#36	`7`
`help_msg`	#79	`rc`	#36	list of 73 {"Generic BigList Utilities", "----------------------------", "This is a package for maintaining huge persistent (sorted) lists in a format that is less likely to spam the server (which runs into a certain amount of trouble dealing with long ordinary lists --- btw we use `biglist' to refer to the huge data structure we're about to describe and `list' to refer to ordinary MOO lists {...}). The biglist in question lives on a particular object, to which we will refer in the discussion below as the `home' object, and its various elements appear as leaves of a tree whose nodes are kept in properties of the home object. It should be noted that the home object does not need to be (and in fact should not be) a descendant of this one; this object merely provides utilities for manipulating the properties on the home object that are used in a particular biglist manipulation. ", "", "All of the utilities below refer to `caller' to locate the home object. Thus verbs to manipulate a given biglist must be located on or inherited by its home object itself. The home object needs to define the following verbs", "", " :_make(@args) => new property on home object with value args", " :_kill(prop) delete a given property that was created by :_make", " :_get(prop) => home.prop", " :_put(prop,@args) set home.prop = args", " :_ord(element) given something that is of the form of a biglist element", " return the corresponding ordinal (for sorting purposes).", " If you never intend to use :find_ord, then this can be a ", " routine that always returns 0 or some other random value.", "", "See #5546 (Generic Biglist Resident) or $big_mail_recipient", "for examples.", "", "Those of the following routines that take a biglist argument are expecting", "either {} (empty biglist) or some biglist returned by one of the other routines", "", " :length(biglist) => length(biglist) (i.e., number of elements)", " :find_nth(biglist,n) => biglist[n]", " :find_ord(biglist,k,comp) => n where n is", " the largest such that home:(comp)(k,home:_ord(biglist[n])) is false, or", " the smallest such that home:(comp)(k,home:_ord(biglist[n+1])) is true.", " Always returns a value between 0 and length(biglist) inclusive.", " This assumes biglist to be sorted in order of increasing :_ord values ", " with respect to home:(comp)().", " Standard situation is :_ord returns a number and comp is a < verb.", "", " :start(biglist,s,e) => {biglist[s..?],@handle} or {}", " :next(@handle) => {biglist[?+1..??],@newhandle} or {}", " These two are used for iterating over a range of elements of a biglist", " The canonical incantation for doing", " for elt in (biglist[first..last])", " ...", " endfor", " is", " handle = :start(biglist,first,last);", " while(handle)", " for elt in (handle[1])", " ...", " endfor", " handle = :next(@listdelete(handle,1));", " endwhile", "", "The following all destructively modify their biglist argument(s) L (and M).", "", " :set_nth(L,n,value) => L[n] = value", " replaces the indicated element", "", " :insert_before(L,M,n) => {@L[1..n-1],@M,@L[n..length(L)]}", " :insert_after (L,M,n) => {@L[1..n], @M,@L[n+1..length(L)]}", " takes two distinct biglists, inserts one into the other at the given point", " returns the resulting consolidated biglist", "", " :extract_range(L,m,n) => {{@L[1..m-1],@L[n+1..]}, L[m..n]} ", " breaks the given biglist into two distinct biglists.", "", " :delete_range(L,m,n[,leafkiller]) => {@L[1..m-1],@L[n+1..]}", " :keep_range (L,m,n[,leafkiller]) => L[m..n]", " like extract_range only we destroy what we don't want.", "", " :insertlast(L,value) => {@L,value}", " inserts a new element at the end of biglist. ", " If find_ord is to continue to work properly, it is assumed that the ", " home:_ord(elt) is greater (comp-wise) than all of the :_ord values", " of elements currently in the biglist.", "", " :kill(L[,leafkiller]) ", " destroys all nodes used by biglist. ", " Calls home:leafkiller on each element."}
`key`	#1	`c`	#36	`<clear>`
`aliases`	#1	`r`	#36	`{"Generic BigList Utilities", "ghblu", "biglist_utils"}`
`description`	#1	`rc`	#36	{"This is the Generic BigList Utilities utility package. See `help $biglist' for more details."}
`object_size`	#1	`r`	#36	`{24282, -1090650497}`

about

#13

rc

#36

list of 15

{"Implementation notes", "--------------------", "Each biglist is actually a tree (a kind of B-tree, actually).", "The routines above pass around handles of the form", "", "    {root_node, size, leftmost_ord}", "", "where root_node is the (string) name of a property that holds the root of the tree, size is the number of leaves in the tree, and leftmost_ord is the :_ord value of the leftmost element of the list (i.e., the leftmost leaf).", "Each node property has a value of the form ", "", "    {height,list of subtrees}.", "", "where the each of the subtrees is itself a 3-element list as above unless", "the height is 0, in which case the subtrees are actually biglist elements of the arbitrary form determined by the home object.", "At every level, each node except the rightmost has between this.maxfanout/2 and this.maxfanout subtrees; the rightmost is allowed to have as few as 1 subtree."}

maxfanout #13 rc #36 7

help_msg

#79

rc

#36

list of 73

{"Generic BigList Utilities", "----------------------------", "This is a package for maintaining huge persistent (sorted) lists in a format that is less likely to spam the server (which runs into a certain amount of trouble dealing with long ordinary lists --- btw we use `biglist' to refer to the huge data structure we're about to describe and `list' to refer to ordinary MOO lists {...}).  The biglist in question lives on a particular object, to which we will refer in the discussion below as the `home' object, and its various elements appear as leaves of a tree whose nodes are kept in properties of the home object.  It should be noted that the home object does not need to be (and in fact should *not* be) a descendant of this one; this object merely provides utilities for manipulating the properties on the home object that are used in a particular biglist manipulation.  ", "", "All of the utilities below refer to `caller' to locate the home object.  Thus verbs to manipulate a given biglist must be located on or inherited by its home object itself.  The home object needs to define the following verbs", "", "  :_make(@args)     => new property on home object with value args", "  :_kill(prop)      delete a given property that was created by :_make", "  :_get(prop)       => home.prop", "  :_put(prop,@args) set home.prop = args", "  :_ord(element)    given something that is of the form of a biglist element", "                    return the corresponding ordinal (for sorting purposes).", "                    If you never intend to use :find_ord, then this can be a ", "                    routine that always returns 0 or some other random value.", "", "See #5546 (Generic Biglist Resident) or $big_mail_recipient", "for examples.", "", "Those of the following routines that take a biglist argument are expecting", "either {} (empty biglist) or some biglist returned by one of the other routines", "", "  :length(biglist)          => length(biglist) (i.e., number of elements)", "  :find_nth(biglist,n)      => biglist[n]", "  :find_ord(biglist,k,comp) => n where n is", "     the largest such that home:(comp)(k,home:_ord(biglist[n])) is false, or", "     the smallest such that home:(comp)(k,home:_ord(biglist[n+1])) is true.", "     Always returns a value between 0 and length(biglist) inclusive.", "     This assumes biglist to be sorted in order of increasing :_ord values ", "     with respect to home:(comp)().", "     Standard situation is :_ord returns a number and comp is a < verb.", "", "  :start(biglist,s,e)  => {biglist[s..?],@handle} or {}", "  :next(@handle)       => {biglist[?+1..??],@newhandle} or {}", "     These two are used for iterating over a range of elements of a biglist", "     The canonical incantation for doing", "        for elt in (biglist[first..last])", "          ...", "        endfor", "     is", "        handle = :start(biglist,first,last);", "        while(handle)", "          for elt in (handle[1])", "            ...", "          endfor", "          handle = :next(@listdelete(handle,1));", "        endwhile", "", "The following all destructively modify their biglist argument(s) L (and M).", "", "  :set_nth(L,n,value)  =>  L[n] = value", "     replaces the indicated element", "", "  :insert_before(L,M,n) => {@L[1..n-1],@M,@L[n..length(L)]}", "  :insert_after (L,M,n) => {@L[1..n],  @M,@L[n+1..length(L)]}", "     takes two distinct biglists, inserts one into the other at the given point", "     returns the resulting consolidated biglist", "", "  :extract_range(L,m,n) => {{@L[1..m-1],@L[n+1..]}, L[m..n]} ", "     breaks the given biglist into two distinct biglists.", "", "  :delete_range(L,m,n[,leafkiller]) => {@L[1..m-1],@L[n+1..]}", "  :keep_range  (L,m,n[,leafkiller]) => L[m..n]", "     like extract_range only we destroy what we don't want.", "", "  :insertlast(L,value)  => {@L,value}", "     inserts a new element at the end of biglist.  ", "     If find_ord is to continue to work properly, it is assumed that the ", "     home:_ord(elt) is greater (comp-wise) than all of the :_ord values", "     of elements currently in the biglist.", "", "  :kill(L[,leafkiller]) ", "     destroys all nodes used by biglist.  ", "     Calls home:leafkiller on each element."}

key #1 c #36 <clear>

aliases #1 r #36 {"Generic BigList Utilities", "ghblu", "biglist_utils"}

description #1 rc #36 {"This is the Generic BigList Utilities utility package. See `help $biglist' for more details."}

object_size #1 r #36 {24282, -1090650497}

Ancestry

#1 Root Class
- #79 Generic Utilities Package
  - #13 Generic BigList Utilities

Ancestors (nearest first): #79 Generic Utilities Package → #1 Root Class

Children: none