Skip to content

HTTPS clone URL

Subversion checkout URL

You can clone with HTTPS or Subversion.

Download ZIP
Browse files

Fix trivial errors in eep-0035

  • Loading branch information...
commit 289ca8df372c91b3b449053cee0cf2faf0ae2130 1 parent 53d4504
@tuncer tuncer authored
Showing with 61 additions and 63 deletions.
  1. +61 −63 eeps/eep-0035.md
View
124 eeps/eep-0035.md
@@ -253,7 +253,7 @@ region-specific properties of a string, the interface should not
contain language-dependent functionality. The ``string`` module did not
originally contain such functions (except that character alignment
functions were named ``left`` and ``right``), but unfortunately
-functions like ``to_float`` and ``to_upper`` has been added.
+functions like ``to_float`` and ``to_upper`` have been added.
I think that having language-dependent functions in the ``string``
module was a mistake and I do not want to make that mistake
@@ -292,7 +292,7 @@ As mentioned earlier, I don't think direction of the graphical
representation should be implied in the interface, why I suggest using
notions like leading and trailing (meaning leading and trailing
characters in the binary) rather than any directional notions. I also
-think aligning strings (like in ``strings:right`` etc) could be solved
+think aligning strings (like in ``strings:right`` etc.) could be solved
in one function ``align``, taking one of the atoms ``leading``,
``trailing`` or ``center`` as a parameter, if it should at all be
implemented.
@@ -323,11 +323,11 @@ offset of that first character too.
I suggest adding some interfaces returning byte offsets, or _part()'s_
like the ones used in the ``binary`` module and by ``re``, to cope
-with the need for byte offset's and lengths in some circumstances. A
+with the need for byte offsets and lengths in some circumstances. A
``b`` suffix to the function name could denote such functionality, so
-that ``bstring:span`` returns character position while
-``bstring:spanb`` returns byte position and ``btring:str`` returns a
-character position and ``bstring:strb`` return a _part()_. Although
+that ``bstring:span`` returns a character position while
+``bstring:spanb`` returns a byte position and ``btring:str`` returns a
+character position and ``bstring:strb`` returns a _part()_. Although
this will in the end give rise to more functions in the interface,
having return-type-changing options in an option list is not the way
to go (I know, I have them in ``re``, but it's still not generally a
@@ -367,9 +367,9 @@ following interfaces, expressed as in a manual page of OTP.
- The encoding of characters in the binary data, both input and output
bstring()
- Binary with characters encoded either in ISO-Latin-1 or UTF-8
- unicode\_char() = non\_negative\_integer()
+ unicode_char() = non_negative_integer()
- An integer representing a valid unicode codepoint
- non\_negative\_integer()
+ non_negative_integer()
- An integer >= 0
@@ -389,7 +389,7 @@ Types:
Aligns the characters in ``BString`` in a ``Result`` of ``Number`` characters according to the ``Alignment`` parameter. Alignment is done by inserting the character ``Char`` in the beginning or end (or both) of the binary string.
-The resulting binary string will contain exactly ``Number`` characters, the string is truncated if it contains more characters than ``Number`` - either at the end if ``Alignment`` is ``leading`` , or at the beginning if ``Alignment`` is ``trailing`` , or at both ends if ``Alignment`` is ``center`` . If ``Encoding`` is ``unicode`` , the ``Result`` may well contain more bytes than ``Number`` , as one character may require several bytes.
+The resulting binary string will contain exactly ``Number`` characters, the string is truncated if it contains more characters than ``Number`` - either at the end if ``Alignment`` is ``leading``, or at the beginning if ``Alignment`` is ``trailing``, or at both ends if ``Alignment`` is ``center`` . If ``Encoding`` is ``unicode``, the ``Result`` may well contain more bytes than ``Number``, as one character may require several bytes.
Example:
@@ -397,7 +397,7 @@ Example:
> bstring:align(<<"Hello">>, latin1, center, 10, $.).
<<"..Hello...">>
-If the encoding is not given, it is assumed to be ``latin1`` , implying that no interpretation is given to the bytes in the binary string.
+If the encoding is not given, it is assumed to be ``latin1``, implying that no interpretation is given to the bytes in the binary string.
Raises a ``badarg`` exception if ``BString`` does not contain characters encoded according to the ``Encoding`` parameter, ``Encoding`` or ``Alignment`` has an invalid value, the character ``Char`` cannot be encoded in the character encoding given as ``Encoding`` or any of the parameters are of the wrong type.
@@ -419,13 +419,13 @@ Types:
Returns the (zero-based) character position of the first/last occurrence of ``Character`` in ``BString`` . ``-1`` is returned if ``Character`` does not occur.
-Note that the character position is not the same as the byte position. Use the chrb and rchrb functions to get the byte positions.
+Note that the character position is not the same as the byte position. Use the ``chrb`` and ``rchrb`` functions to get the byte positions.
If ``Character`` cannot be represented in the encoding, it is not an error, you are just certain to get ``-1`` as a return value.
-If the encoding is not given, it is assumed to be ``latin1`` , implying that no interpretation is given to the bytes in the binary string.
+If the encoding is not given, it is assumed to be ``latin1``, implying that no interpretation is given to the bytes in the binary string.
-Raises a ``badarg`` exception if searched part of ``BString`` does not contain characters encoded according to the ``Encoding`` parameter, the ``Encoding`` has an invalid value, or any of the parameters are of the wrong type.
+Raises a ``badarg`` exception if the searched part of ``BString`` does not contain characters encoded according to the ``Encoding`` parameter, the ``Encoding`` has an invalid value, or any of the parameters are of the wrong type.
### ``chrb(BString, Character) -> {BytePosition, ByteLength}``
@@ -444,7 +444,7 @@ Types:
BytePosition = integer()
ByteLength = non_negative_integer()
-Works as chr and rchr respectively, but returns the byte position and byte length of the character.
+Works as ``chr`` and ``rchr`` respectively, but returns the byte position and byte length of the character.
If the character is not found, ``{-1,0}`` is returned.
@@ -460,7 +460,7 @@ Types:
Concatenates two binary strings to form a new string. Returns the new binary string in the encoding given by Encoding3.
-If the encoding is not given, it is assumed to be ``latin1`` , implying that no interpretation is given to the bytes in the binary string.
+If the encoding is not given, it is assumed to be ``latin1``, implying that no interpretation is given to the bytes in the binary string.
Raises a ``badarg`` exception if ``BString1`` or ``Bstring2`` does not contain characters encoded according to the ``Encoding1`` and ``Encoding2`` parameters, the encoding parameters has an invalid value, the codepoints in the in-parameters cannot be represented in the output encoding or any of the parameters are of the wrong type.
@@ -478,11 +478,11 @@ Tests whether two binary strings are equal. Returns ``true`` if they are, otherw
``Encoding1`` is the encoding of ``BString1`` and ``Encoding2`` is the encoding of ``BString2`` .
-Note that the strings can have different encoding and that it is the character values encoded in the strings that are compared. The binary strings are scanned as long as they are equal, meaning that if the function returns ``true`` , both strings are correctly encoded, while a return value of ``false`` does not guarantee correct encoding in both binary strings. An exception is raised if faulty encoding is determined while comparing the strings, not if parts of the string not inspected contains encoding errors.
+Note that the strings can have different encoding and that it is the character values encoded in the strings that are compared. The binary strings are scanned as long as they are equal, meaning that if the function returns ``true``, both strings are correctly encoded, while a return value of ``false`` does not guarantee correct encoding in both binary strings. An exception is raised if faulty encoding is determined while comparing the strings, not if parts of the string not inspected contain encoding errors.
-If the encoding is not given, it is assumed to be ``latin1`` , implying that no interpretation is given to the bytes in the binary string.
+If the encoding is not given, it is assumed to be ``latin1``, implying that no interpretation is given to the bytes in the binary string.
-Raises a ``badarg`` exception if wrongly encoded characters, according to the encoding parameters are encountered during comparison, the encoding parameters has an invalid value or any of the parameters are of the wrong type.
+Raises a ``badarg`` exception if wrongly encoded characters, according to the encoding parameters, are encountered during comparison, the encoding parameters has an invalid value or any of the parameters are of the wrong type.
### ``join(BStringList, Separator) -> Result``
@@ -506,9 +506,9 @@ Example:
> bstring:join([<<"one">>, <<"two">>, <<"three">>], latin1, <<", ">>, latin1, latin1).
<<"one, two, three">>
-If the encoding is not given, it is assumed to be ``latin1`` , implying that no interpretation is given to the bytes in the binary string.
+If the encoding is not given, it is assumed to be ``latin1``, implying that no interpretation is given to the bytes in the binary string.
-Raises a ``badarg`` exception if binary strings in ``BStringList`` or the ``Separator`` does not contain characters encoded according to the ``BStringListEncoding`` and ``SeparatorEncoding`` parameters respectively, the encoding parameters has an invalid value, the codepoints in the in-parameters cannot be represented in the output encoding ``ResultEncoding`` or any of the parameters are of the wrong type.
+Raises a ``badarg`` exception if binary strings in ``BStringList`` or the ``Separator`` do not contain characters encoded according to the ``BStringListEncoding`` and ``SeparatorEncoding`` parameters respectively, the encoding parameters has an invalid value, the codepoints in the in-parameters cannot be represented in the output encoding ``ResultEncoding`` or any of the parameters are of the wrong type.
### ``len(BString) -> Length``
@@ -523,7 +523,7 @@ Types:
Returns the number of characters in the binary string.
-If the encoding is not given, it is assumed to be ``latin1`` , implying that no interpretation is given to the bytes in the binary string.
+If the encoding is not given, it is assumed to be ``latin1``, implying that no interpretation is given to the bytes in the binary string.
Raises a ``badarg`` exception if ``BString`` does not contain characters encoded according to the ``Encoding`` parameter, the ``Encoding`` has an invalid value or any of the parameters are of the wrong type.
@@ -539,21 +539,21 @@ Types:
CharList = [ unicode_char() ]
N = non_negative_integer()
-Returns the token number ``Number`` of ``BString`` (zero-based). Tokens are separated by the characters in ``CharList`` .
+Returns the token number ``N`` of ``BString`` (zero-based). Tokens are separated by the characters in ``CharList`` .
The returned token will have the same encoding as ``BString`` .
For example:
- > bstring:sub\_word(<<" Hello old boy !">>,latin1,3,[$o, $ ]).
+ > bstring:nth_token(<<" Hello old boy !">>,latin1,3,[$o, $ ]).
<<"ld b">>
-``CharList`` is to be viewed as a _set_ of characters, order is not significant. Codepoints given in ``CharList`` that cannot be represented by the ``Encoding`` , is not an error.
+``CharList`` is to be viewed as a _set_ of characters, order is not significant. Codepoints given in ``CharList`` that cannot be represented by the ``Encoding``, is not an error.
-Values of ``N`` >= number of words in ``BString`` will result in the empty binary string ( ``<<>>`` ) being returned.
+Values of ``N`` >= number of tokens in ``BString`` will result in the empty binary string ``<<>>`` being returned.
-If the encoding is not given, it is assumed to be ``latin1`` , implying that no interpretation is given to the bytes in the binary string.
+If the encoding is not given, it is assumed to be ``latin1``, implying that no interpretation is given to the bytes in the binary string.
Raises a ``badarg`` exception if ``BString`` does not contain characters encoded according to the ``Encoding`` parameter, the ``Encoding`` has an invalid value, or any of the parameters are of the wrong type.
@@ -569,19 +569,19 @@ Types:
CharList = [ unicode_char() ]
Count = non_negative_integer()
-Returns the number of tokens in ``String`` , separated by the characters in ``CharList`` .
+Returns the number of tokens in ``String``, separated by the characters in ``CharList`` .
The result is the same as for length(bstring:tokens(BString,Encoding,CharList)), but avoids building the result.
For example:
- > words(<<" Hello old boy!">>, latin1, [$o, $ ]).
+ > num_tokens(<<" Hello old boy!">>, latin1, [$o, $ ]).
4
-``CharList`` is to be viewed as a _set_ of characters, order is not significant. Codepoints given in ``CharList`` that cannot be represented by the ``Encoding`` , is not an error.
+``CharList`` is to be viewed as a _set_ of characters, order is not significant. Codepoints given in ``CharList`` that cannot be represented by the ``Encoding``, is not an error.
-If the encoding is not given, it is assumed to be ``latin1`` , implying that no interpretation is given to the bytes in the binary string.
+If the encoding is not given, it is assumed to be ``latin1``, implying that no interpretation is given to the bytes in the binary string.
Raises a ``badarg`` exception if ``BString`` does not contain characters encoded according to the ``Encoding`` parameter, the ``Encoding`` has an invalid value, or any of the parameters are of the wrong type.
@@ -611,7 +611,7 @@ Types:
Returns the length (in characters) of the maximum initial (span and cspan) or trailing (rspan and rcspan) segment of BString, which consists entirely of characters from (span and rspan), or not from (cspan and rcspan) Chars.
-``Chars`` is to be viewed as a _set_ of characters, order is not significant. Codepoints given in ``Char`` that cannot be represented by the ``Encoding`` , is not an error.
+``Chars`` is to be viewed as a _set_ of characters, order is not significant. Codepoints given in ``Char`` that cannot be represented by the ``Encoding``, is not an error.
For example:
@@ -621,11 +621,11 @@ For example:
> bstring:cspan((<<"\t abcdef">>,latin1, " \t").
0
-Code point in ``Chars`` that can not be represented by ``Encoding`` is not considered an error.
+Codepoints in ``Chars`` that can not be represented by ``Encoding`` is not considered an error.
-If the encoding is not given, it is assumed to be ``latin1`` , implying that no interpretation is given to the bytes in the binary string.
+If the encoding is not given, it is assumed to be ``latin1``, implying that no interpretation is given to the bytes in the binary string.
-Raises a ``badarg`` exception if searched part of ``BString`` does not contain characters encoded according to the ``Encoding`` parameter, the ``Encoding`` has an invalid value, or any of the parameters are of the wrong type.
+Raises a ``badarg`` exception if the searched part of ``BString`` does not contain characters encoded according to the ``Encoding`` parameter, the ``Encoding`` has an invalid value, or any of the parameters are of the wrong type.
### ``spanb(BString, Chars) -> ByteLength``
@@ -651,7 +651,7 @@ Types:
Chars = [ integer() ]
ByteLength = non_negative_integer()
-Work exactly as the functions ``span`` , ``rspan`` , ``cspan`` and ``rcspan`` respectively, but returns the number of bytes rather than the number of characters.
+Work exactly as the functions ``span``, ``rspan``, ``cspan`` and ``rcspan`` respectively, but returns the number of bytes rather than the number of characters.
### ``split(BString, Separators, Where) -> Tokens``
@@ -666,7 +666,7 @@ Types:
Where = first | last | all
Tokens = [bstring()]
-Returns a list of tokens in ``BString`` , separated by the binary strings in ``Separators`` .
+Returns a list of tokens in ``BString``, separated by the binary strings in ``Separators`` .
The ``Tokens`` returned are encoded according to ``ReturnEncoding`` .
@@ -676,13 +676,13 @@ Example:
> bstring:split(<<"abc defxxghix jkl">>, latin1, [<<"x">>,<<" ">>],all,latin1).
[<<"abc">>, <<"def">>, <<"ghi">>, <<"jkl">>]
-``Separators`` is to be viewed as a _set_ of binary strings, order is not significant. Codepoints given in ``Separators`` that cannot be represented by the ``Encoding`` , is not an error.
+``Separators`` is to be viewed as a _set_ of binary strings, order is not significant. Codepoints given in ``Separators`` that cannot be represented by the ``Encoding``, is not an error.
The ``Where`` parameter specifies at which occurrence of any of the ``Separators`` the binary string is to be split, either at the ``first`` occurrence, the ``last`` occurrence or at ``all`` occurrences, in which case the ``Tokens`` may be an arbitrary long list.
-If the encoding is not given, it is assumed to be ``latin1`` , implying that no interpretation is given to the bytes in the binary string.
+If the encoding is not given, it is assumed to be ``latin1``, implying that no interpretation is given to the bytes in the binary string.
-Raises a ``badarg`` exception if ``BString`` or ``Separators`` does not contain characters encoded according to the ``Encoding`` and ``SepEncoding`` parameters respectively, the resulting tokens cannot be encoded in the ``ReturnEncoding`` , the ``Encoding`` has an invalid value, or any of the parameters are of the wrong type.
+Raises a ``badarg`` exception if ``BString`` or ``Separators`` does not contain characters encoded according to the ``Encoding`` and ``SepEncoding`` parameters respectively, the resulting tokens cannot be encoded in the ``ReturnEncoding``, the ``Encoding`` has an invalid value, or any of the parameters are of the wrong type.
### ``str(BString, SubBStrings) -> Position``
@@ -702,9 +702,9 @@ Types:
Returns the (zero-based) character position where the first/last occurrence of any of the ``SubBStrings`` begins in ``BString`` . ``-1`` is returned if ``SubBString`` does not exist in ``BString`` .
-Note that the ``Character`` position is not the same as the byte position. Use the strb and rstrb functions to get the byte positions.
+Note that the ``Character`` position is not the same as the byte position. Use the ``strb`` and ``rstrb`` functions to get the byte positions.
-The encoding need not be the same for ``BString`` and ``SubBStrings`` , however all strings in SubBStrings need to have the same encoding.
+The encoding need not be the same for ``BString`` and ``SubBStrings``, however all strings in SubBStrings need to have the same encoding.
If the codepoints in SubBString can not be represented in the encoding of BString, that is not an error, but will always result in the return value -1.
@@ -716,9 +716,9 @@ Example:
Note that if both encodings are the same and repeated searches with the same ``SubBStrings`` are to be performed, it is more efficient to use the ``binary:match/{2,3}`` functions with a precompiled pattern on the raw binary data.
-If the encoding is not given, it is assumed to be ``latin1`` , implying that no interpretation is given to the bytes in the binary string.
+If the encoding is not given, it is assumed to be ``latin1``, implying that no interpretation is given to the bytes in the binary string.
-Raises a ``badarg`` exception if searched part of ``BString`` or ``SubBString`` does not contain characters encoded according to the ``Encoding`` and ``SubEnc`` parameters, the ``Encoding`` has an invalid value, or any of the parameters are of the wrong type.
+Raises a ``badarg`` exception if the searched part of ``BString`` or ``SubBString`` does not contain characters encoded according to the ``Encoding`` and ``SubEnc`` parameters, the ``Encoding`` has an invalid value, or any of the parameters are of the wrong type.
### ``strb(BString, SubBStrings) -> {BytePosition, ByteLength}``
@@ -737,9 +737,9 @@ Types:
BytePosition = integer()
ByteLength = non_negative_integer()
-Works as str and rstr respectively, but returns the byte position and byte length of the found substring.
+Works as ``str`` and ``rstr`` respectively, but returns the byte position and byte length of the found substring.
-Note that the ByteLength is the length the found substring has in ``BString`` , regardless of the encoding in ``SubBStrings`` , so that ``ByteLength`` may be both larger and smaller than ``byte_size(SubBString)`` depending on the binary strings encoding.
+Note that ``ByteLength`` is the length the found substring has in ``BString``, regardless of the encoding in ``SubBStrings``, so that ``ByteLength`` may be both larger and smaller than ``byte_size(SubBString)`` depending on the binary string's encoding.
If the substring is not found, ``{-1,0}`` is returned.
@@ -755,7 +755,7 @@ Types:
Which = leading | trailing | both
CharList = [ unicode_char() ]
-Removes leading ( ``Which`` = ``leading`` ) or trailing ( ``Which`` = ``trailing`` ) or both leading and trailing ( ``Which`` = ``both`` ) characters belonging to the set indicated by ``CharList`` from the binary string ``BString`` .
+Removes leading (``Which`` = ``leading``), trailing (``Which`` = ``trailing``) or both leading and trailing (``Which`` = ``both``) characters belonging to the set indicated by ``CharList`` from the binary string ``BString`` .
This is essentially the same as using ``spanb`` and/or ``rspanb`` in combination with bit syntax to remove the characters.
@@ -765,14 +765,14 @@ Example:
> bstring:strip(<<"...He.llo.....">>, latin1, both, [$.]).
<<"He.llo">>
-If the encoding is not given, it is assumed to be ``latin1`` , implying that no interpretation is given to the bytes in the binary string.
+If the encoding is not given, it is assumed to be ``latin1``, implying that no interpretation is given to the bytes in the binary string.
Raises a ``badarg`` exception if scanned part of ``BString`` does not contain characters encoded according to the ``Encoding`` parameter, ``Encoding`` or ``Which`` has an invalid value, or any of the parameters are of the wrong type.
-### ``subst(BString, Separators, Replacement, Where) -> Result``
+### ``replace(BString, Separators, Replacement, Where) -> Result``
-### ``subst(BString, Encoding, Separators, SeparatorsEncoding, Replacement, ReplacementEncoding, Where, ResultEncoding) -> Result``
+### ``replace(BString, Encoding, Separators, SeparatorsEncoding, Replacement, ReplacementEncoding, Where, ResultEncoding) -> Result``
Types:
@@ -804,9 +804,9 @@ Types:
Start = integer()
Length = non_negative_integer() | infinity
-Returns a substring of ``String`` , starting at the zero-based character position ``Start`` , and ending at the end of the binary string (if ``Length`` is ``infinity`` or up to, but not including, the character position ``Start+Length`` (if ``Length`` is a non negative integer).
+Returns a substring of ``String``, starting at the zero-based character position ``Start``, and ending at the end of the binary string (if ``Length`` is ``infinity`` or up to, but not including, the character position ``Start+Length`` (if ``Length`` is a non negative integer).
-The returned SubBString will have the same encoding as ``BString`` .
+The returned ``SubBString`` will have the same encoding as ``BString`` .
Example:
@@ -814,15 +814,15 @@ Example:
> bstring:substr(<<"Hello World">>, latin1, 3, 5).
<<"lo Wo">>
-A negative value of ``Start`` denotes ``abs(Start)`` characters from the _end_ of ``BString`` , so that ``-1`` is the last character position in the binary string.
+A negative value of ``Start`` denotes ``abs(Start)`` characters from the _end_ of ``BString``, so that ``-1`` is the last character position in the binary string.
Example:
- > bstring:substr(<<"Hello World">>, latin1, -3, 3).
+ > bstring:substr(<<"Hello World">>, latin1, -1, 3).
<<"rld">>
-As the true length of an UTF-8 encoded binary string is quite costly to determine ( ``O(N)`` , where ``N`` is the number of bytes in the binary), the function is very forgiving about positions given outside of the string, both ``Start`` s and ``Length`` s. Character positions outside of the string in either direction is collapsed to the empty binary string.
+As the true length of an UTF-8 encoded binary string is quite costly to determine ( ``O(N)``, where ``N`` is the number of bytes in the binary), the function is very forgiving about positions given outside of the string, both ``Start`` s and ``Length`` s. Character positions outside of the string in either direction are collapsed to the empty binary string.
Examples:
@@ -833,18 +833,16 @@ Examples:
<<"4">>
> bstring:substr(<<"01234">>, latin1, -5, 100).
<<"01234">>
- > bstring:substr(<<"01234">>, latin1, -5, 100).
- <<"01234">>
> bstring:substr(<<"01234">>, latin1, -6, 1).
<<>>
> bstring:substr(<<"01234">>, latin1, -6, 2).
<<"0">>
-If the encoding is not given, it is assumed to be ``latin1`` , implying that no interpretation is given to the bytes in the binary string.
+If the encoding is not given, it is assumed to be ``latin1``, implying that no interpretation is given to the bytes in the binary string.
-If the encoding is not given, it is assumed to be ``latin1`` , implying that no interpretation is given to the bytes in the binary string.
+If the encoding is not given, it is assumed to be ``latin1``, implying that no interpretation is given to the bytes in the binary string.
-Raises a ``badarg`` exception if searched part of ``BString`` does not contain characters encoded according to the ``Encoding`` parameter, the ``Encoding`` has an invalid value, or any of the parameters are of the wrong type.
+Raises a ``badarg`` exception if the searched part of ``BString`` does not contain characters encoded according to the ``Encoding`` parameter, the ``Encoding`` has an invalid value, or any of the parameters are of the wrong type.
### ``tokens(BString, SeparatorList) -> Tokens``
@@ -858,7 +856,7 @@ Types:
SeparatorList = [ non_negative_integer() ]
Tokens = [bstring()]
-Returns a list of tokens in ``BString`` , separated by the characters in ``SeparatorList`` .
+Returns a list of tokens in ``BString``, separated by the characters in ``SeparatorList`` .
The ``Tokens`` returned are encoded in the same character encoding as the ``BString`` .
@@ -868,11 +866,11 @@ Example:
> bstring:tokens(<<"abc defxxghix jkl">>, latin1, [$x,$ ]).
[<<"abc">>, <<"def">>, <<"ghi">>, <<"jkl">>]
-``SeparatorList`` is to be viewed as a _set_ of characters, order is not significant. Codepoints given in ``SeparatorList`` that cannot be represented by the ``Encoding`` , is not an error.
+``SeparatorList`` is to be viewed as a _set_ of characters, order is not significant. Codepoints given in ``SeparatorList`` that cannot be represented by the ``Encoding``, is not an error.
-If the encoding is not given, it is assumed to be ``latin1`` , implying that no interpretation is given to the bytes in the binary string.
+If the encoding is not given, it is assumed to be ``latin1``, implying that no interpretation is given to the bytes in the binary string.
-Raises a ``badarg`` exception if searched part of ``BString`` does not contain characters encoded according to the ``Encoding`` parameter, the ``Encoding`` has an invalid value, or any of the parameters are of the wrong type.
+Raises a ``badarg`` exception if the searched part of ``BString`` does not contain characters encoded according to the ``Encoding`` parameter, the ``Encoding`` has an invalid value, or any of the parameters are of the wrong type.
Performance
===========
Please sign in to comment.
Something went wrong with that request. Please try again.