diff options
Diffstat (limited to 'doc')
| -rw-r--r-- | doc/advopt.txt | 3 | ||||
| -rw-r--r-- | doc/basicopt.txt | 1 | ||||
| -rw-r--r-- | doc/lib.rst | 7 | ||||
| -rw-r--r-- | doc/manual/generics.txt | 54 | ||||
| -rw-r--r-- | doc/manual/pragmas.txt | 8 | ||||
| -rw-r--r-- | doc/manual/type_sections.txt | 3 | ||||
| -rw-r--r-- | doc/tut1.rst | 3 | ||||
| -rw-r--r-- | doc/tut2.rst | 17 |
8 files changed, 56 insertions, 40 deletions
diff --git a/doc/advopt.txt b/doc/advopt.txt index fb6fd719b..60fd081b8 100644 --- a/doc/advopt.txt +++ b/doc/advopt.txt @@ -7,7 +7,8 @@ Advanced commands: //rst2html convert a reStructuredText file to HTML //rst2tex convert a reStructuredText file to TeX //jsondoc extract the documentation to a json file - //jsondoc2 extract documentation to a json file (uses doc2) + //jsondoc2 extract the documentation to a json file (uses doc2) + //ctags create a tags file //buildIndex build an index for the whole documentation //run run the project (with Tiny C backend; buggy!) //genDepend generate a DOT file containing the diff --git a/doc/basicopt.txt b/doc/basicopt.txt index 3b0271077..4db2d5af7 100644 --- a/doc/basicopt.txt +++ b/doc/basicopt.txt @@ -5,7 +5,6 @@ Command: //compile, c compile project with default code generator (C) //doc generate the documentation for inputfile - //doc2 generate the documentation for inputfile Arguments: arguments are passed to the program being run (if --run option is selected) diff --git a/doc/lib.rst b/doc/lib.rst index 069fcc87c..6dd3f5bea 100644 --- a/doc/lib.rst +++ b/doc/lib.rst @@ -64,7 +64,6 @@ Core * `cpuinfo <cpuinfo.html>`_ This module implements procs to determine the number of CPUs / cores. - Collections and algorithms -------------------------- @@ -182,6 +181,12 @@ Generic Operating System Services This module implements asynchronous file reading and writing using ``asyncdispatch``. +* `distros <distros.html>`_ + This module implements the basics for OS distribution ("distro") detection and the OS's native package manager. + Its primary purpose is to produce output for Nimble packages, but it also contains the widely used **Distribution** enum + that is useful for writing platform specific code. + + Math libraries -------------- diff --git a/doc/manual/generics.txt b/doc/manual/generics.txt index cceea33c0..1ba62bb5c 100644 --- a/doc/manual/generics.txt +++ b/doc/manual/generics.txt @@ -9,26 +9,26 @@ The following example shows a generic binary tree can be modelled: .. code-block:: nim type - BinaryTreeObj[T] = object # BinaryTreeObj is a generic type with - # with generic param ``T`` - le, ri: BinaryTree[T] # left and right subtrees; may be nil - data: T # the data stored in a node - BinaryTree[T] = ref BinaryTreeObj[T] # a shorthand for notational convenience + BinaryTree*[T] = ref object # BinaryTree is a generic type with + # generic param ``T`` + le, ri: BinaryTree[T] # left and right subtrees; may be nil + data: T # the data stored in a node - proc newNode[T](data: T): BinaryTree[T] = # constructor for a node + proc newNode*[T](data: T): BinaryTree[T] = + # constructor for a node new(result) result.data = data - proc add[T](root: var BinaryTree[T], n: BinaryTree[T]) = + proc add*[T](root: var BinaryTree[T], n: BinaryTree[T]) = + # insert a node into the tree if root == nil: root = n else: var it = root while it != nil: - var c = cmp(it.data, n.data) # compare the data items; uses - # the generic ``cmp`` proc that works for - # any type that has a ``==`` and ``<`` - # operator + # compare the data items; uses the generic ``cmp`` proc + # that works for any type that has a ``==`` and ``<`` operator + var c = cmp(it.data, n.data) if c < 0: if it.le == nil: it.le = n @@ -40,20 +40,28 @@ The following example shows a generic binary tree can be modelled: return it = it.ri - iterator inorder[T](root: BinaryTree[T]): T = - # inorder traversal of a binary tree - # recursive iterators are not yet implemented, so this does not work in - # the current compiler! - if root.le != nil: yield inorder(root.le) - yield root.data - if root.ri != nil: yield inorder(root.ri) + proc add*[T](root: var BinaryTree[T], data: T) = + # convenience proc: + add(root, newNode(data)) + + iterator preorder*[T](root: BinaryTree[T]): T = + # Preorder traversal of a binary tree. + # Since recursive iterators are not yet implemented, + # this uses an explicit stack (which is more efficient anyway): + var stack: seq[BinaryTree[T]] = @[root] + while stack.len > 0: + var n = stack.pop() + while n != nil: + yield n.data + add(stack, n.ri) # push right subtree onto the stack + n = n.le # and follow the left pointer var - root: BinaryTree[string] # instantiate a BinaryTree with the type string - add(root, newNode("hallo")) # instantiates generic procs ``newNode`` and - add(root, newNode("world")) # ``add`` - for str in inorder(root): - writeLine(stdout, str) + root: BinaryTree[string] # instantiate a BinaryTree with ``string`` + add(root, newNode("hello")) # instantiates ``newNode`` and ``add`` + add(root, "world") # instantiates the second ``add`` proc + for str in preorder(root): + stdout.writeLine(str) Is operator diff --git a/doc/manual/pragmas.txt b/doc/manual/pragmas.txt index db7ce7e63..835b6909d 100644 --- a/doc/manual/pragmas.txt +++ b/doc/manual/pragmas.txt @@ -102,6 +102,14 @@ collector to not consider objects of this type as part of a cycle: left, right: Node data: string +Or if we directly use a ref object: + +.. code-block:: nim + type + Node = ref object {.acyclic, final.} + left, right: Node + data: string + In the example a tree structure is declared with the ``Node`` type. Note that the type definition is recursive and the GC has to assume that objects of this type may form a cyclic graph. The ``acyclic`` pragma passes the diff --git a/doc/manual/type_sections.txt b/doc/manual/type_sections.txt index af761c77e..12b2a11ac 100644 --- a/doc/manual/type_sections.txt +++ b/doc/manual/type_sections.txt @@ -5,8 +5,7 @@ Example: .. code-block:: nim type # example demonstrating mutually recursive types - Node = ref NodeObj # a traced pointer to a NodeObj - NodeObj = object + Node = ref object # an object managed by the garbage collector (ref) le, ri: Node # left and right subtrees sym: ref Sym # leaves contain a reference to a Sym diff --git a/doc/tut1.rst b/doc/tut1.rst index be5cd8c11..6731efde9 100644 --- a/doc/tut1.rst +++ b/doc/tut1.rst @@ -1511,8 +1511,7 @@ operators perform implicit dereferencing operations for reference types: .. code-block:: nim type - Node = ref NodeObj - NodeObj = object + Node = ref object le, ri: Node data: int var diff --git a/doc/tut2.rst b/doc/tut2.rst index 0bb4c94e1..0636c4ed6 100644 --- a/doc/tut2.rst +++ b/doc/tut2.rst @@ -104,15 +104,14 @@ Example: .. code-block:: nim type - Node = ref NodeObj # a traced reference to a NodeObj - NodeObj = object + Node = ref object # a reference to an object with the following field: le, ri: Node # left and right subtrees sym: ref Sym # leaves contain a reference to a Sym Sym = object # a symbol name: string # the symbol's name line: int # the line the symbol was declared in - code: Node # the symbol's abstract syntax tree + code: Node # the symbol's abstract syntax tree Type conversions @@ -155,8 +154,7 @@ An example: nkAdd, # an addition nkSub, # a subtraction nkIf # an if statement - Node = ref NodeObj - NodeObj = object + Node = ref object case kind: NodeKind # the ``kind`` field is the discriminator of nkInt: intVal: int of nkFloat: floatVal: float @@ -482,11 +480,10 @@ containers: .. code-block:: nim type - BinaryTreeObj[T] = object # BinaryTree is a generic type with - # with generic param ``T`` - le, ri: BinaryTree[T] # left and right subtrees; may be nil - data: T # the data stored in a node - BinaryTree*[T] = ref BinaryTreeObj[T] # type that is exported + BinaryTree*[T] = ref object # BinaryTree is a generic type with + # generic param ``T`` + le, ri: BinaryTree[T] # left and right subtrees; may be nil + data: T # the data stored in a node proc newNode*[T](data: T): BinaryTree[T] = # constructor for a node |