From 4e2a34cc2932185f67a8d307b7033d7652b7fda5 Mon Sep 17 00:00:00 2001 From: "Gary V. Vaughan" Date: Sat, 6 Feb 2016 00:16:08 +0000 Subject: [PATCH 1/3] Initial documentation import. --- .gitignore | 3 + index.html | 99 +++ ldoc.css | 304 +++++++++ object_system/prototype.container.html | 337 ++++++++++ object_system/prototype.list.html | 534 +++++++++++++++ object_system/prototype.object.html | 295 ++++++++ object_system/prototype.set.html | 890 +++++++++++++++++++++++++ object_system/prototype.strbuf.html | 267 ++++++++ object_system/prototype.tree.html | 528 +++++++++++++++ 9 files changed, 3257 insertions(+) create mode 100644 .gitignore create mode 100644 index.html create mode 100644 ldoc.css create mode 100644 object_system/prototype.container.html create mode 100644 object_system/prototype.list.html create mode 100644 object_system/prototype.object.html create mode 100644 object_system/prototype.set.html create mode 100644 object_system/prototype.strbuf.html create mode 100644 object_system/prototype.tree.html diff --git a/.gitignore b/.gitignore new file mode 100644 index 0000000..6009d70 --- /dev/null +++ b/.gitignore @@ -0,0 +1,3 @@ +.DS_Store +/doc +!/doc/config.ld.in diff --git a/index.html b/index.html new file mode 100644 index 0000000..8087820 --- /dev/null +++ b/index.html @@ -0,0 +1,99 @@ + + + + + prototype 1.0 Reference + + + + +
+ +
+ +
+
+
+ + +
+ + + + + + +
+ + +

+

Module Oriented Programming with Lua

+ +

A straight forward prototype-based object system, and a selection of +useful objects built on it. + +

This is a collection of light-weight libraries for Lua 5.1 (including +LuaJIT), 5.2 and 5.3 written in pure Lua, comprising:

+ +

LICENSE

+ +

The code is copyright by its respective authors, and released under the +MIT license (the same license as Lua itself). There is no warranty.

+ + + +

Object System

