J.Vm.Predef.Extension

Sized stream

Returns stream of array elements limited to given size

Elements stream

Returns stream of array elements

Range

Returns Double.Range from current to given value

 (1.0 <> 10.0).tp  // Prints  1.0 <> 10.0

Range

Returns Float.Range from current to given value

 (1F <> 10F).tp  // Prints  1.0 <> 10.0

Range

Returns Long.Range from current to given value

 (1L <> 10L).tp  // Prints  1 <> 10

Range

Returns Int.Range from current to given value

 (1 <> 10).tp  // Prints  1 <> 10

Range

Returns Short.Range from current to given value

 (1.Short <> 10.Short).tp  // Prints  1 <> 10

Range

Returns Char.Range from current to given value

 ('a' <> 'd').tp  // Prints  a <> d

Range

Returns Byte.Range from current to given value

 (1.Byte <> 10.Byte).tp  // Prints  1 <> 10

Range

Returns Range from current to given value

 ("AAA" <> "BBB").tp  // Prints  AAA <> BBB

Note. A type comparator must be implicitly available

Range by size

Returns Long.Range starting at current value and with given size

 (5L <>= 10L).tp  // Prints 5 <> 14

Range by size

Returns Int.Range starting at current value and with given size

 (5 <>= 10).tp  // Prints 5 <> 14

Range by size

Returns Short.Range starting at current value and with given size

 (5.Short <>= 10).tp  // Prints 5 <> 14

Range by size

Returns Char.Range starting at current value and with given size

 ('a' <>= 5).tp  // Prints a <> e

Range by size

Returns Byte.Range starting at current value and with given size

 (5.Byte <>= 10).tp  // Prints 5 <> 14

Exclusive end range

Returns Double.Range from current to given value exclusive

 (1.0 <>> 10.0).tp  // Prints  1.0 <>> 10.0

Exclusive end range

Returns Float.Range from current to given value exclusive

 (1F <>> 10F).tp  // Prints  1.0 <>> 10.0

Exclusive end range

Returns Long.Range from current to given value exclusive

 (1L <>> 10L).tp  // Prints  1 <> 9

Exclusive end range

Returns Int.Range from current to given value exclusive

 (1 <>> 10).tp  // Prints  1 <> 9

Exclusive end range

Returns Short.Range from current to given value exclusive

 (1.Short <>> 10.Short).tp  // Prints  1 <> 9

Exclusive end range

Returns Char.Range from current to given value exclusive

 ('a' <>> 'd').tp  // Prints  a <> c

Exclusive end range

Returns Byte.Range from current to given value exclusive

 (1.Byte <>> 10.Byte).tp  // Prints  1 <> 9

Exclusive end range

Returns Byte.Range from current to given value exclusive

  ("AAA" <>> "BBB").tp  // Prints  AAA <>> BBB

Note. A type comparator must be implicitly available

def +- -> Any to String add with space

Concatenates this and given object string tags with one space in between

true +- 1 +- 2 +- 3 +- 'A' +- 10.Percent tp() // Prints true 1 2 3 A 10%

Note. Java supports AnyRef + AnyRef, resulting in their String representation concatenation. Scala 2 also used to support this, which was a huge mistake, because this not importent + operation, due to it global nature, would interfere with all attempts to use + for anything else. Scala 3 got rid of this for good. Scalqa re-introduces this usefull functionality with such a weired name "+-", hoping it will not pose naming conflits

To option

Returns Double.Opt for current value

 val o : Double.Opt = 12.0.?

To option

Returns Float.Opt for current value

 val o : Float.Opt = 12F.?

To option

Returns Long.Opt for current value

 val o : Long.Opt = 12L.?

To option

Returns Int.Opt for current value

 val o : Int.Opt = 12.?

To option

Returns Short.Opt for current value

 val o : Short.Opt = 12.Short.?

To option

Returns Char.Opt for current value

 val o : Char.Opt = 'A'.?

To option

Returns Byte.Opt for current value

 val o : Byte.Opt = 12.Byte.?

To given value option

Returns given value option if base Boolean is true, and void option if false

 var b = true

 (b ? "Foo").tp  // Prints   Opt(Foo)

 b = false

 (b ? "Foo").tp  // Prints   Opt(\/)

Note: This operation can be used as a conditional function

 var b = true

 (b ? "Foo" or "Bar").tp  // Prints   Foo

 b = false

 (b ? "Foo" or "Bar").tp  // Prints   Bar

To option

Returns Boolean.Opt for current value

 val o: Boolean.Opt = true.?

To option

Returns Opt for current value

 val o : Opt[String] = "Foo".?

To result

Returns Result for current value

 val o : Result[String] = "Foo".??

Self view

Returns additional Self library available to this instance

The most popular feature is doing some processing within context of an anonimous function

val a: Array[Int] = new Array[Int](3).^(_.fill(5))

