lib/pure/strutils.nim: fix doc comment for splitLines

1 files changed, 53 insertions, 53 deletions

diff --git a/lib/pure/strutils.nim b/lib/pure/strutils.nim
index 9b4b09fae..9f7e01693 100755
--- a/lib/pure/strutils.nim
+++ b/lib/pure/strutils.nim
@@ -26,19 +26,19 @@ type
 const

   Whitespace* = {' ', '\t', '\v', '\r', '\l', '\f'}

     ## All the characters that count as whitespace.

-    

+

   Letters* = {'A'..'Z', 'a'..'z'}

     ## the set of letters

-  

+

   Digits* = {'0'..'9'}

     ## the set of digits

-  

+

   HexDigits* = {'0'..'9', 'A'..'F', 'a'..'f'}

     ## the set of hexadecimal digits

 

   IdentChars* = {'a'..'z', 'A'..'Z', '0'..'9', '_'}

     ## the set of characters an identifier can consist of

-  

+

   IdentStartChars* = {'a'..'z', 'A'..'Z', '_'}

     ## the set of characters an identifier can start with

 

@@ -192,7 +192,7 @@ proc addf*(s: var string, formatstr: string, a: openarray[string]) {.
       inc(i)

 

 proc `%` *(formatstr: string, a: openarray[string]): string {.noSideEffect,

-  rtl, extern: "nsuFormatOpenArray".} = 

+  rtl, extern: "nsuFormatOpenArray".} =

   ## The `substitution`:idx: operator performs string substitutions in

   ## `formatstr` and returns a modified `formatstr`. This is often called

   ## `string interpolation`:idx:.