+ + + + + + + + + + + + + + + + + + + + + + + + + +
prototype.containerContainer prototype.
prototype.objectObject prototype.
prototype.listList prototype.
prototype.setSet container prototype.
prototype.strbufString buffer prototype.
prototype.treeTree container prototype.
+ +
+
+
+generated by LDoc 1.4.3 +Last updated 2016-02-06 00:10:05 +
+
+ + diff --git a/ldoc.css b/ldoc.css new file mode 100644 index 0000000..ce77ac8 --- /dev/null +++ b/ldoc.css @@ -0,0 +1,304 @@ +/* BEGIN RESET + +Copyright (c) 2010, Yahoo! Inc. All rights reserved. +Code licensed under the BSD License: +http://developer.yahoo.com/yui/license.html +version: 2.8.2r1 +*/ +html { + color: #000; + background: #FFF; +} +body,div,dl,dt,dd,ul,ol,li,h1,h2,h3,h4,h5,h6,pre,code,form,fieldset,legend,input,button,textarea,p,blockquote,th,td { + margin: 0; + padding: 0; +} +table { + border-collapse: collapse; + border-spacing: 0; +} +fieldset,img { + border: 0; +} +address,caption,cite,code,dfn,em,strong,th,var,optgroup { + font-style: inherit; + font-weight: inherit; +} +del,ins { + text-decoration: none; +} +li { + list-style: disc; + margin-left: 20px; +} +caption,th { + text-align: left; +} +h1,h2,h3,h4,h5,h6 { + font-size: 100%; + font-weight: bold; +} +q:before,q:after { + content: ''; +} +abbr,acronym { + border: 0; + font-variant: normal; +} +sup { + vertical-align: baseline; +} +sub { + vertical-align: baseline; +} +legend { + color: #000; +} +input,button,textarea,select,optgroup,option { + font-family: inherit; + font-size: inherit; + font-style: inherit; + font-weight: inherit; +} +input,button,textarea,select {*font-size:100%; +} +/* END RESET */ + +body { + margin-left: 1em; + margin-right: 1em; + font-family: arial, helvetica, geneva, sans-serif; + background-color: #ffffff; margin: 0px; +} + +code, tt { font-family: monospace; font-size: 1.1em; } +span.parameter { font-family:monospace; } +span.parameter:after { content:":"; } +span.types:before { content:"("; } +span.types:after { content:")"; } +.type { font-weight: bold; font-style:italic } + +body, p, td, th { font-size: .95em; line-height: 1.2em;} + +p, ul { margin: 10px 0 0 0px;} + +strong { font-weight: bold;} + +em { font-style: italic;} + +h1 { + font-size: 1.5em; + margin: 0 0 20px 0; +} +h2, h3, h4 { margin: 15px 0 10px 0; } +h2 { font-size: 1.25em; } +h3 { font-size: 1.15em; } +h4 { font-size: 1.06em; } + +a:link { font-weight: bold; color: #004080; text-decoration: none; } +a:visited { font-weight: bold; color: #006699; text-decoration: none; } +a:link:hover { text-decoration: underline; } + +hr { + color:#cccccc; + background: #00007f; + height: 1px; +} + +blockquote { margin-left: 3em; } + +ul { list-style-type: disc; } + +p.name { + font-family: "Andale Mono", monospace; + padding-top: 1em; +} + +pre { + background-color: rgb(245, 245, 245); + border: 1px solid #C0C0C0; /* silver */ + padding: 10px; + margin: 10px 0 10px 0; + overflow: auto; + font-family: "Andale Mono", monospace; +} + +pre.example { + font-size: .85em; +} + +table.index { border: 1px #00007f; } +table.index td { text-align: left; vertical-align: top; } + +#container { + margin-left: 1em; + margin-right: 1em; + background-color: #f0f0f0; +} + +#product { + text-align: center; + border-bottom: 1px solid #cccccc; + background-color: #ffffff; +} + +#product big { + font-size: 2em; +} + +#main { + background-color: #f0f0f0; + border-left: 2px solid #cccccc; +} + +#navigation { + float: left; + width: 14em; + vertical-align: top; + background-color: #f0f0f0; + overflow: visible; +} + +#navigation h2 { + background-color:#e7e7e7; + font-size:1.1em; + color:#000000; + text-align: left; + padding:0.2em; + border-top:1px solid #dddddd; + border-bottom:1px solid #dddddd; +} + +#navigation ul +{ + font-size:1em; + list-style-type: none; + margin: 1px 1px 10px 1px; +} + +#navigation li { + text-indent: -1em; + display: block; + margin: 3px 0px 0px 22px; +} + +#navigation li li a { + margin: 0px 3px 0px -1em; +} + +#content { + margin-left: 14em; + padding: 1em; + width: 700px; + border-left: 2px solid #cccccc; + border-right: 2px solid #cccccc; + background-color: #ffffff; +} + +#about { + clear: both; + padding: 5px; + border-top: 2px solid #cccccc; + background-color: #ffffff; +} + +@media print { + body { + font: 12pt "Times New Roman", "TimeNR", Times, serif; + } + a { font-weight: bold; color: #004080; text-decoration: underline; } + + #main { + background-color: #ffffff; + border-left: 0px; + } + + #container { + margin-left: 2%; + margin-right: 2%; + background-color: #ffffff; + } + + #content { + padding: 1em; + background-color: #ffffff; + } + + #navigation { + display: none; + } + pre.example { + font-family: "Andale Mono", monospace; + font-size: 10pt; + page-break-inside: avoid; + } +} + +table.module_list { + border-width: 1px; + border-style: solid; + border-color: #cccccc; + border-collapse: collapse; +} +table.module_list td { + border-width: 1px; + padding: 3px; + border-style: solid; + border-color: #cccccc; +} +table.module_list td.name { background-color: #f0f0f0; min-width: 200px; } +table.module_list td.summary { width: 100%; } + + +table.function_list { + border-width: 1px; + border-style: solid; + border-color: #cccccc; + border-collapse: collapse; +} +table.function_list td { + border-width: 1px; + padding: 3px; + border-style: solid; + border-color: #cccccc; +} +table.function_list td.name { background-color: #f0f0f0; min-width: 200px; } +table.function_list td.summary { width: 100%; } + +ul.nowrap { + overflow:auto; + white-space:nowrap; +} + +dl.table dt, dl.function dt {border-top: 1px solid #ccc; padding-top: 1em;} +dl.table dd, dl.function dd {padding-bottom: 1em; margin: 10px 0 0 20px;} +dl.table h3, dl.function h3 {font-size: .95em;} + +/* stop sublists from having initial vertical space */ +ul ul { margin-top: 0px; } +ol ul { margin-top: 0px; } +ol ol { margin-top: 0px; } +ul ol { margin-top: 0px; } + +/* make the target distinct; helps when we're navigating to a function */ +a:target + * { + background-color: #FF9; +} + + +/* styles for prettification of source */ +pre .comment { color: #558817; } +pre .constant { color: #a8660d; } +pre .escape { color: #844631; } +pre .keyword { color: #aa5050; font-weight: bold; } +pre .library { color: #0e7c6b; } +pre .marker { color: #512b1e; background: #fedc56; font-weight: bold; } +pre .string { color: #8080ff; } +pre .number { color: #f8660d; } +pre .operator { color: #2239a8; font-weight: bold; } +pre .preprocessor, pre .prepro { color: #a33243; } +pre .global { color: #800080; } +pre .user-keyword { color: #800080; } +pre .prompt { color: #558817; } +pre .url { color: #272fc2; text-decoration: underline; } + diff --git a/object_system/prototype.container.html b/object_system/prototype.container.html new file mode 100644 index 0000000..fc43748 --- /dev/null +++ b/object_system/prototype.container.html @@ -0,0 +1,337 @@ + + + + + prototype 1.0 Reference + + + + +
+ +
+ +
+
+
+ + +
+ + + + + + +
+ +

Module prototype.container

+

Container prototype. +

+ + +

This module supplies the root prototype object from which every other + object is descended. There are no classes as such, rather new objects + are created by cloning an existing object, and then changing or adding + to the clone. Further objects can then be made by cloning the changed + object, and so on.

+ +

The functionality of a container based object is entirely defined by its + metamethods. However, since we can store any object in a container, + we cannot rely on the __index metamethod, because it is only a + fallback for when that key is not already in the container itself. Of + course that does not entirely preclude the use of __index with + containers, so long as this limitation is observed.

+ +

When making your own prototypes, derive from prototype.container.prototype + if you want to access the contents of your containers with the [] + operator, otherwise from prototype.object.prototype if you want to access + the functionality of your objects with named object methods.

+ +

Prototype Chain

+ + +
+table
+ `-> Container
+
+ +

+ + +

Objects

+ + + + + +
prototypeContainer prototype.
+

Metamethods

+ + + + + + + + + +
prototype:__call (...)Return a clone of this container and its metatable.
prototype:__tostring ()Return a compact string representation of this object.
+

Functions

+ + + + + +
mapfields (new, src[, map={}])Return new with references to the fields of src merged in.
+ +
+
+ + +

Objects

+ +
+
+ + prototype +
+
+ Container prototype. + + +

Fields:

+
    +
  • _init + table or function + object initialisation + (optional) +
    • +
  • _type + string + object name + (default "Container") +
    • +
+ + + + +

Usage:

+
    + 
    + local Container = require "prototype.container".prototype
+ local Graph = Container { _type = "Graph" }
+ local function nodes (graph)
+   local n = 0
+   for _ in std.pairs (graph) do n = n + 1 end
+   return n
+ end
+ local g = Graph { "node1", "node2" }
+ assert (nodes (g) == 2)
    +
+ +
+
+

Metamethods

+ +
+
+ + prototype:__call (...) +
+
+ Return a clone of this container and its metatable.

+ +

Like any Lua table, a container is essentially a collection of + field_n = value_n pairs, except that field names beginning with + an underscore _ are usually kept in that container's metatable + where they define the behaviour of a container object rather than + being part of its actual contents. In general, cloned objects + also clone the behaviour of the object they cloned, unless...

+ +

When calling prototype.container.prototype, you pass a single table + argument with additional fields (and values) to be merged into the + clone. Any field names beginning with an underscore _ are copied + to the clone's metatable, and all other fields to the cloned + container itself. For instance, you can change the name of the + cloned object by setting the _type field in the argument table.

+ +

The _init private field is also special: When set to a sequence of + field names, unnamed fields in the call argument table are assigned + to those field names in subsequent clones, like the example below.

+ +

Alternatively, you can set the _init private field of a cloned + container object to a function instead of a sequence, in which case + all the arguments passed when it is called/cloned (including named + and unnamed fields in the initial table argument, if there is one) + are passed through to the _init function, following the nascent + cloned object. See the mapfields usage example below. + + +

Parameters:

+
    +
  • ... + arguments to prototype's _init, often a single table +
    • +
+ +

Returns:

+
    + + prototype + clone of this container, with shared or + merged metatable as appropriate +
+ + + +

Usage:

+
    + 
    + local Cons = Container {_type="Cons", _init={"car", "cdr"}}
+ local list = Cons {"head", Cons {"tail", nil}}
    +
+ +
+
+ + prototype:__tostring () +
+
+ Return a compact string representation of this object.

+ +

First the container name, and then between { and } an ordered list + of the array elements of the contained values with numeric keys, + followed by asciibetically sorted remaining public key-value pairs.

+ +

This metamethod doesn't recurse explicitly, but relies upon + suitable __tostring metamethods for non-primitive content objects. + + + +

Returns:

+
    + + string + stringified object representation +
+ + +

See also:

+ + +

Usage:

+
    + 
    assert (tostring (list) == 'Cons {car="head", cdr=Cons {car="tail"}}')
    +
+ +
+
+

Functions

+ +
+
+ + mapfields (new, src[, map={}]) +
+
+ Return new with references to the fields of src merged in.

+ +

This is the function used to instantiate the contents of a newly + cloned container, as called by __call above, to split the + fields of a __call argument table into private "_" prefixed + field namess, -- which are merged into the new metatable, and + public (everything else) names, which are merged into new itself.

+ +

You might want to use this function from _init functions of your + own derived containers. + + +

Parameters:

+
    +
  • new + table + partially instantiated clone container +
    • +
  • src + table + __call argument table that triggered cloning +
    • +
  • map + table + key renaming specification in the form + {old_key=new_key, ...} + (default {}) +
    • +
+ +

Returns:

+
    + + table + merged public fields from new and src, with a + metatable of private fields (if any), both renamed according to + map +
+ + + +

Usage:

+
    + 
    + local Bag = Container {
+   _type = "Bag",
+   _init = function (new, ...)
+     if type (...) == "table" then
+       return container.mapfields (new, (...))
+     end
+     return functional.reduce (operator.set, new, ipairs, {...})
+   end,
+ }
+ local groceries = Bag ("apple", "banana", "banana")
+ local purse = Bag {_type = "Purse"} ("cards", "cash", "id")
    +
+ +
+
+ + +
+
+
+generated by LDoc 1.4.3 +Last updated 2016-02-06 00:10:05 +
+
+ + diff --git a/object_system/prototype.list.html b/object_system/prototype.list.html new file mode 100644 index 0000000..2439686 --- /dev/null +++ b/object_system/prototype.list.html @@ -0,0 +1,534 @@ + + + + + prototype 1.0 Reference + + + + +
+ +
+ +
+
+
+ + +
+ + + + + + +
+ +

Module prototype.list

+

List prototype. +

+ + +

In addition to the functionality described here, List objects also + have all the methods and metamethods of the prototype.object.prototype + (except where overridden here),

+ +

Prototype Chain

+ + +
+table
+ `-> Container
+      `-> Object
+           `-> List
+
+ +

+ + +

Metamethods

+ + + + + + + + + + + + + + + + + +
prototype:__concat (m)Concatenate lists.
prototype:__add (e)Append element to list.
prototype:__lt (m)List order operator.
prototype:__le (m)List equality or order operator.
+

Methods

+ + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + +
prototype:append (x)Append an item to a list.
prototype:compare (m)Compare two lists element-by-element, from left-to-right.
prototype:concat (...)Concatenate the elements from any number of lists.
prototype:cons (x)Prepend an item to a list.
prototype:rep (n)Repeat a list.
prototype:sub ([from=1[, to=#l]])Return a sub-range of a list.
prototype:tail ()Return a list with its first element removed.
prototypeList prototype object.
+ +
+
+ + +

Metamethods

+ +
+
+ + prototype:__concat (m) +
+
+ Concatenate lists. + + +

Parameters:

+
    +
  • m + prototype or table + another list, or table (hash part is ignored) +
    • +
+ + + +

See also:

+ + +

Usage:

+
    + 
    new = alist .. {"append", "these", "elements"}
    +
+ +
+
+ + prototype:__add (e) +
+
+ Append element to list. + + +

Parameters:

+
    +
  • e + element to append +
    • +
+ + + +

See also:

+ + +

Usage:

+
    + 
    list = list + "element"
    +
+ +
+
+ + prototype:__lt (m) +
+
+ List order operator. + + +

Parameters:

+ + + + +

See also:

+ + +

Usage:

+
    + 
    max = list1 > list2 and list1 or list2
    +
+ +
+
+ + prototype:__le (m) +
+
+ List equality or order operator. + + +

Parameters:

+ + + + +

See also:

+ + +

Usage:

+
    + 
    min = list1 <= list2 and list1 or list2
    +
+ +
+
+

Methods

+ +
+
+ + prototype:append (x) +
+
+ Append an item to a list. + + +

Parameters:

+
    +
  • x + item +
    • +
+ +

Returns:

+
    + + prototype + new list with x appended +
+ + + +

Usage:

+
    + 
    + --> List {"shorter", "longer"}
+ longer = (List {"shorter"}):append "longer"
    +
+ +
+
+ + prototype:compare (m) +
+
+ Compare two lists element-by-element, from left-to-right. + + +

Parameters:

+ + +

Returns:

+
    + + -1 if l is less than m, 0 if they are the same, and 1 + if l is greater than m +
+ + + +

Usage:

+
    + 
    if list1:compare (list2) == 0 then print "same" end
    +
+ +
+
+ + prototype:concat (...) +
+
+ Concatenate the elements from any number of lists. + + +

Parameters:

+
    +
  • ... + prototype or table + additional lists, or list-like tables +
    • +
+ +

Returns:

+
    + + prototype + new list with elements from arguments +
+ + + +

Usage:

+
    + 
    + --> List {"shorter", "short", "longer", "longest"}
+ longest = (List {"shorter"}):concat ({"short", "longer"}, {"longest"})
    +
+ +
+
+ + prototype:cons (x) +
+
+ Prepend an item to a list. + + +

Parameters:

+
    +
  • x + item +
    • +
+ +

Returns:

+
    + + prototype + new list with x followed by elements of l +
+ + + +

Usage:

+
    + 
    + --> List {"x", 1, 2, 3}
+ consed = (List {1, 2, 3}):cons "x"
    +
+ +
+
+ + prototype:rep (n) +
+
+ Repeat a list. + + +

Parameters:

+
    +
  • n + int + number of times to repeat +
    • +
+ +

Returns:

+
    + + prototype + n copies of l appended together +
+ + + +

Usage:

+
    + 
    + --> List {1, 2, 3, 1, 2, 3, 1, 2, 3}
+ repped = (List {1, 2, 3}):rep (3)
    +
+ +
+
+ + prototype:sub ([from=1[, to=#l]]) +
+
+ Return a sub-range of a list. + (The equivalent of string.sub on strings; negative list indices + count from the end of the list.) + + +

Parameters:

+
    +
  • from + int + start of range + (default 1) +
    • +
  • to + int + end of range + (default #l) +
    • +
+ +

Returns:

+
    + + prototype + new list containing elements between from and to + inclusive +
+ + + +

Usage:

+
    + 
    + --> List {3, 4, 5}
+ subbed = (List {1, 2, 3, 4, 5, 6}):sub (3, 5)
    +
+ +
+
+ + prototype:tail () +
+
+ Return a list with its first element removed. + + + +

Returns:

+
    + + prototype + new list with all but the first element of l +
+ + + +

Usage:

+
    + 
    + --> List {3, {4, 5}, 6, 7}
+ tailed = (List {{1, 2}, 3, {4, 5}, 6, 7}):tail ()
    +
+ +
+
+ + prototype +
+
+ List prototype object. + + +

Fields:

+
    +
  • _init + table or function + object initialisation + (optional) +
    • +
  • _type + string + object name + (default "List") +
    • +
+ + + +

See also:

+ + +

Usage:

+
    + 
    + local List = require "prototype.list".prototype
+ assert (prototype.type (List) == "List")
    +
+ +
+
+ + +
+
+
+generated by LDoc 1.4.3 +Last updated 2016-02-06 00:10:05 +
+
+ + diff --git a/object_system/prototype.object.html b/object_system/prototype.object.html new file mode 100644 index 0000000..2b84e9f --- /dev/null +++ b/object_system/prototype.object.html @@ -0,0 +1,295 @@ + + + + + prototype 1.0 Reference + + + + +
+ +
+ +
+
+
+ + +
+ + + + + + +
+ +

Module prototype.object

+

Object prototype. +

+ + +

This module provides a specialization of the prototype.container.prototype + with the addition of object methods. In addition to the functionality + described here, object prototypes also have all the methods and + metamethods of the prototype.container.prototype.

+ +

Note that object methods are stored in the __index field of their + metatable, and so cannot also use the __index metamethod to lookup + references with square brackets. Use a prototype.container.prototype based + object if you want to do that.

+ +

Prototype Chain

+ + +
+table
+ `-> Container
+      `-> Object
+
+ +

+ + +

Metamethods

+ + + + + +
prototype:__pairs ()Return an in-order iterator over public object fields.
+

Methods

+ + + + + +
prototype:clone (...)Return a clone of this object and its metatable.
+

Object Functions

+ + + + + + + + + +
prototype.mapfields (new, src[, map={}])Return new with references to the fields of src merged in.
prototypeObject prototype.
+ +
+
+ + +

Metamethods

+ +
+
+ + prototype:__pairs () +
+
+ Return an in-order iterator over public object fields. + + + +

Returns:

+
    +
  1. + function + iterator function
    2. +
  2. + Object + self
    3. +
+ + + +

Usage:

+
    + 
    for k, v in prototype.pairs (anobject) do process (k, v) end
    +
+ +
+
+

Methods

+ +
+
+ + prototype:clone (...) +
+
+ Return a clone of this object and its metatable.

+ +

This function is useful if you need to override the normal use of + the __call metamethod for object cloning, without losing the + ability to clone an object. + + +

Parameters:

+
    +
  • ... + arguments to prototype's _init, often a single table +
    • +
+ +

Returns:

+
    + + prototype + a clone of this object, with shared or merged + metatable as appropriate +
+ + +

See also:

+ + +

Usage:

+
    + 
    + local Node = Object { _type = "Node" }
+ -- A trivial FSA to recognize powers of 10, either "0" or a "1"
+ -- followed by zero or more "0"s can transition to state 'finish'
+ local states; states = {
+   start  = Node { ["1"] = states[1], ["0"] = states.finish },
+   [1]    = Node { ["0"] = states[1], [""] = states.finish },
+   finish = Node {},
+ }
    +
+ +
+
+

Object Functions

+ +
+
+ + prototype.mapfields (new, src[, map={}]) +
+
+ Return new with references to the fields of src merged in.

+ +

You can change the value of this function in an object, and that + new function will be called during cloning instead of the + standard prototype.container.mapfields implementation. + + +

Parameters:

+
    +
  • new + table + partially instantiated clone container +
    • +
  • src + table + clone argument table that triggered cloning +
    • +
  • map + table + key renaming specification in the form + {old_key=new_key, ...} + (default {}) +
    • +
+ +

Returns:

+
    + + table + merged public fields from new and src, with a + metatable of private fields (if any), both renamed according to + map +
+ + +

See also:

+ + + +
+
+ + prototype +
+
+ Object prototype. + + +

Fields:

+
    +
  • _init + table or function + object initialisation + (optional) +
    • +
  • _type + string + object name + (default "Object") +
    • +
+ + + + +

Usage:

+
    + 
    + local Object = require "prototype.object".prototype
+ local Process = Object {
+   _type = "Process",
+   _init = { "status", "out", "err" },
+ }
+ local process = Process {
+   procs[pid].status, procs[pid].out, procs[pid].err, -- auto assigned
+   command = pipeline[pid],                           -- manual assignment
+ }
    +
+ +
+
+ + +
+
+
+generated by LDoc 1.4.3 +Last updated 2016-02-06 00:10:05 +
+
+ + diff --git a/object_system/prototype.set.html b/object_system/prototype.set.html new file mode 100644 index 0000000..02092d6 --- /dev/null +++ b/object_system/prototype.set.html @@ -0,0 +1,890 @@ + + + + + prototype 1.0 Reference + + + + +
+ +
+ +
+
+
+ + +
+ + + + + + +
+ +

Module prototype.set

+

Set container prototype. +

+ + +

This module returns a table of set operators, as well as the prototype + for a Set container object.

+ +

Every possible object or primitive value is always present in any Set + container exactly zero or one times.

+ +

In addition to the functionality described here, Set containers also + have all the methods and metamethods of the prototype.container.prototype + (except where overridden here).

+ +

Prototype Chain

+ + +
+table
+ `-> Container
+      `-> Set
+
+ +

+ + +

Objects

+ + + + + +
prototypeSet prototype object.
+

Initialisation

+ + + + + +
prototype._initSet object initialisation.
+

Metamethods

+ + + + + + + + + + + + + + + + + + + + + + + + + + + + + +
prototype:__add (s)Union operation.
prototype:__sub (s)Difference operation.
prototype:__mul (s)Intersection operation.
prototype:__div (s)Symmetric difference operation.
prototype:__le (s)Subset operation.
prototype:__lt (s)Proper subset operation.
prototype:__tostring ()Return a string representation of this set.
+

Functions

+ + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + +
delete (set, e)Delete an element from a set.
difference (set1, set2)Find the difference of two sets.
elems (set)Iterator for sets.
equal (set1, set2)Find whether two sets are equal.
insert (set, e)Insert an element into a set.
intersection (set1, set2)Find the intersection of two sets.
difference (set, e)Say whether an element is in a set.
proper_subset (set1, set2)Find whether one set is a proper subset of another.
subset (set1, set2)Find whether one set is a subset of another.
symmetric_difference (set1, set2)Find the symmetric difference of two sets.
union (set1, set2)Find the union of two sets.
+ +
+
+ + +

Objects

+ +
+
+ + prototype +
+
+ Set prototype object. + + +

Fields:

+
    +
  • _type + string + object name + (default "Set") +
    • +
+ + + +

See also:

+ + +

Usage:

+
    + 
    + local Set = require "prototype.set".prototype
+ assert (prototype.type (Set) == "Set")
    +
+ +
+
+

Initialisation

+ +
+
+ + prototype._init +
+
+ Set object initialisation.

+ +

Returns partially initialised Set container with contents + from t. + + +

Parameters:

+
    +
  • new + table + uninitialised Set container object +
    • +
  • t + table + initialisation table from __call +
    • +
+ + + + + +
+
+

Metamethods

+ +
+
+ + prototype:__add (s) +
+
+ Union operation. + + +

Parameters:

+ + +

Returns:

+
    + + prototype + everything from this set plus everything from s +
+ + +

See also:

+ + +

Usage:

+
    + 
    union = this + s
    +
+ +
+
+ + prototype:__sub (s) +
+
+ Difference operation. + + +

Parameters:

+ + +

Returns:

+
    + + prototype + everything from this set that is not also in s +
+ + +

See also:

+ + +

Usage:

+
    + 
    difference = this - s
    +
+ +
+
+ + prototype:__mul (s) +
+
+ Intersection operation. + + +

Parameters:

+ + +

Returns:

+
    + + prototype + anything in both this set and in s +
+ + +

See also:

+ + +

Usage:

+
    + 
    intersection = this * s
    +
+ +
+
+ + prototype:__div (s) +
+
+ Symmetric difference operation. + + +

Parameters:

+ + +

Returns:

+
    + + prototype + everything in this set or in s but not in both +
+ + +

See also:

+ + +

Usage:

+
    + 
    symmetric_difference = this / s
    +
+ +
+
+ + prototype:__le (s) +
+
+ Subset operation. + + +

Parameters:

+ + +

Returns:

+
    + + boolean + true if everything in this set is also in s +
+ + +

See also:

+ + +

Usage:

+
    + 
    issubset = this <= s
    +
+ +
+
+ + prototype:__lt (s) +
+
+ Proper subset operation. + + +

Parameters:

+ + +

Returns:

+
    + + boolean + true if s is not equal to this set, but does + contain everything from this set +
+ + +

See also:

+ + +

Usage:

+
    + 
    ispropersubset = this < s
    +
+ +
+
+ + prototype:__tostring () +
+
+ Return a string representation of this set. + + + +

Returns:

+
    + + string + string representation of a set. +
+ + +

See also:

+
    +
+ + +
+
+

Functions

+ +
+
+ + delete (set, e) +
+
+ Delete an element from a set. + + +

Parameters:

+
    +
  • set + prototype + a set +
    • +
  • e + element +
    • +
+ +

Returns:

+
    + + prototype + the modified set +
+ + + +

Usage:

+
    + 
    set.delete (available, found)
    +
+ +
+
+ + difference (set1, set2) +
+
+ Find the difference of two sets. + + +

Parameters:

+ + +

Returns:

+
    + + prototype + a copy of set1 with elements of set2 removed +
+ + + +

Usage:

+
    + 
    all = set.difference (all, Set {32, 49, 56})
    +
+ +
+
+ + elems (set) +
+
+ Iterator for sets. + + +

Parameters:

+ + +

Returns:

+
    + + set iterator +
+ + + +

Usage:

+
    + 
    for code in set.elems (isprintable) do print (code) end
    +
+ +
+
+ + equal (set1, set2) +
+
+ Find whether two sets are equal. + + +

Parameters:

+ + +

Returns:

+
    + + boolean + true if set1 and set2 each contain identical + elements, false otherwise +
+ + + +

Usage:

+
    + 
    if set.equal (keys, Set {META, CTRL, "x"}) then process (keys) end
    +
+ +
+
+ + insert (set, e) +
+
+ Insert an element into a set. + + +

Parameters:

+
    +
  • set + prototype + a set +
    • +
  • e + element +
    • +
+ +

Returns:

+
    + + prototype + the modified set +
+ + + +

Usage:

+
    + 
    + for byte = 32,126 do
+   set.insert (isprintable, string.char (byte))
+ end
    +
+ +
+
+ + intersection (set1, set2) +
+
+ Find the intersection of two sets. + + +

Parameters:

+ + +

Returns:

+
    + + prototype + a new set with elements in both set1 and set2 +
+ + + +

Usage:

+
    + 
    common = set.intersection (a, b)
    +
+ +
+
+ + difference (set, e) +
+
+ Say whether an element is in a set. + + +

Parameters:

+
    +
  • set + prototype + a set +
    • +
  • e + element +
    • +
+ +

Returns:

+
    + + true if e is in set, otherwise false + otherwise +
+ + + +

Usage:

+
    + 
    if not set.member (keyset, pressed) then return nil end
    +
+ +
+
+ + proper_subset (set1, set2) +
+
+ Find whether one set is a proper subset of another. + + +

Parameters:

+ + +

Returns:

+
    + + boolean + true if set2 contains all elements in set1 + but not only those elements, false otherwise +
+ + + +

Usage:

+
    + 
    + if set.proper_subset (a, b) then
+   for e in set.elems (set.difference (b, a)) do
+     set.delete (b, e)
+   end
+ end
+ assert (set.equal (a, b))
    +
+ +
+
+ + subset (set1, set2) +
+
+ Find whether one set is a subset of another. + + +

Parameters:

+ + +

Returns:

+
    + + boolean + true if all elements in set1 are also in set2, + false otherwise +
+ + + +

Usage:

+
    + 
    if set.subset (a, b) then a = b end
    +
+ +
+
+ + symmetric_difference (set1, set2) +
+
+ Find the symmetric difference of two sets. + + +

Parameters:

+ + +

Returns:

+
    + + prototype + a new set with elements that are in set1 or set2 + but not both +
+ + + +

Usage:

+
    + 
    unique = set.symmetric_difference (a, b)
    +
+ +
+
+ + union (set1, set2) +
+
+ Find the union of two sets. + + +

Parameters:

+ + +

Returns:

+
    + + prototype + a copy of set1 with elements in set2 merged in +
+ + + +

Usage:

+
    + 
    all = set.union (a, b)
    +
+ +
+
+ + +
+
+
+generated by LDoc 1.4.3 +Last updated 2016-02-06 00:10:05 +
+
+ + diff --git a/object_system/prototype.strbuf.html b/object_system/prototype.strbuf.html new file mode 100644 index 0000000..920a1df --- /dev/null +++ b/object_system/prototype.strbuf.html @@ -0,0 +1,267 @@ + + + + + prototype 1.0 Reference + + + + +
+ +
+ +
+
+
+ + +
+ + + + + + +
+ +

Module prototype.strbuf

+

String buffer prototype. +

+ + +

Buffers are mutable by default, but being based on objects, they can + also be used in a functional style:

+ + +
+local StrBuf = require "prototype.strbuf".prototype
+local a = StrBuf {"a"}
+local b = a:concat "b"    -- mutate *a*
+print (a, b)              --> ab   ab
+local c = a {} .. "c"     -- copy and append
+print (a, c)              --> ab   abc
+
+
+ +

In addition to the functionality described here, StrBuf objects also + have all the methods and metamethods of the prototype.object.prototype + (except where overridden here),

+ +

Prototype Chain

+ + +
+table
+ `-> Container
+      `-> Object
+           `-> StrBuf
+
+ +

+ + +

Metamethods

+ + + + + + + + + +
prototype:__concat (x)Support concatenation to StrBuf objects.
prototype:__tostring ()Support fast conversion to Lua string.
+

Methods

+ + + + + + + + + +
prototype:concat (x)Add a object to a buffer.
prototypeStrBuf prototype object.
+ +
+
+ + +

Metamethods

+ +
+
+ + prototype:__concat (x) +
+
+ Support concatenation to StrBuf objects. + + +

Parameters:

+
    +
  • x + a string, or object that can be coerced to a string +
    • +
+ +

Returns:

+
    + + prototype + modified buf +
+ + +

See also:

+ + +

Usage:

+
    + 
    buf = buf .. x
    +
+ +
+
+ + prototype:__tostring () +
+
+ Support fast conversion to Lua string. + + + +

Returns:

+
    + + string + concatenation of buffer contents +
+ + +

See also:

+ + +

Usage:

+
    + 
    str = tostring (buf)
    +
+ +
+
+

Methods

+ +
+
+ + prototype:concat (x) +
+
+ Add a object to a buffer. + Elements are stringified lazily, so if you add a table and then + change its contents, the contents of the buffer will be affected + too. + + +

Parameters:

+
    +
  • x + object to add to buffer +
    • +
+ +

Returns:

+
    + + prototype + modified buffer +
+ + + +

Usage:

+
    + 
    c = StrBuf {} :concat "append this" :concat (StrBuf {" and", " this"})
    +
+ +
+
+ + prototype +
+
+ StrBuf prototype object. + + +

Fields:

+
    +
  • _type + string + object name + (default "StrBuf") +
    • +
+ + + +

See also:

+ + +

Usage:

+
    + 
    + local StrBuf = require "prototype.strbuf".prototype
+ local a = StrBuf {1, 2, 3}
+ local b = StrBuf {a, "five", "six"}
+ a = a .. 4
+ b = b:concat "seven"
+ print (a, b) --> 1234   1234fivesixseven
+ os.exit (0)
    +
+ +
+
+ + +
+
+
+generated by LDoc 1.4.3 +Last updated 2016-02-06 00:10:05 +
+
+ + diff --git a/object_system/prototype.tree.html b/object_system/prototype.tree.html new file mode 100644 index 0000000..5f13ea5 --- /dev/null +++ b/object_system/prototype.tree.html @@ -0,0 +1,528 @@ + + + + + prototype 1.0 Reference + + + + +
+ +
+ +
+
+
+ + +
+ + + + + + +
+ +

Module prototype.tree

+

Tree container prototype. +

+ + +

This module returns a table of tree operators, as well as the prototype + for a Tree container object.

+ +

This is not a search tree, but rather a way to efficiently store and + retrieve values stored with a path as a key, such as a multi-key + keytable. Although it does have iterators for walking the tree with + various algorithms.

+ +

In addition to the functionality described here, Tree containers also + have all the methods and metamethods of the prototype.container.prototype + (except where overridden here),

+ +

Prototype Chain

+ + +
+table
+ `-> Container
+      `-> Tree
+
+ +

+ + +

Objects

+ + + + + +
prototypeTree prototype object.
+

Metamethods

+ + + + + + + + + +
prototype:__index (i)Deep retrieval.
prototype:__newindex (i[, v])Deep insertion.
+

Functions

+ + + + + + + + + + + + + + + + + + + + + + + + + +
clone (tr, nometa)Make a deep copy of a tree or table, including any metatables.
ileaves (tr)Tree iterator which returns just numbered leaves, in order.
inodes (tr)Tree iterator over numbered nodes, in order.
leaves (t)Tree iterator which returns just leaves.
merge (t, u)Destructively deep-merge one tree into another.
nodes (tr)Tree iterator over all nodes.
+ +
+
+ + +

Objects

+ +
+
+ + prototype +
+
+ Tree prototype object. + + +

Fields:

+
    +
  • _type + string + object name + (default "Tree") +
    • +
+ + + +

See also:

+ + +

Usage:

+
    + 
    + local tree = require "prototype.tree"
+ local Tree = tree.prototype
+ local tr = Tree {}
+ tr[{"branch1", 1}] = "leaf1"
+ tr[{"branch1", 2}] = "leaf2"
+ tr[{"branch2", 1}] = "leaf3"
+ print (tr[{"branch1"}])      --> Tree {leaf1, leaf2}
+ print (tr[{"branch1", 2}])   --> leaf2
+ print (tr[{"branch1", 3}])   --> nil
+ --> leaf1	leaf2	leaf3
+ for leaf in tree.leaves (tr) do
+   io.write (leaf .. "\t")
+ end
    +
+ +
+
+

Metamethods

+ +
+
+ + prototype:__index (i) +
+
+ Deep retrieval. + + +

Parameters:

+
    +
  • i + non-table, or list of keys {i1, ...i_n} +
    • +
+ +

Returns:

+
    + + tr[i1]...[i_n] if i is a key list, tr[i] otherwise +
+ + + +

Usage:

+
    + 
    del_other_window = keymap[{"C-x", "4", KEY_DELETE}]
    +
+ +
+
+ + prototype:__newindex (i[, v]) +
+
+ Deep insertion. + + +

Parameters:

+
    +
  • i + non-table, or list of keys {i1, ...i_n} +
    • +
  • v + value + (optional) +
    • +
+ + + + +

Usage:

+
    + 
    function bindkey (keylist, fn) keymap[keylist] = fn end
    +
+ +
+
+

Functions

+ +
+
+ + clone (tr, nometa) +
+
+ Make a deep copy of a tree or table, including any metatables. + + +

Parameters:

+
    +
  • tr + table + tree or tree-like table +
    • +
  • nometa + boolean + if non-nil don't copy metatables +
    • +
+ +

Returns:

+
    + + prototype or table + a deep copy of tr +
+ + +

See also:

+ + +

Usage:

+
    + 
    + tr = {"one", {two=2}, {{"three"}, four=4}}
+ copy = clone (tr)
+ copy[2].two=5
+ assert (tr[2].two == 2)
    +
+ +
+
+ + ileaves (tr) +
+
+ Tree iterator which returns just numbered leaves, in order. + + +

Parameters:

+ + +

Returns:

+
    +
  1. + function + iterator function
    2. +
  2. + prototype or table + the tree tr
    3. +
+ + +

See also:

+ + +

Usage:

+
    + 
    + --> t = {"one", "three", "five"}
+ for leaf in ileaves {"one", {two=2}, {{"three"}, four=4}}, foo="bar", "five"}
+ do
+   t[#t + 1] = leaf
+ end
    +
+ +
+
+ + inodes (tr) +
+
+ Tree iterator over numbered nodes, in order.

+ +

The iterator function behaves like nodes, but only traverses the + array part of the nodes of tr, ignoring any others. + + +

Parameters:

+
    +
  • tr + prototype or table + tree or tree-like table to iterate over +
    • +
+ +

Returns:

+
    +
  1. + function + iterator function
    2. +
  2. + tree or table + the tree, tr
    3. +
+ + +

See also:

+ + + +
+
+ + leaves (t) +
+
+ Tree iterator which returns just leaves. + + +

Parameters:

+
    +
  • t + table + tree or tree-like table +
    • +
+ +

Returns:

+
    +
  1. + function + iterator function
    2. +
  2. + table + t
    3. +
+ + +

See also:

+ + +

Usage:

+
    + 
    + for leaf in leaves {"one", {two=2}, {{"three"}, four=4}}, foo="bar", "five"}
+ do
+   t[#t + 1] = leaf
+ end
+ --> t = {2, 4, "five", "foo", "one", "three"}
+ table.sort (t, lambda "=tostring(_1) < tostring(_2)")
    +
+ +
+
+ + merge (t, u) +
+
+ Destructively deep-merge one tree into another. + + +

Parameters:

+
    +
  • t + table + destination tree +
    • +
  • u + table + table with nodes to merge +
    • +
+ +

Returns:

+
    + + table + t with nodes from u merged in +
+ + +

See also:

+
    +
+ +

Usage:

+
    + 
    merge (dest, {{exists=1}, {{not = {present = { inside = "dest" }}}}})
    +
+ +
+
+ + nodes (tr) +
+
+ Tree iterator over all nodes.

+ +

The returned iterator function performs a depth-first traversal of + tr, and at each node it returns {node-type, tree-path, tree-node} + where node-type is branch, join or leaf; tree-path is a + list of keys used to reach this node, and tree-node is the current + node.

+ +

Note that the tree-path reuses the same table on each iteration, so + you must table.clone a copy if you want to take a snap-shot of the + current state of the tree-path list before the next iteration + changes it. + + +

Parameters:

+
    +
  • tr + prototype or table + tree or tree-like table to iterate over +
    • +
+ +

Returns:

+
    +
  1. + function + iterator function
    2. +
  2. + prototype or table + the tree, tr
    3. +
+ + +

See also:

+ + +

Usage:

+
    + 
    + -- tree = +-- node1
+ --        |    +-- leaf1
+ --        |    '-- leaf2
+ --        '-- leaf 3
+ tree = Tree { Tree { "leaf1", "leaf2"}, "leaf3" }
+ for node_type, path, node in nodes (tree) do
+   print (node_type, path, node)
+ end
+ --> "branch"   {}      {{"leaf1", "leaf2"}, "leaf3"}
+ --> "branch"   {1}     {"leaf1", "leaf2")
+ --> "leaf"     {1,1}   "leaf1"
+ --> "leaf"     {1,2}   "leaf2"
+ --> "join"     {1}     {"leaf1", "leaf2"}
+ --> "leaf"     {2}     "leaf3"
+ --> "join"     {}      {{"leaf1", "leaf2"}, "leaf3"}
+ os.exit (0)
    +
+ +
+
+ + +
+
+
+generated by LDoc 1.4.3 +Last updated 2016-02-06 00:10:05 +
+
+ + From d737c198197374a94e0752318cfcb2878838353f Mon Sep 17 00:00:00 2001 From: "Gary V. Vaughan" Date: Sun, 7 Feb 2016 18:25:12 +0000 Subject: [PATCH 2/3] maint: bump to v1.0 docs. Signed-off-by: Gary V. Vaughan --- index.html | 87 ++- .../std.prototype.container.html | 75 ++- modules/std.prototype.html | 152 +++++ .../std.prototype.object.html | 186 +++--- .../std.prototype.set.html | 113 ++-- .../std.prototype.strbuf.html | 120 ++-- .../std.prototype.trie.html | 151 +++-- object_system/prototype.list.html | 534 ------------------ 8 files changed, 564 insertions(+), 854 deletions(-) rename object_system/prototype.container.html => modules/std.prototype.container.html (78%) create mode 100644 modules/std.prototype.html rename object_system/prototype.object.html => modules/std.prototype.object.html (66%) rename object_system/prototype.set.html => modules/std.prototype.set.html (76%) rename object_system/prototype.strbuf.html => modules/std.prototype.strbuf.html (79%) rename object_system/prototype.tree.html => modules/std.prototype.trie.html (69%) delete mode 100644 object_system/prototype.list.html diff --git a/index.html b/index.html index 8087820..d2bbbaf 100644 --- a/index.html +++ b/index.html @@ -29,14 +29,14 @@

prototype 1.0

-

Object System

+

Modules

@@ -45,13 +45,52 @@

Object System

-

Module Oriented Programming with Lua

+

Prototype Oriented Programming with Lua

A straight forward prototype-based object system, and a selection of -useful objects built on it. +useful objects built on it.

This is a collection of light-weight libraries for Lua 5.1 (including -LuaJIT), 5.2 and 5.3 written in pure Lua, comprising:

+LuaJIT), 5.2 and 5.3 written in pure Lua.

+ +

Each of the modules in this package returns a table with an empty +prototype object in the prototype field, and often a selection of +module functions not related to a specific instance. That is, when +you require one of these modules, you get a conventional table of +functions plus an empty object of some sort:

+ + +
local object = require "std.prototype.object"
+for k, v in pairs (object) do print (k, type (v)) end
+--> prototype  table
+--> type       function
+
+ +

In this case, a module function called type which looks up the +_type field in any prototype's metatable, and an empty Object:

+ +
print (object.prototype)
+--> Object {}
+
+ +

You can instantiate additional copies of a prototype by calling it with +a table of specialised attributes:

+ +
print (object.prototype { myattribute = "my value" })
+--> Object {myattribute=my value}
+
+ +

As a convenience, calling the module itself passes the argument table +through to that module's prototype, although its faster to save an +empty instance of the prototype in a local and use that:

+ +
print (object { 1, 2, foo = "bar" })
+--> Object {1, 2; foo=bar}
+
+local Object = object.prototype
+print (Object { "Woo!" })
+--> Object {Woo!}
+

LICENSE

@@ -60,31 +99,31 @@

LICENSE

-

Object System

+

Modules

- - + + - - + + - - + + - - + + - - + + - - + +
prototype.containerContainer prototype.std.prototypeModule table.
prototype.objectObject prototype.std.prototype.containerContainer Prototype.
prototype.listList prototype.std.prototype.objectObject Prototype.
prototype.setSet container prototype.std.prototype.setSet Prototype.
prototype.strbufString buffer prototype.std.prototype.strbufStrBuf Prototype.
prototype.treeTree container prototype.std.prototype.trieTrie Prototype.
@@ -92,7 +131,7 @@

Object System

generated by LDoc 1.4.3 -Last updated 2016-02-06 00:10:05 +Last updated 2016-02-07 19:52:52
diff --git a/object_system/prototype.container.html b/modules/std.prototype.container.html similarity index 78% rename from object_system/prototype.container.html rename to modules/std.prototype.container.html index fc43748..5ce9ff4 100644 --- a/object_system/prototype.container.html +++ b/modules/std.prototype.container.html @@ -34,26 +34,26 @@

Contents

-

Object System

+

Modules

-

Module prototype.container

-

Container prototype. +

Module std.prototype.container

+

Container Prototype.

@@ -70,9 +70,9 @@

Module prototype.container

course that does not entirely preclude the use of __index with containers, so long as this limitation is observed.

-

When making your own prototypes, derive from prototype.container.prototype +

When making your own prototypes, derive from prototype.container.prototype if you want to access the contents of your containers with the [] - operator, otherwise from prototype.object.prototype if you want to access + operator, otherwise from prototype.object.prototype if you want to access the functionality of your objects with named object methods.

Prototype Chain

@@ -100,11 +100,15 @@

Metamethods

Return a clone of this container and its metatable. + prototype:__pairs () + Return an in-order iterator over public object fields. + + prototype:__tostring () Return a compact string representation of this object. -

Functions

+

Module Functions

@@ -151,7 +155,7 @@

Usage:

local Graph = Container { _type = "Graph" } localfunction nodes (graph) local n = 0 - for _ in std.pairs (graph) do n = n + 1end + for _ inpairs (graph) do n = n + 1endreturn n endlocal g = Graph { "node1", "node2" } @@ -177,7 +181,7 @@

Metamethods

being part of its actual contents. In general, cloned objects also clone the behaviour of the object they cloned, unless...

-

When calling prototype.container.prototype, you pass a single table +

When calling prototype.container.prototype, you pass a single table argument with additional fields (and values) to be merged into the clone. Any field names beginning with an underscore _ are copied to the clone's metatable, and all other fields to the cloned @@ -193,7 +197,7 @@

Metamethods

all the arguments passed when it is called/cloned (including named and unnamed fields in the initial table argument, if there is one) are passed through to the _init function, following the nascent - cloned object. See the mapfields usage example below. + cloned object. See the mapfields usage example below.

Parameters:

@@ -206,7 +210,7 @@

Parameters:

Returns:

    - prototype + prototype clone of this container, with shared or merged metatable as appropriate
@@ -220,6 +224,33 @@

Usage:

local list = Cons {"head", Cons {"tail", nil}} + +
+ + prototype:__pairs () +
+
+ Return an in-order iterator over public object fields. + + + +

Returns:

+
    +
  1. + function + iterator function
    2. +
  2. + Object + self
    3. +
+ + + +

Usage:

+
    + 
    for k, v in pairs (anobject) do process (k, v) end
    +
+
@@ -257,7 +288,7 @@

Usage:

-

Functions

+

Module Functions

@@ -268,8 +299,8 @@

Functions

Return new with references to the fields of src merged in.

This is the function used to instantiate the contents of a newly - cloned container, as called by __call above, to split the - fields of a __call argument table into private "_" prefixed + cloned container, as called by __call above, to split the + fields of a __call argument table into private "_" prefixed field namess, -- which are merged into the new metatable, and public (everything else) names, which are merged into new itself.

@@ -285,7 +316,7 @@

Parameters:

  • src table - __call argument table that triggered cloning + __call argument table that triggered cloning
  • map table @@ -330,7 +361,7 @@

    Usage:

    generated by LDoc 1.4.3 -Last updated 2016-02-06 00:10:05 +Last updated 2016-02-07 19:52:52
    diff --git a/modules/std.prototype.html b/modules/std.prototype.html new file mode 100644 index 0000000..e5f34e4 --- /dev/null +++ b/modules/std.prototype.html @@ -0,0 +1,152 @@ + + + + + prototype 1.0 Reference + + + + +
    + +
    + +
    +
    +
    + + +
    + + + + + + +
    + +

    Module std.prototype

    +

    Module table.

    +

    Lazy loading of submodules, and metadata for the Prototype package.

    + + +

    Tables

    +
    • mapfields (new, src[, map={}])
    + + + + +
    prototypeModule table.
    +

    Metamethods

    + + + + + +
    __index (name)Lazy loading of prototype modules.
    + +
    +
    + + +

    Tables

    + +
    +
    + + prototype +
    +
    + Module table. + + +

    Fields:

    +
      +
    • version + Release version string +
      • +
    + + + + + +
    +
    +

    Metamethods

    + +
    +
    + + __index (name) +
    +
    + Lazy loading of prototype modules. + Don't load everything on initial startup, wait until first attempt + to access a submodule, and then load it on demand. + + +

    Parameters:

    +
      +
    • name + string + submodule name +
      • +
    + +

    Returns:

    +
      + + table or nil + the submodule that was loaded to satisfy the missing + name, otherwise nil if nothing was found +
    + + + +

    Usage:

    +
      + 
      + local prototype = require "prototype"
+ local Object = prototype.object.prototype
      +
    + +
    +
    + + +
    + +
    +generated by LDoc 1.4.3 +Last updated 2016-02-07 19:52:52 +
    + + + diff --git a/object_system/prototype.object.html b/modules/std.prototype.object.html similarity index 66% rename from object_system/prototype.object.html rename to modules/std.prototype.object.html index 2b84e9f..937775e 100644 --- a/object_system/prototype.object.html +++ b/modules/std.prototype.object.html @@ -32,39 +32,39 @@

    prototype 1.0

    Contents

    -

    Object System

    +

    Modules

    -

    Module prototype.object

    -

    Object prototype. +

    Module std.prototype.object

    +

    Object Prototype.

    -

    This module provides a specialization of the prototype.container.prototype +

    This module provides a specialization of the prototype.container.prototype with the addition of object methods. In addition to the functionality described here, object prototypes also have all the methods and - metamethods of the prototype.container.prototype.

    + metamethods of the prototype.container.prototype.

    Note that object methods are stored in the __index field of their metatable, and so cannot also use the __index metamethod to lookup - references with square brackets. Use a prototype.container.prototype based + references with square brackets. Use a prototype.container.prototype based object if you want to do that.

    Prototype Chain

    @@ -79,11 +79,18 @@

    Prototype Chain

    -

    Metamethods

    +

    Objects

    - - + + + +
    prototype:__pairs ()Return an in-order iterator over public object fields.prototypeObject prototype.
    +

    Module Functions

    + + + +
    type (x)Type of an object.

    Methods

    @@ -92,50 +99,103 @@

    Methods

    prototype:clone (...) Return a clone of this object and its metatable. - -

    Object Functions

    - - - - -
    prototype.mapfields (new, src[, map={}]) Return new with references to the fields of src merged in.
    prototypeObject prototype.


    -

    Metamethods

    +

    Objects

    - - prototype:__pairs () + + prototype
    - Return an in-order iterator over public object fields. + Object prototype. + + +

    Fields:

    +
      +
    • _init + table or function + object initialisation + (optional) +
      • +
    • _type + string + object name + (default "Object") +
      • +
    + + + + +

    Usage:

    +
      + 
      + local Object = require "std.prototype.object".prototype
+ local Process = Object {
+   _type = "Process",
+   _init = { "status", "out", "err" },
+ }
+ local process = Process {
+   procs[pid].status, procs[pid].out, procs[pid].err, -- auto assigned
+   command = pipeline[pid],                           -- manual assignment
+ }
      +
    +
    +
    +

    Module Functions

    +
    +
    + + type (x) +
    +
    + Type of an object.

    + +

    It's conventional to organise similar objects according to a string + valued _type field, which can then be queried using this + function. + + +

    Parameters:

    +
      +
    • x + an object +
      • +

    Returns:

      -
    1. - function - iterator function
      2. -
    2. - Object - self
      3. + + string + type of x, or nil if x has no _type + metatable entry.

    Usage:

      - 
      for k, v in prototype.pairs (anobject) do process (k, v) end
      + 
      +   local Object = require "std.object".prototype
+   assert (object.type (Object) == "Object")
+   local Stack = Object {
+     _type = "Stack",
+     ...
+   }
+   local stack = Stack {"some stuff"}
+   assert (object.type (stack) == getmetatable (stack)._type)
    @@ -165,7 +225,7 @@

    Parameters:

    Returns:

      - prototype + prototype a clone of this object, with shared or merged metatable as appropriate
    @@ -173,7 +233,7 @@

    Returns:

    See also:

    Usage:

    @@ -190,10 +250,6 @@

    Usage:

    -
    -

    Object Functions

    - -
    prototype.mapfields (new, src[, map={}]) @@ -203,7 +259,7 @@

    Object Functions

    You can change the value of this function in an object, and that new function will be called during cloning instead of the - standard prototype.container.mapfields implementation. + standard prototype.container.mapfields implementation.

    Parameters:

    @@ -214,7 +270,7 @@

    Parameters:

  • src table - clone argument table that triggered cloning + clone argument table that triggered cloning
  • map table @@ -236,50 +292,10 @@

    Returns:

    See also:

    - -
    - - prototype -
    -
    - Object prototype. - - -

    Fields:

    -
      -
    • _init - table or function - object initialisation - (optional) -
      • -
    • _type - string - object name - (default "Object") -
      • -
    - - - - -

    Usage:

    -
      - 
      - local Object = require "prototype.object".prototype
- local Process = Object {
-   _type = "Process",
-   _init = { "status", "out", "err" },
- }
- local process = Process {
-   procs[pid].status, procs[pid].out, procs[pid].err, -- auto assigned
-   command = pipeline[pid],                           -- manual assignment
- }
      -
    -
    • @@ -288,7 +304,7 @@

    Usage:

    generated by LDoc 1.4.3 -Last updated 2016-02-06 00:10:05 +Last updated 2016-02-07 19:52:52
    diff --git a/object_system/prototype.set.html b/modules/std.prototype.set.html similarity index 76% rename from object_system/prototype.set.html rename to modules/std.prototype.set.html index 02092d6..cddc354 100644 --- a/object_system/prototype.set.html +++ b/modules/std.prototype.set.html @@ -35,26 +35,26 @@

    Contents

  • Objects
  • Initialisation
  • Metamethods
    • -
  • Functions
    • +
  • Module Functions
    • -

    Object System

    +

    Modules

    -

    Module prototype.set

    -

    Set container prototype. +

    Module std.prototype.set

    +

    Set Prototype.

    @@ -65,7 +65,7 @@

    Module prototype.set

    container exactly zero or one times.

    In addition to the functionality described here, Set containers also - have all the methods and metamethods of the prototype.container.prototype + have all the methods and metamethods of the prototype.container.prototype (except where overridden here).

    Prototype Chain

    @@ -125,7 +125,7 @@

    Metamethods

    Return a string representation of this set. -

    Functions

    +

    Module Functions

    @@ -201,13 +201,13 @@

    Fields:

    See also:

    Usage:

      - local Set = require "prototype.set".prototype
+ local Set = require "std.prototype.set".prototype
  assert (prototype.type (Set) == "Set")
    @@ -259,7 +259,7 @@

    Metamethods

    Parameters:

    @@ -267,14 +267,14 @@

    Parameters:

    Returns:

      - prototype + prototype everything from this set plus everything from s

    See also:

    Usage:

    @@ -294,7 +294,7 @@

    Usage:

    Parameters:

    @@ -302,14 +302,14 @@

    Parameters:

    Returns:

      - prototype + prototype everything from this set that is not also in s

    See also:

    Usage:

    @@ -329,7 +329,7 @@

    Usage:

    Parameters:

    @@ -337,14 +337,14 @@

    Parameters:

    Returns:

      - prototype + prototype anything in both this set and in s

    See also:

    Usage:

    @@ -364,7 +364,7 @@

    Usage:

    Parameters:

    @@ -372,14 +372,14 @@

    Parameters:

    Returns:

      - prototype + prototype everything in this set or in s but not in both

    See also:

    Usage:

    @@ -399,7 +399,7 @@

    Usage:

    Parameters:

    @@ -414,7 +414,7 @@

    Returns:

    See also:

    Usage:

    @@ -434,7 +434,7 @@

    Usage:

    Parameters:

    @@ -450,7 +450,7 @@

    Returns:

    See also:

    Usage:

    @@ -478,12 +478,13 @@

    Returns:

    See also:

    -

    Functions

    +

    Module Functions

    @@ -497,7 +498,7 @@

    Functions

    Parameters:

    delete (set, e)
    + + + + +
    prototypeStrBuf prototype object.

    Metamethods

    @@ -104,16 +112,53 @@

    Methods

    - - - -
    prototype:concat (x) Add a object to a buffer.
    prototypeStrBuf prototype object.


    +

    Objects

    + +
    +
    + + prototype +
    +
    + StrBuf prototype object. + + +

    Fields:

    +
      +
    • _type + string + object name + (default "StrBuf") +
      • +
    + + + +

    See also:

    + + +

    Usage:

    +
      + 
      + local StrBuf = require "std.prototype.strbuf".prototype
+ local a = StrBuf {1, 2, 3}
+ local b = StrBuf {a, "five", "six"}
+ a = a .. 4
+ b = b:concat "seven"
+ print (a, b) --> 1234   1234fivesixseven
+ os.exit (0)
      +
    + +
    +

    Metamethods

    @@ -135,14 +180,14 @@

    Parameters:

    Returns:

      - prototype + prototype modified buf

    See also:

    Usage:

    @@ -204,7 +249,7 @@

    Parameters:

    Returns:

      - prototype + prototype modified buffer
    @@ -215,43 +260,6 @@

    Usage:

    c = StrBuf {} :concat "append this" :concat (StrBuf {" and", " this"})
    - -
    - - prototype -
    -
    - StrBuf prototype object. - - -

    Fields:

    -
      -
    • _type - string - object name - (default "StrBuf") -
      • -
    - - - -

    See also:

    - - -

    Usage:

    -
      - 
      - local StrBuf = require "prototype.strbuf".prototype
- local a = StrBuf {1, 2, 3}
- local b = StrBuf {a, "five", "six"}
- a = a .. 4
- b = b:concat "seven"
- print (a, b) --> 1234   1234fivesixseven
- os.exit (0)
      -
    -
    @@ -260,7 +268,7 @@

    Usage:

    generated by LDoc 1.4.3 -Last updated 2016-02-06 00:10:05 +Last updated 2016-02-07 19:52:52
    diff --git a/object_system/prototype.tree.html b/modules/std.prototype.trie.html similarity index 69% rename from object_system/prototype.tree.html rename to modules/std.prototype.trie.html index 5f13ea5..577f270 100644 --- a/object_system/prototype.tree.html +++ b/modules/std.prototype.trie.html @@ -34,39 +34,39 @@

    Contents

    -

    Object System

    +

    Modules

    -

    Module prototype.tree

    -

    Tree container prototype. +

    Module std.prototype.trie

    +

    Trie Prototype.

    -

    This module returns a table of tree operators, as well as the prototype - for a Tree container object.

    +

    This module returns a table of trie operators, as well as the prototype + for a Trie container object.

    -

    This is not a search tree, but rather a way to efficiently store and - retrieve values stored with a path as a key, such as a multi-key - keytable. Although it does have iterators for walking the tree with +

    This is not a search tree, but rather a radix tree to efficiently store + and retrieve values stored with a path as a key, such as a multi-key + keytable. Although it does have iterators for walking the trie with various algorithms.

    -

    In addition to the functionality described here, Tree containers also - have all the methods and metamethods of the prototype.container.prototype +

    In addition to the functionality described here, Trie containers also + have all the methods and metamethods of the prototype.container.prototype (except where overridden here),

    Prototype Chain

    @@ -75,7 +75,7 @@

    Prototype Chain

     table
  `-> Container
-      `-> Tree
+      `-> Trie

    @@ -85,7 +85,7 @@

    Objects

    - +
    prototypeTree prototype object.Trie prototype object.

    Metamethods

    @@ -99,31 +99,31 @@

    Metamethods

    Deep insertion. -

    Functions

    +

    Module Functions

    - + - + - + - + - + - +
    clone (tr, nometa)Make a deep copy of a tree or table, including any metatables.Make a deep copy of a trie or table, including any metatables.
    ileaves (tr)Tree iterator which returns just numbered leaves, in order.Trie iterator which returns just numbered leaves, in order.
    inodes (tr)Tree iterator over numbered nodes, in order.Trie iterator over numbered nodes, in order.
    leaves (t)Tree iterator which returns just leaves.Trie iterator which returns just leaves.
    merge (t, u)Destructively deep-merge one tree into another.Destructively deep-merge one trie into another.
    nodes (tr)Tree iterator over all nodes.Trie iterator over all nodes.
    @@ -139,7 +139,7 @@

    Objects

    prototype
    - Tree prototype object. + Trie prototype object.

    Fields:

    @@ -147,7 +147,7 @@

    Fields:

  • _type string object name - (default "Tree") + (default "Trie")
    • @@ -155,23 +155,23 @@

    Fields:

    See also:

    Usage:

      - local tree = require "prototype.tree"
- local Tree = tree.prototype
- local tr = Tree {}
+ local trie = require "std.prototype.trie"
+ local Trie = trie.prototype
+ local tr = Trie {}
  tr[{"branch1", 1}] = "leaf1"
  tr[{"branch1", 2}] = "leaf2"
  tr[{"branch2", 1}] = "leaf3"
- print (tr[{"branch1"}])      --> Tree {leaf1, leaf2}
+ print (tr[{"branch1"}])      --> Trie {leaf1, leaf2}
  print (tr[{"branch1", 2}])   --> leaf2
  print (tr[{"branch1", 3}])   --> nil
  --> leaf1	leaf2	leaf3
- for leaf in tree.leaves (tr) do
+ for leaf in trie.leaves (tr) do
    io.write (leaf .. "\t")
  end
    @@ -239,7 +239,7 @@

    Usage:

    -

    Functions

    +

    Module Functions

    @@ -247,14 +247,14 @@

    Functions

    clone (tr, nometa)
    - Make a deep copy of a tree or table, including any metatables. + Make a deep copy of a trie or table, including any metatables.

    Parameters:

    • tr table - tree or tree-like table + trie or trie-like table
    • nometa boolean @@ -265,14 +265,14 @@

      Parameters:

      Returns:

        - prototype or table + prototype or table a deep copy of tr

      See also:

      Usage:

      @@ -290,14 +290,14 @@

      Usage:

      ileaves (tr)
      - Tree iterator which returns just numbered leaves, in order. + Trie iterator which returns just numbered leaves, in order.

      Parameters:

      @@ -307,15 +307,15 @@

      Returns:

      function iterator function
    • - prototype or table - the tree tr
      • + prototype or table + the trie tr

      See also:

      Usage:

      @@ -334,17 +334,17 @@

      Usage:

      inodes (tr)
      - Tree iterator over numbered nodes, in order.

      + Trie iterator over numbered nodes, in order.

      -

      The iterator function behaves like nodes, but only traverses the +

      The iterator function behaves like nodes, but only traverses the array part of the nodes of tr, ignoring any others.

      Parameters:

      @@ -354,14 +354,14 @@

      Returns:

      function iterator function
    • - tree or table - the tree, tr
      • + trie or table + the trie, tr

      See also:

      @@ -371,14 +371,14 @@

      See also:

      leaves (t)
      - Tree iterator which returns just leaves. + Trie iterator which returns just leaves.

      Parameters:

      • t table - tree or tree-like table + trie or trie-like table
      @@ -395,8 +395,8 @@

      Returns:

      See also:

      Usage:

      @@ -416,14 +416,14 @@

      Usage:

      merge (t, u)
      - Destructively deep-merge one tree into another. + Destructively deep-merge one trie into another.

      Parameters:

      • t table - destination tree + destination trie
      • u table @@ -439,9 +439,6 @@

        Returns:

        -

        See also:

        -
          -

        Usage:

          @@ -454,25 +451,25 @@

          Usage:

          nodes (tr)
          - Tree iterator over all nodes.

          + Trie iterator over all nodes.

          The returned iterator function performs a depth-first traversal of - tr, and at each node it returns {node-type, tree-path, tree-node} - where node-type is branch, join or leaf; tree-path is a - list of keys used to reach this node, and tree-node is the current + tr, and at each node it returns {node-type, trie-path, trie-node} + where node-type is branch, join or leaf; trie-path is a + list of keys used to reach this node, and trie-node is the current node.

          -

          Note that the tree-path reuses the same table on each iteration, so +

          Note that the trie-path reuses the same table on each iteration, so you must table.clone a copy if you want to take a snap-shot of the - current state of the tree-path list before the next iteration + current state of the trie-path list before the next iteration changes it.

          Parameters:

          @@ -482,25 +479,25 @@

          Returns:

          function iterator function
        • - prototype or table - the tree, tr
          • + prototype or table + the trie, tr

          See also:

          Usage:

            - -- tree = +-- node1
+ -- trie = +-- node1
  --        |    +-- leaf1
  --        |    '-- leaf2
  --        '-- leaf 3
- tree = Tree { Tree { "leaf1", "leaf2"}, "leaf3" }
- for node_type, path, node in nodes (tree) do
+ trie = Trie { Trie { "leaf1", "leaf2"}, "leaf3" }
+ for node_type, path, node in nodes (trie) do
    print (node_type, path, node)
  end
  --> "branch"   {}      {{"leaf1", "leaf2"}, "leaf3"}
@@ -521,7 +518,7 @@ 
            Usage:
    generated by LDoc 1.4.3 -Last updated 2016-02-06 00:10:05 +Last updated 2016-02-07 19:52:52
    diff --git a/object_system/prototype.list.html b/object_system/prototype.list.html deleted file mode 100644 index 2439686..0000000 --- a/object_system/prototype.list.html +++ /dev/null @@ -1,534 +0,0 @@ - - - - - prototype 1.0 Reference - - - - -
    - -
    - -
    -
    -
    - - -
    - - - - - - -
    - -

    Module prototype.list

    -

    List prototype. -

    - - -

    In addition to the functionality described here, List objects also - have all the methods and metamethods of the prototype.object.prototype - (except where overridden here),

    - -

    Prototype Chain

    - - -
    -table
- `-> Container
-      `-> Object
-           `-> List
-
    - -

    - - -

    Metamethods

    - - - - - - - - - - - - - - - - - -
    prototype:__concat (m)Concatenate lists.
    prototype:__add (e)Append element to list.
    prototype:__lt (m)List order operator.
    prototype:__le (m)List equality or order operator.
    -

    Methods

    - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - -
    prototype:append (x)Append an item to a list.
    prototype:compare (m)Compare two lists element-by-element, from left-to-right.
    prototype:concat (...)Concatenate the elements from any number of lists.
    prototype:cons (x)Prepend an item to a list.
    prototype:rep (n)Repeat a list.
    prototype:sub ([from=1[, to=#l]])Return a sub-range of a list.
    prototype:tail ()Return a list with its first element removed.
    prototypeList prototype object.
    - -
    -
    - - -

    Metamethods

    - -
    -
    - - prototype:__concat (m) -
    -
    - Concatenate lists. - - -

    Parameters:

    -
      -
    • m - prototype or table - another list, or table (hash part is ignored) -
      • -
    - - - -

    See also:

    - - -

    Usage:

    -
      - 
      new = alist .. {"append", "these", "elements"}
      -
    - -
    -
    - - prototype:__add (e) -
    -
    - Append element to list. - - -

    Parameters:

    -
      -
    • e - element to append -
      • -
    - - - -

    See also:

    - - -

    Usage:

    -
      - 
      list = list + "element"
      -
    - -
    -
    - - prototype:__lt (m) -
    -
    - List order operator. - - -

    Parameters:

    - - - - -

    See also:

    - - -

    Usage:

    -
      - 
      max = list1 > list2 and list1 or list2
      -
    - -
    -
    - - prototype:__le (m) -
    -
    - List equality or order operator. - - -

    Parameters:

    - - - - -

    See also:

    - - -

    Usage:

    -
      - 
      min = list1 <= list2 and list1 or list2
      -
    - -
    -
    -

    Methods

    - -
    -
    - - prototype:append (x) -
    -
    - Append an item to a list. - - -

    Parameters:

    -
      -
    • x - item -
      • -
    - -

    Returns:

    -
      - - prototype - new list with x appended -
    - - - -

    Usage:

    -
      - 
      - --> List {"shorter", "longer"}
- longer = (List {"shorter"}):append "longer"
      -
    - -
    -
    - - prototype:compare (m) -
    -
    - Compare two lists element-by-element, from left-to-right. - - -

    Parameters:

    - - -

    Returns:

    -
      - - -1 if l is less than m, 0 if they are the same, and 1 - if l is greater than m -
    - - - -

    Usage:

    -
      - 
      if list1:compare (list2) == 0 then print "same" end
      -
    - -
    -
    - - prototype:concat (...) -
    -
    - Concatenate the elements from any number of lists. - - -

    Parameters:

    -
      -
    • ... - prototype or table - additional lists, or list-like tables -
      • -
    - -

    Returns:

    -
      - - prototype - new list with elements from arguments -
    - - - -

    Usage:

    -
      - 
      - --> List {"shorter", "short", "longer", "longest"}
- longest = (List {"shorter"}):concat ({"short", "longer"}, {"longest"})
      -
    - -
    -
    - - prototype:cons (x) -
    -
    - Prepend an item to a list. - - -

    Parameters:

    -
      -
    • x - item -
      • -
    - -

    Returns:

    -
      - - prototype - new list with x followed by elements of l -
    - - - -

    Usage:

    -
      - 
      - --> List {"x", 1, 2, 3}
- consed = (List {1, 2, 3}):cons "x"
      -
    - -
    -
    - - prototype:rep (n) -
    -
    - Repeat a list. - - -

    Parameters:

    -
      -
    • n - int - number of times to repeat -
      • -
    - -

    Returns:

    -
      - - prototype - n copies of l appended together -
    - - - -

    Usage:

    -
      - 
      - --> List {1, 2, 3, 1, 2, 3, 1, 2, 3}
- repped = (List {1, 2, 3}):rep (3)
      -
    - -
    -
    - - prototype:sub ([from=1[, to=#l]]) -
    -
    - Return a sub-range of a list. - (The equivalent of string.sub on strings; negative list indices - count from the end of the list.) - - -

    Parameters:

    -
      -
    • from - int - start of range - (default 1) -
      • -
    • to - int - end of range - (default #l) -
      • -
    - -

    Returns:

    -
      - - prototype - new list containing elements between from and to - inclusive -
    - - - -

    Usage:

    -
      - 
      - --> List {3, 4, 5}
- subbed = (List {1, 2, 3, 4, 5, 6}):sub (3, 5)
      -
    - -
    -
    - - prototype:tail () -
    -
    - Return a list with its first element removed. - - - -

    Returns:

    -
      - - prototype - new list with all but the first element of l -
    - - - -

    Usage:

    -
      - 
      - --> List {3, {4, 5}, 6, 7}
- tailed = (List {{1, 2}, 3, {4, 5}, 6, 7}):tail ()
      -
    - -
    -
    - - prototype -
    -
    - List prototype object. - - -

    Fields:

    -
      -
    • _init - table or function - object initialisation - (optional) -
      • -
    • _type - string - object name - (default "List") -
      • -
    - - - -

    See also:

    - - -

    Usage:

    -
      - 
      - local List = require "prototype.list".prototype
- assert (prototype.type (List) == "List")
      -
    - -
    -
    - - -
    -
    -
    -generated by LDoc 1.4.3 -Last updated 2016-02-06 00:10:05 -
    -
    - - From 5188260c465a9168a819b344c9789cf2d08ce566 Mon Sep 17 00:00:00 2001 From: "Gary V. Vaughan" Date: Mon, 8 Feb 2016 00:33:13 +0000 Subject: [PATCH 3/3] update docs for release 1.0.1 --- index.html | 6 +++--- modules/std.prototype.container.html | 6 +++--- modules/std.prototype.html | 6 +++--- modules/std.prototype.object.html | 6 +++--- modules/std.prototype.set.html | 6 +++--- modules/std.prototype.strbuf.html | 6 +++--- modules/std.prototype.trie.html | 6 +++--- 7 files changed, 21 insertions(+), 21 deletions(-) diff --git a/index.html b/index.html index d2bbbaf..bf7ea27 100644 --- a/index.html +++ b/index.html @@ -3,7 +3,7 @@ - prototype 1.0 Reference + std.prototype 1.0.1 Reference @@ -24,7 +24,7 @@
    generated by LDoc 1.4.3 -Last updated 2016-02-07 19:52:52 +Last updated 2016-02-08 00:31:49
    diff --git a/modules/std.prototype.container.html b/modules/std.prototype.container.html index 5ce9ff4..0db69ae 100644 --- a/modules/std.prototype.container.html +++ b/modules/std.prototype.container.html @@ -3,7 +3,7 @@ - prototype 1.0 Reference + std.prototype 1.0.1 Reference @@ -24,7 +24,7 @@
    generated by LDoc 1.4.3 -Last updated 2016-02-07 19:52:52 +Last updated 2016-02-08 00:31:49
    diff --git a/modules/std.prototype.html b/modules/std.prototype.html index e5f34e4..11be839 100644 --- a/modules/std.prototype.html +++ b/modules/std.prototype.html @@ -3,7 +3,7 @@ - prototype 1.0 Reference + std.prototype 1.0.1 Reference @@ -24,7 +24,7 @@
    generated by LDoc 1.4.3 -Last updated 2016-02-07 19:52:52 +Last updated 2016-02-08 00:31:49
    diff --git a/modules/std.prototype.object.html b/modules/std.prototype.object.html index 937775e..cb5e796 100644 --- a/modules/std.prototype.object.html +++ b/modules/std.prototype.object.html @@ -3,7 +3,7 @@ - prototype 1.0 Reference + std.prototype 1.0.1 Reference @@ -24,7 +24,7 @@
    generated by LDoc 1.4.3 -Last updated 2016-02-07 19:52:52 +Last updated 2016-02-08 00:31:49
    diff --git a/modules/std.prototype.set.html b/modules/std.prototype.set.html index cddc354..dbbee23 100644 --- a/modules/std.prototype.set.html +++ b/modules/std.prototype.set.html @@ -3,7 +3,7 @@ - prototype 1.0 Reference + std.prototype 1.0.1 Reference @@ -24,7 +24,7 @@
    generated by LDoc 1.4.3 -Last updated 2016-02-07 19:52:52 +Last updated 2016-02-08 00:31:49
    diff --git a/modules/std.prototype.strbuf.html b/modules/std.prototype.strbuf.html index c140c6e..1a5af5e 100644 --- a/modules/std.prototype.strbuf.html +++ b/modules/std.prototype.strbuf.html @@ -3,7 +3,7 @@ - prototype 1.0 Reference + std.prototype 1.0.1 Reference @@ -24,7 +24,7 @@
    generated by LDoc 1.4.3 -Last updated 2016-02-07 19:52:52 +Last updated 2016-02-08 00:31:49
    diff --git a/modules/std.prototype.trie.html b/modules/std.prototype.trie.html index 577f270..61ea3f4 100644 --- a/modules/std.prototype.trie.html +++ b/modules/std.prototype.trie.html @@ -3,7 +3,7 @@ - prototype 1.0 Reference + std.prototype 1.0.1 Reference @@ -24,7 +24,7 @@
    generated by LDoc 1.4.3 -Last updated 2016-02-07 19:52:52 +Last updated 2016-02-08 00:31:49