// Compare to

val b: Array[Int] = { val a = new Array[Int](3); a.fill(5); a }

Note. Due to opaque implementation and inlining, there is no performance difference in the above two cases

Max

Returns maximum of current or given value

 val v = 5F

 v.atLeast(0).tp   // Prints 5.0

 v.atLeast(10).tp  // Prints 10.0

Max

Returns maximum of current or given value

 val v = 5F

 v.atLeast(0).tp   // Prints 5.0

 v.atLeast(10).tp  // Prints 10.0

Max

Returns maximum of current or given value

 val v = 5L

 v.atLeast(0).tp   // Prints 5

 v.atLeast(10).tp  // Prints 10

Max

Returns maximum of current or given value

 val b = 5

 b.atLeast(0).tp   // Prints 5

 b.atLeast(10).tp  // Prints 10

Max

Returns maximum of current or given value

 val b = 5.Short

 b.atLeast(0).tp   // Prints 5

 b.atLeast(10).tp  // Prints 10

Max

Returns maximum of current or given value

 val v = 'D'

 v.atLeast('A').tp   // Prints D

 v.atLeast('F').tp   // Prints F

Max

Returns maximum of current or given value

 val b = 5.Byte

 b.atLeast(0).tp   // Prints 5

 b.atLeast(10).tp  // Prints 10

Min

Returns minimun of current or given value

 val v = 5F

 v.atMost(0).tp   // Prints 0.0

 v.atMost(10).tp  // Prints 5.0

Min

Returns minimun of current or given value

 val v = 5F

 v.atMost(0).tp   // Prints 0.0

 v.atMost(10).tp  // Prints 5.0

Min

Returns minimun of current or given value

 val v = 5L

 v.atMost(0).tp   // Prints 0

 v.atMost(10).tp  // Prints 5

Min

Returns minimun of current or given value

 val b = 5

 b.atMost(0).tp   // Prints 0

 b.atMost(10).tp  // Prints 5

Min

Returns minimun of current or given value

 val b = 5.Short

 b.atMost(0).tp   // Prints 0

 b.atMost(10).tp  // Prints 5

Min

Returns minimun of current or given value

val v = 'D'

v.atMost('A').tp   // Prints A

v.atMost('F').tp   // Prints D

Min

Returns minimun of current or given value

 val b = 5.Byte

 b.atMost(0).tp   // Prints 0

 b.atMost(10).tp  // Prints 5

Source of Chars

Returns String as a Source of [Char]] "abcd".char_~ tp // Prints ~(a, x, c, d)

Char at position

Returns Char at the specified position

Char at position

Optionally Returns Char at the specified position

/ is returned if specified position is out of String range

