jyapayne/Nim
1
0
Fork 0
Code Issues Pull requests Projects Releases Packages Wiki Activity Actions

Merge pull request #2792 from apense/patch-1

Browse source 
Corrected various links within documentation
This commit is contained in:
Dominik Picheta 2015-05-25 10:57:00 +01:00
commit 71561bef58
3 changed files with 6 additions and 6 deletions
Download patch file Download diff file Expand all files Collapse all files

6
doc/manual/stmts.txt
View file

@ -176,9 +176,9 @@ The rules for compile-time computability are:
1. Literals are compile-time computable. 1. Literals are compile-time computable.
2. Type conversions are compile-time computable. 2. Type conversions are compile-time computable.
3. Procedure calls of the form ``p(X)`` are compile-time computable if 3. Procedure calls of the form ``p(X)`` are compile-time computable if
``p`` is a proc without side-effects (see the `noSideEffect pragma`_ ``p`` is a proc without side-effects (see the `noSideEffect pragma
for details) and if ``X`` is a (possibly empty) list of compile-time <#pragmas-nosideeffect-pragma>`_ for details) and if ``X`` is a
computable arguments. (possibly empty) list of compile-time computable arguments.
Constants cannot be of type ``ptr``, ``ref``, ``var`` or ``object``, nor can Constants cannot be of type ``ptr``, ``ref``, ``var`` or ``object``, nor can

2
doc/manual/types.txt
View file

@ -963,7 +963,7 @@ Most calling conventions exist only for the Windows 32-bit platform.
Assigning/passing a procedure to a procedural variable is only allowed if one Assigning/passing a procedure to a procedural variable is only allowed if one
of the following conditions hold: of the following conditions hold:
1) The procedure that is accessed resides in the current module. 1) The procedure that is accessed resides in the current module.
2) The procedure is marked with the ``procvar`` pragma (see `procvar pragma`_). 2) The procedure is marked with the ``procvar`` pragma (see `procvar pragma <#pragmas-procvar-pragma>`_).
3) The procedure has a calling convention that differs from ``nimcall``. 3) The procedure has a calling convention that differs from ``nimcall``.
4) The procedure is anonymous. 4) The procedure is anonymous.

4
lib/system.nim
View file

@ -2248,14 +2248,14 @@ proc echo*(x: varargs[expr, `$`]) {.magic: "Echo", tags: [WriteIOEffect],
## Unlike other IO operations this is guaranteed to be thread-safe as ## Unlike other IO operations this is guaranteed to be thread-safe as
## ``echo`` is very often used for debugging convenience. If you want to use ## ``echo`` is very often used for debugging convenience. If you want to use
## ``echo`` inside a `proc without side effects ## ``echo`` inside a `proc without side effects
## <manual.html#nosideeffect-pragma>`_ you can use `debugEcho <#debugEcho>`_ ## <manual.html#pragmas-nosideeffect-pragma>`_ you can use `debugEcho <#debugEcho>`_
## instead. ## instead.
proc debugEcho*(x: varargs[expr, `$`]) {.magic: "Echo", noSideEffect, proc debugEcho*(x: varargs[expr, `$`]) {.magic: "Echo", noSideEffect,
tags: [], raises: [].} tags: [], raises: [].}
## Same as `echo <#echo>`_, but as a special semantic rule, ``debugEcho`` ## Same as `echo <#echo>`_, but as a special semantic rule, ``debugEcho``
## pretends to be free of side effects, so that it can be used for debugging ## pretends to be free of side effects, so that it can be used for debugging
## routines marked as `noSideEffect <manual.html#nosideeffect-pragma>`_. ## routines marked as `noSideEffect <manual.html#pragmas-nosideeffect-pragma>`_.
template newException*(exceptn: typedesc, message: string): expr = template newException*(exceptn: typedesc, message: string): expr =
## creates an exception object of type ``exceptn`` and sets its ``msg`` field ## creates an exception object of type ``exceptn`` and sets its ``msg`` field