@@ -233,7 +233,7 @@ proc `%` *(formatstr: string, a: openarray[string]): string {.noSideEffect,
   result = newStringOfCap(formatstr.len + a.len shl 4)

   addf(result, formatstr, a)

 

-proc `%` *(formatstr, a: string): string {.noSideEffect, 

+proc `%` *(formatstr, a: string): string {.noSideEffect,

   rtl, extern: "nsuFormatSingleElem".} =

   ## This is the same as ``formatstr % [a]``.

   result = newStringOfCap(formatstr.len + a.len)

@@ -249,7 +249,7 @@ proc strip*(s: string, leading = true, trailing = true): string {.noSideEffect,
   var

     first = 0

     last = len(s)-1

-  if leading: 

+  if leading:

     while s[first] in chars: inc(first)

   if trailing:

     while last >= 0 and s[last] in chars: dec(last)

@@ -337,7 +337,7 @@ iterator splitLines*(s: string): string =
   ## Example:

   ##

   ## .. code-block:: nimrod

-  ##   for line in lines("\nthis\nis\nan\n\nexample\n"):

+  ##   for line in splitLines("\nthis\nis\nan\n\nexample\n"):

   ##     writeln(stdout, line)

   ##

   ## Results in:

@@ -365,7 +365,7 @@ iterator splitLines*(s: string): string =
 

 proc splitLines*(s: string): seq[string] {.noSideEffect,

   rtl, extern: "nsuSplitLines".} =

-  ## The same as the `splitLines` iterator, but is a proc that returns a 

+  ## The same as the `splitLines` iterator, but is a proc that returns a

   ## sequence of substrings.

   accumulateResult(splitLines(s))

 

@@ -435,21 +435,21 @@ proc ParseHexInt*(s: string): int {.noSideEffect, procvar,
   rtl, extern: "nsuParseHexInt".} =

   ## Parses a hexadecimal integer value contained in `s`. If `s` is not

   ## a valid integer, `EInvalidValue` is raised. `s` can have one of the

-  ## following optional prefixes: ``0x``, ``0X``, ``#``. 

+  ## following optional prefixes: ``0x``, ``0X``, ``#``.

   ## Underscores within `s` are ignored.

   var i = 0

   if s[i] == '0' and (s[i+1] == 'x' or s[i+1] == 'X'): inc(i, 2)

   elif s[i] == '#': inc(i)

-  while true: 

+  while true:

     case s[i]

     of '_': inc(i)

-    of '0'..'9': 

+    of '0'..'9':

       result = result shl 4 or (ord(s[i]) - ord('0'))

       inc(i)

-    of 'a'..'f': 

+    of 'a'..'f':

       result = result shl 4 or (ord(s[i]) - ord('a') + 10)

       inc(i)

-    of 'A'..'F': 

+    of 'A'..'F':

       result = result shl 4 or (ord(s[i]) - ord('A') + 10)

       inc(i)

     of '\0': break

@@ -473,7 +473,7 @@ proc align*(s: string, count: int): string {.
   ## Aligns a string `s` with spaces, so that is of length `count`. Spaces are

   ## added before `s` resulting in right alignment. If ``s.len >= count``, no

   ## spaces are added and `s` is returned unchanged.

-  if s.len < count: 

+  if s.len < count:

     result = newString(count)

     var spaces = count - s.len

     for i in 0..spaces-1: result[i] = ' '

@@ -515,11 +515,11 @@ iterator tokenize*(s: string, seps: set[char] = Whitespace): tuple[
       break

     i = j

 

-proc wordWrap*(s: string, maxLineWidth = 80, 

+proc wordWrap*(s: string, maxLineWidth = 80,

                splitLongWords = true,

                seps: set[char] = whitespace,

                newLine = "\n"): string {.

-               noSideEffect, rtl, extern: "nsuWordWrap".} = 

+               noSideEffect, rtl, extern: "nsuWordWrap".} =

   ## word wraps `s`.

   result = newStringOfCap(s.len + s.len shr 6)

   var SpaceLeft = maxLineWidth

@@ -529,7 +529,7 @@ proc wordWrap*(s: string, maxLineWidth = 80,
         result.add(substr(word, 0, spaceLeft-1))

         var w = spaceLeft+1

         var wordLeft = len(word) - spaceLeft

-        while wordLeft > 0: 

+        while wordLeft > 0:

           result.add(newLine)

           var L = min(maxLineWidth, wordLeft)

           SpaceLeft = maxLineWidth - L

@@ -545,7 +545,7 @@ proc wordWrap*(s: string, maxLineWidth = 80,
       result.add(word)

 

 proc unindent*(s: string, eatAllIndent = false): string {.

-               noSideEffect, rtl, extern: "nsuUnindent".} = 

+               noSideEffect, rtl, extern: "nsuUnindent".} =

   ## unindents `s`.

   result = newStringOfCap(s.len)

   var i = 0

@@ -593,17 +593,17 @@ proc endsWith*(s, suffix: string): bool {.noSideEffect,
   if suffix[i] == '\0': return true

 

 proc addSep*(dest: var string, sep = ", ", startLen = 0) {.noSideEffect,

-                                                           inline.} = 

-  ## A shorthand for: 

-  ## 

+                                                           inline.} =

+  ## A shorthand for:

+  ##

   ## .. code-block:: nimrod

   ##   if dest.len > startLen: add(dest, sep)

-  ## 

+  ##

   ## This is often useful for generating some code where the items need to

   ## be *separated* by `sep`. `sep` is only added if `dest` is longer than

   ## `startLen`. The following example creates a string describing

-  ## an array of integers:  

-  ## 

+  ## an array of integers:

+  ##

   ## .. code-block:: nimrod

   ##   var arr = "["

   ##   for x in items([2, 3, 5, 7, 11]):

@@ -622,13 +622,13 @@ proc allCharsInSet*(s: string, theSet: TCharSet): bool =
 #    345

 

 when false:

-  proc abbrev(s: string, possibilities: openarray[string]): int = 

+  proc abbrev(s: string, possibilities: openarray[string]): int =

     ## returns the index of the first item in `possibilities` if not

     ## ambiguous; -1 if no item has been found; -2 if multiple items

     ## match.

     result = -1 # none found

-    for i in 0..possibilities.len-1: 

-      if possibilities[i].startsWith(s): 

+    for i in 0..possibilities.len-1:

+      if possibilities[i].startsWith(s):

         if result >= 0: return -2 # ambiguous

         result = i

 

@@ -648,7 +648,7 @@ proc join*(a: openArray[string], sep: string): string {.
       add(result, a[i])

   else:

     result = ""

-  

+

 proc join*(a: openArray[string]): string {.

   noSideEffect, rtl, extern: "nsuJoin".} =

   ## concatenates all strings in `a`.

@@ -706,7 +706,7 @@ proc find*(s: string, chars: set[char], start: int = 0): int {.noSideEffect,
   ## none of the characters in `chars`, -1 is returned.

   for i in start..s.len-1:

     if s[i] in chars: return i

-  return -1 

+  return -1

 

 proc quoteIfContainsWhite*(s: string): string =

   ## returns ``'"' & s & '"'`` if `s` contains a space and does not

@@ -775,10 +775,10 @@ proc ParseOctInt*(s: string): int {.noSideEffect,
   ## Underscores within `s` are ignored.

   var i = 0

   if s[i] == '0' and (s[i+1] == 'o' or s[i+1] == 'O'): inc(i, 2)

-  while true: 

+  while true:

     case s[i]

     of '_': inc(i)

-    of '0'..'7': 

+    of '0'..'7':

       result = result shl 3 or (ord(s[i]) - ord('0'))

       inc(i)

     of '\0': break

@@ -813,17 +813,17 @@ proc toBin*(x: BiggestInt, len: int): string {.noSideEffect,
     mask = mask shl 1

 

 proc insertSep*(s: string, sep = '_', digits = 3): string {.noSideEffect,

-  rtl, extern: "nsuInsertSep".} = 

+  rtl, extern: "nsuInsertSep".} =

   ## inserts the separator `sep` after `digits` digits from right to left.

-  ## Even though the algorithm works with any string `s`, it is only useful 

+  ## Even though the algorithm works with any string `s`, it is only useful

   ## if `s` contains a number.

-  ## Example: ``insertSep("1000000") == "1_000_000"`` 

+  ## Example: ``insertSep("1000000") == "1_000_000"``

   var L = (s.len-1) div digits + s.len

   result = newString(L)

   var j = 0

   dec(L)

-  for i in countdown(len(s)-1, 0): 

-    if j == digits: 

+  for i in countdown(len(s)-1, 0):

+    if j == digits:

       result[L] = sep

       dec(L)

       j = 0

@@ -854,9 +854,9 @@ proc escape*(s: string, prefix = "\"", suffix = "\""): string {.noSideEffect,
     of '\"': add(result, "\\\"")

     else: add(result, c)

   add(result, suffix)

-  

+

 proc validIdentifier*(s: string): bool {.noSideEffect,

-  rtl, extern: "nsuValidIdentifier".} = 

+  rtl, extern: "nsuValidIdentifier".} =

   ## returns true if `s` is a valid identifier. A valid identifier starts

   ## with a character of the set `IdentStartChars` and is followed by any

   ## number of characters of the set `IdentChars`.

@@ -864,7 +864,7 @@ proc validIdentifier*(s: string): bool {.noSideEffect,
     for i in 1..s.len-1:

       if s[i] notin IdentChars: return false

     return true

-  

+

 proc editDistance*(a, b: string): int {.noSideEffect,

   rtl, extern: "nsuEditDistance".} =

   ## returns the edit distance between `a` and `b`. This uses the Levenshtein

@@ -967,17 +967,17 @@ type
 

 proc formatBiggestFloat*(f: BiggestFloat, format: TFloatFormat = ffDefault,

                          precision = 16): string {.noSideEffect,

-                                                  rtl, extern: "nsu$1".} = 

-  ## converts a floating point value `f` to a string. 

+                                                  rtl, extern: "nsu$1".} =

+  ## converts a floating point value `f` to a string.

   ##

-  ## If ``format == ffDecimal`` then precision is the number of digits to 

+  ## If ``format == ffDecimal`` then precision is the number of digits to

   ## be printed after the decimal point.

-  ## If ``format == ffScientific`` then precision is the maximum number 

+  ## If ``format == ffScientific`` then precision is the maximum number

   ## of significant digits to be printed.

   ## `precision`'s default value is the maximum number of meaningful digits

-  ## after the decimal point for Nimrod's ``biggestFloat`` type. 

+  ## after the decimal point for Nimrod's ``biggestFloat`` type.

   const floatFormatToChar: array[TFloatFormat, char] = ['g', 'f', 'e']

-  var 

+  var

     frmtstr: array[0..5, char]

     buf: array[0..80, char]

   frmtstr[0] = '%'

@@ -988,7 +988,7 @@ proc formatBiggestFloat*(f: BiggestFloat, format: TFloatFormat = ffDefault,
     frmtstr[4] = floatFormatToChar[format]

     frmtstr[5] = '\0'

     c_sprintf(buf, frmtstr, precision, f)

-  else: 

+  else:

     frmtstr[2] = floatFormatToChar[format]

     frmtstr[3] = '\0'

     c_sprintf(buf, frmtstr, f)

@@ -996,15 +996,15 @@ proc formatBiggestFloat*(f: BiggestFloat, format: TFloatFormat = ffDefault,
 

 proc formatFloat*(f: float, format: TFloatFormat = ffDefault,

                   precision = 16): string {.noSideEffect,

-                                           rtl, extern: "nsu$1".} = 

-  ## converts a floating point value `f` to a string. 

+                                           rtl, extern: "nsu$1".} =

+  ## converts a floating point value `f` to a string.

   ##

-  ## If ``format == ffDecimal`` then precision is the number of digits to 

+  ## If ``format == ffDecimal`` then precision is the number of digits to

   ## be printed after the decimal point.

-  ## If ``format == ffScientific`` then precision is the maximum number 

+  ## If ``format == ffScientific`` then precision is the maximum number

   ## of significant digits to be printed.

   ## `precision`'s default value is the maximum number of meaningful digits

-  ## after the decimal point for Nimrod's ``float`` type. 

+  ## after the decimal point for Nimrod's ``float`` type.

   result = formatBiggestFloat(f, format, precision)

 

 {.pop.}

@@ -1017,6 +1017,6 @@ when isMainModule:
                    it goes""", 10, false)

   assert formatBiggestFloat(0.00000000001, ffDecimal, 11) == "0.00000000001"

   assert formatBiggestFloat(0.00000000001, ffScientific, 1) == "1.0e-11"

-  

+

   assert "$# $3 $# $#" % ["a", "b", "c"] == "a c b c"