if(<name>.charAt_?(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_".charIndex_?(_ >= 'd', 4) tp // Prints: ?(8)
   "abcd_abcd_".charIndex_?('x' <> 'z') tp  // Prints: \/

Contains check

Returns true is this String contains that String "abc".contains("cd") tp // Prints: false

Contains check

Returns true if array contains equal value, `false - otherwise

Copy with new size

Creates new Array of specified size (can be larger or smaller), with appropriate elements copied from base array

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

Is contained

Returns true if this instance is within given container.

 val range = 1 <> 10

 (5 in range).tp   // Prints true

 val list = (1 <> 10).~.><

 5 in list.tp      // Prints true

Note. This operation is heavily overloaded, to provide performance close to directly written efficient comparison code

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 ```

Source of indexes

Source of indexes for each occurrence of x "abcd_abcd_abcd_abcd_abcd".indexesOf_~("bc") tp // Prints ~(1, 6, 11, 16, 21)

Value position

Optionally returns position of the specified x "abcd_abcd_".indexOf_?("d_a") tp // Prints: ?(3)

Get Info

Returns Info object describing current instance

Referance types can implement Able.Info, opaque types can provide implicit Doc, in any case this operation will retrieve Info or will create a basic one, if none is found.

Insert at position

Creates new String with x inserted at the specified position "0123456789".insertAt(5,"abc") tp // Prints: 01234abc56789

Is alphabetic check

Inlines call to java.lang.Character.isAlphabetic

Is digit check

Inlines call to java.lang.Character.isDigit

Is letter check

Inlines call to java.lang.Character.isLetter

Is letter or digit check

Inlines call to java.lang.Character.isLetterOrDigit

Lower case check

Inlines call to java.lang.Character.isLowerCase

Title case check

Inlines call to java.lang.Character.isTitleCase

Upper case check

Inlines call to java.lang.Character.isUpperCase

Whitespace check

Inlines call to java.lang.Character.isWhitespace

Capitalize

Capitalizes first character of every word (separated by white spaces) "all string ops".tag tp // Prints: All String Ops

Char index

Optionally returns index of the last Char passing the let function

   "abcd_abcd_".lastCharIndex_?(_ >= 'd', 4) tp // Prints: ?(3)
   "abcd_abcd_".lastCharIndex_?('x' <> 'z') tp  // Prints: \/

Value position

Optionally returns last position of the specified x "abcd_abcd_abcd_".lastIndexOf_?("d_a") tp // Prints: ?(8)

Source of lines

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

') of this text

```  "abc

def xyz".line_~.tp // Prints ~(abc, def, xyz) ```

toLowerCase

Creates new String with all upper case Chars changed to lower case "ABc".lower tp // Prints: abc

Char name

Inlines call to java.lang.Character.getName

New Array

Creates new empty array of the same type as base array

Reversed Boolean

This is a postfix operation equivalent to !, ie. true.not == !true

 var b = true

 b.not  // Prints   false

 b = false

 b.not  // Prints   true

Note: This operation is inlined and can be used without performance worries

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

Round to size

Rounds current value to specified size

 91F.roundTo(5).tp            // Prints 90.0

 91F.roundTo(5)(using UP).tp  // Prints 95.0

Round to size

Rounds current value to specified size

 91F.roundTo(5).tp            // Prints 90.0

 91F.roundTo(5)(using UP).tp  // Prints 95.0

Round to size

Rounds current value to specified size

 91L.roundTo(5).tp            // Prints 90

 91L.roundTo(5)(using UP).tp  // Prints 95

Round to size

Rounds current value to specified size

 91.roundTo(5).tp            // Prints 90

 91.roundTo(5)(using UP).tp  // Prints 95

Round to size

Rounds current value to specified size

 91.Short.roundTo(5).tp            // Prints 90

 91.Short.roundTo(5)(using UP).tp  // Prints 95

Round to size

Rounds current value to specified size

 91.Byte.roundTo(5).tp            // Prints 90

 91.Byte.roundTo(5)(using UP).tp  // Prints 95

Self view

self_^ is functionally identical to ^, and should be used when ^ struggles

^ occasionally does not work, because it is locally overridden with other functionality (for example on Int, Long it does some bit ops)

Check if begins with

Returns true this String starts with that String "abc".startsWith("ab") tp // Prints: true

To String

Returns String representation of base type value.

.tag has to universally be used instead of Java .toString. This is due opaque types, which by definition cannot overwrite .toString, but have facility to provide correct .tag.

In traditional objects, .tag by default calls .toString.

val v: Time.Length =  100.Seconds

v.tag.tp       // Prints 1 min 40 secs

// Compare to

v.toString.tp  // Prints 100000000000

Copy end

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

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

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

Copy end

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

If no x found, dflt x 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 x found

If no x found, dflt x 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 x found

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

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

Copy end

Copies String from the position where the specified x found

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

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

Copy end

Copies String from the last position the specified x found

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

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

Boolean result conversion

Converts String to Boolean result

 "true".toBoolean_?? tp

 "abc".toBoolean_?? tp

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

Double result conversion

Converts String to Double result

 "123.45".toDouble_?? tp

 "abc".toDouble_?? tp

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

Int result conversion

Converts String to Int result

 "123".toInt_?? tp

 "abc".toInt_?? tp

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

Source 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).~.makeString()
    "Text to Tokenize:".tp.tp
    str.tp.tp
    ("Token", "Range", "String").tp
    str.replace("

", "").tokenized~(Stream("000","111","222","333","444")).tp

    // Output

    Text to Tokenize:

    12345678910111213141516171819202122232425262728293031323334353637383940

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

Long result conversion

Converts String to Long result

  "123".toLong_?? tp

  "abc".toLong_?? tp

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

To lower case

Inlines call to java.lang.Character.toLowerCase

To title case

Inlines call to java.lang.Character.toTitleCase

To upper case

Inlines call to java.lang.Character.toUpperCase

Tag print

tp should be pronounced as "tip"

tp is a functional equivalent to println for debugging, education and demonstration purposes

tp should never be inside a production program, println should be used instead. Searching code for tp should immediately locate debugging fragments.

 // Compare:

 1.tp
 // vs.
 println(1.tag)

 (1 <> 10).~.tp
 // vs.
 println((1 <> 10).~.tag)

 100.Seconds.tp
 // vs.
 println(100.Seconds.tag)

Also, there is postfix like overload of tp on String type

  "Results:" +- 1 +- 2 +- 3 +- 4.Percent tp()
  // vs.
  println("Results:" +- 1 +- 2 +- 3 +- 4.Percent)

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('x' <> 'z') tp                // Prints: ABC

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

Trim both ends

Trims end of String from Chars defined by let function

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

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

Trim end

Trims end of String from space Chars

Trim start

Trims start of String from Chars defined by let function

   "yyxxxxABC".trimBoth('x' <> 'z') tp                // Prints: ABC

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

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 BigDecimal

BigDecimal constructor attached to Double

To BigDecimal

BigDecimal constructor attached to Float