_methods

Join tag

Joins value tag to base string.

Use it instead of '+'. Single plus joins '.toString' instead of '.tag', which often does not make sense especially for 'opaque values'

Note. This method should logically be called '+'. However, it is already defined in 'final class String' and cannot be overridden.

  val p = 12.Percent

  val s = "Value: " ++ p

  // same result as

  val s = "Value: " + p.tag

Optional join

Joins option value to base string.

Returns String "as is" for empty option.

Char at position

Returns Char at the specified position

Char at position

Optionally Returns Char at the specified position

VOID is returned if specified position is out of String range

if(<name>.charAtOpt(2).take(_.isUpper)) ()
// is equivalent
if(<name>.length >=2 && <name>.charAt(2).isUpper) ()

Char index

Optionally returns index of the first Char passing the let function

   "abcd_abcd_".charIndexOpt(_ >= 'd', 4).tp // Prints: Opt(8)
   "abcd_abcd_".charIndexOpt('x' <> 'z') tp  // Prints: Opt(VOID)

Stream of Chars

Returns String as a Stream of [Char]]

"abcd".charStream.tp // Prints Stream(a, x, c, d)

Contains check

Returns true is this String contains that String

"abc".contains("cd").tp // Prints: false

Copy without start

Copies without given number of first characters

The method call is inlined as Java .substring(cnt)

Copy without end

Copies without given number of last characters

The method call is inlined as Java x.substring(0, x.length - cnt)

Copy without range

Copies without range of characters specified

Copy without range

Copies without range of characters specified

Check if ends with

Returns true this String ends with that String

"abc".endsWith("bc").tp // Prints: true

Check if equals ignore case

Returns true this and that String are equal, if upper and lower case Chars are considered equal

"aBc".equalsIgnoreCase("ABC").tp // Prints: true

Indents text with the lines

Indents text with the tag.

Prefixes first line with the tag, other lines with tag equal space

```
   "abc\

de
xyz".indent("Idxs: ").tp // Output Idxs: abc de xyz ```

Value position

Optionally returns position of the specified x

"abcd_abcd_".indexOfOpt("d_a").tp // Prints: Opt(3)

Source of indexes

Source of indexes for each occurrence of x

"abcd_abcd_abcd_abcd_abcd".indexOfStream("bc").tp // Prints Stream(1, 6, 11, 16, 21)

Insert at position

Creates new String with x inserted at the specified position

"0123456789".insertAt(5,"abc").tp // Prints: 01234abc56789

Capitalize

Capitalizes first character of every word (separated by white spaces)

"all string ops".label.tp // Prints: All String Ops

Char index

Optionally returns index of the last Char passing the let function

   "abcd_abcd_".lastCharIndexOpt(_ >= 'd', 4).tp // Prints: Opt(3)
   "abcd_abcd_".lastCharIndexOpt('x' <> 'z') tp  // Prints: Opt(VOID)

Value position

Optionally returns last position of the specified x

"abcd_abcd_abcd_".lastIndexOfOpt("d_a").tp // Prints: Opt(8)

Stream of lines

Creates a [[Stream]] of Strings representing lines (delimited by '

') of this text

```
"abc\

def
xyz".lineStream.tp // Prints Stream(abc, def, xyz) ```

toLowerCase

Creates new String with all upper case Chars changed to lower case

"ABc".lower.tp // Prints: abc

Pad end

  Pads end of string to `targetLength`

Pad start

  Pads start of string to `targetLength`

Remove all

Creates new String with all occurrences of x removed

"123123123123".remove("2").tp // Prints: 13131313

Replace all

Creates new String with all occurrences of x replaced with target

"123123123123".replace("2","_").tp // Prints: 1_31_31_31_3

Replace range with x

Creates new String with all occurrences of x replaced with target

"0123456789".replace(3 <> 7 ,"_").tp // Prints: 012_89

Check if begins with

Returns true this String starts with that String

"abc".startsWith("ab").tp // Prints: true

Copy end

Copies String from the position where the specified v found plus the length of the v

If no v found, dflt v is returned, or original if dflt is void

   "abcdefg".copyAfter("cd").tp // Prints: efg

Copy end

Copies String from the last position the specified v found plus the length of the v

If no v found, dflt v is returned, or original if dflt is void.

   "abcd_abcd_abcd".takeFromLast("ab").tp // Prints: cd

Copy start

Copies String from the beginning until specified v found

If no v found, dflt v is returned, or original if dflt is void

   "abcdefg".takeBefore("ef").tp // Prints: abcd

Copy start

Copies String from the beginning until the last occurrence of specified v found

If no v found, dflt v is returned, or original if dflt is void

   "abcd_abcd_abcd".copyBeforeLast("ab").tp // Prints: abcd_abcd_

Copy start

Copies first given number of characters

The method call is inlined as Java x.substring(0,cnt)

Copy end

Copies String from the position where the specified v found

If no v found, dflt v is returned, or original if dflt is void

   "abcdefg".takeFrom("cd").tp // Prints: cdefg

Copy end

Copies String from the last position the specified v found

If no v found, dflt v is returned, or original if dflt is void.

   "abcd_abcd_abcd".takeFromLast("ab").tp // Prints: abcd

Copy end

Copies last given number of characters

The method call is inlined as Java x.substring(x.length - cnt, x.length)

Copy range

Copies only range of characters specified

Copy range

Copies only range of characters specified

Boolean option conversion

Converts String to Boolean option

 "true".toBooleanOpt.tp

 "abc".toBooleanOpt.tp

 // Output
 Boolean.Opt(true)
 Boolean.Opt(VOID)

Boolean result conversion

Converts String to Boolean result

 "true".toBooleanResult.tp

 "abc".toBooleanResult.tp

 // Output
 Result(true)
 Result(Problem(For input string: "abc"))

Double option conversion

Converts String to Double option

 "123.45".toDoubleOpt.tp

 "abc".toDoubleOpt.tp

 // Output
 Double.Opt(123.45)
 Double.Opt(VOID)

Double result conversion

Converts String to Double result

 "123.45".toDoubleResult.tp

 "abc".toDoubleResult.tp

 // Output
 Result(123.45)
 Result(Problem(For input string: "abc"))

Int opt conversion

Converts String to Int option

 "123".toIntOpt.tp

 "abc".toIntOpt.tp

 // Output
 Int.Opt(123)
 Int.Opt(VOID)

Int result conversion

Converts String to Int result

 "123".toIntResult.tp

 "abc".toIntResult.tp

 // Output
 Result(123)
 Result(Problem(For input string: "abc"))

Stream of tokens

Multi token tokenizetion

Returns a Tuple including:

• Separator preceding the token, empty for the first token
• !.Range of the token in the text
• String token

  val str: String = (1 <> 40).stream.makeString("")
  "Text to Tokenize:".tp.tp
  str.tp.tp
  ("Token", "Range", "String").tp
  str.tokenizedStream(Stream("000","111","222","333","444")).print

  // Output

  Text to Tokenize:

 12345678910111213141516171819202122232425262728293031323334353637383940

  (Token,Range,String)
  --- --------- -------------------
  ?   ?         ?
  --- --------- -------------------
       0 <>> 11 12345678910
  111 14 <>> 33 2131415161718192021
  222 36 <>> 55 3242526272829303132
  333 58 <>> 71 4353637383940
  --- --------- -------------------

Long option conversion

Converts String to Long option

  "123".toLongOpt.tp

  "abc".toLongOpt.tp

  // Output
  Long.Opt(123)
  Long.Opt(VOID)

Long result conversion

Converts String to Long result

  "123".toLongResult.tp

  "abc".toLongResult.tp

  // Output
  Result(123)
  Result(Problem(For input string: "abc"))

Trim both ends

Trims both ends of String from space Chars

Trim both ends

Trims both ends of String from Chars defined by let function

   "yyxxxxABCxxyyxx".trimBoth(_ in 'x' <> 'z') tp           // Prints: ABC

   "yyxxxxABCxxyyxx".trimBoth(c => c == 'x' || c == 'y').tp // Prints: ABC

Trim end

Trims end of String from Chars defined by let function

   "ABCxxyyxx".trimEnd(_ in 'x' <> 'z') tp           // Prints: ABC

   "ABCxxyyxx".trimEnd(c => c == 'x' || c == 'y').tp // Prints: ABC

Trim end

Trims end of String from space Chars

Trim start

Trims start of String from Chars defined by let function

   "yyxxxxABC".trimStart(_ in 'x' <> 'z') tp           // Prints: ABC

   "yyxxxxABC".trimStart(c => c == 'x' || c == 'y').tp // Prints: ABC

Trim start

Trims start of String from space Chars

toUpperCase

Creates new String with all lower case Chars changed to upper case

"aBc".upper.tp // Prints: ABC

To Problem

Creates Result.Problem, where the base String becomes problem message