J.Vm.Predef.GlobalExtensionLibrary

Alias to .stream

Note. In cases when target collection already has a "stream" method with different semantics, calling ~~ is the only option.

Alias to .stream

Note. In cases when target collection already has a "stream" method with different semantics, calling ~~ is the only option.

Shortcut to 'join'

Copies base array to a new array with given element appended

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

Shortcut to 'joinAll'

Copies base array to a new array with given stream of elements appended

Shortcut to 'joinAllAt'

Copies base array to a new array with given stream of elements inserted at given position

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 big mistake, because this not really important + 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

Optional join

Joins option value to base string.

Returns String "as is" for empty option.

Shortcut to 'joinAt'

Copies base array to a new array with given element inserted at given position

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. An Ordering 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 <> from current to given value exclusive

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

Note. An Ordering must be implicitly available

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(VOID)

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".?

Result will be empty option if value is 'null', but non empty for void values. Use .?? instead if void or empty check is required.

To non-empty value option

Returns base value as an option.

Unlike general .? method, this method will create empty option for void or empty values

 val p: Stream[Int]=VOID

 p.?.tp    // prints: Opt(scalqa.val.pack.z.Void)

 p.??.tp  // prints: Opt(VOID)

This method can even safely check Stream for emptiness, returning Stream with original values

def s : Stream[Int] = (1 <> 3).stream.dropFirst(3)

s.??.tp  // prints: Opt(VOID)
s.?.tp   // prints: Opt(Stream())

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

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

Copy to array

Copies base array elements to given array, starting at given 'pos'

'from' and 'size' specify base array range to be copied

Note. Efficient JVM System.arraycopy method is used

Copy to array

Copies base array elements to given array, starting at given position

Note. Efficient JVM System.arraycopy method is used

Copy to array

Copies base array elements to given array

Note. Efficient JVM System.arraycopy method is used

Get Doc

Returns Doc object describing current instance

Reference types can implement Able.Doc, opaque types can provide implicit Any.Def.Doc, in any case this operation will retrieve Doc or will create a default one, if none is found.

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

Drop range

Copies base array to a new array without elements of specified range

Drop range

Copies base array to a new array without elements of specified range

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

Fill value

Assigns given value to all base array positions

Fill range with value

Assigns given value to base array positions within given range

Fill range with value

Assigns given value to base array positions within given range

Is within

Returns true if this instance is contained by given container.

 val range = 1 <> 10

 (5 in range).tp   // Prints true

 val pack = (1 <> 10).stream.pack

 (5 in pack).tp    // Prints true

Note. This operation is Macro optimized for Tuples from 2 to 12, so the following check will be ultimatly efficent with no Tuple allocation:

 val s = "ABC"

 s in ("XYZ","BBC","CBC")

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

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

Upper case check

Inlines call to java.lang.Character.isUpperCase

Void check

Returns true if target is void

Note: Operation can fail for null value, use .self.isVoid if null check is required

Whitespace check

Inlines call to java.lang.Character.isWhitespace

Join element

Copies base array to a new array with given element appended

Join multiple elements

Copies base array to a new array with given stream of elements appended

Join multiple elements at position

Copies base array to a new array with given stream of elements inserted at given position

Join element at position

Copies base array to a new array with given element inserted at given position

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

Make lower case

Inlines call to java.lang.Character.toLowerCase

toLowerCase

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

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

Max value

Returns maximum of current or given value

 val v = 5F

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

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

Max value

Returns maximum of current or given value

 val v = 5F

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

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

Max value

Returns maximum of current or given value

 val v = 5L

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

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

Max value

Returns maximum of current or given value

 val b = 5

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

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

Max value

Returns maximum of current or given value

 val b = 5.Short

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

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

Max value

Returns maximum of current or given value

 val v = 'D'

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

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

Max value

Returns maximum of current or given value

 val b = 5.Byte

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

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

Min value

Returns minimun of current or given value

 val v = 5F

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

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

Min value

Returns minimun of current or given value

 val v = 5F

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

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

Min value

Returns minimun of current or given value

 val v = 5L

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

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

Min value

Returns minimun of current or given value

 val b = 5

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

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

Min value

Returns minimun of current or given value

 val b = 5.Short

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

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

Min value

Returns minimun of current or given value

val v = 'D'

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

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

Min value

Returns minimun of current or given value

 val b = 5.Byte

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

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

Char name

Inlines call to java.lang.Character.getName

New Array

Creates new empty array of the same type as base array, but with given size

Not void check

Returns true if target is non void

Note: Operation can fail for null value, use .self.nonVoid if null check is required

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

Is not within

Reverse "in" method

Pack of elements

Returns Pack of collection elements

Pack of elements

Returns Pack of collection elements

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

Round to decimal

Rounds current value to specified decimal position of fractional value

Round to decimal

Rounds current value to specified decimal position of fractional value

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).self(_.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

Sort array

Sorts array elements

Sort array range

Sorts array elements within given range

Sort array range

Sorts array elements within given range

Check if begins with

Returns true this String starts with that String

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

Stream of elements

Returns Stream of collection elements

Stream of elements

Returns Stream of collection elements

Sized stream

Returns stream of array elements limited to given size

Elements stream

Returns stream of array elements

Make String

Returns String representation of base value.

.tag has to universally be used instead of Java .toString. This is due to opaque types, which by definition cannot override .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 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

Take range

Copies given range of elements a new array

Take range

Copies given range of elements a new array

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"))

Make Byte

Attached Byte constructor

Make Byte

Attached Byte constructor

Make Byte

Returns underlying value

Make Byte

Attached Byte constructor

Make Byte

Attached Byte constructor

Make Byte

Attached Byte constructor

Make Byte

Returns underlying value

Make Char

Attached Char constructor

Make Char

Attached Char constructor

Make Char

Attached Char constructor

Make Char

Attached Char constructor

Make Char

Attached Char constructor

Make Char

Returns underlying value

Make Char

Attached Char constructor

Make Double

Returns underlying value

Make Double

Attached Double constructor

Make Double

Attached Double constructor

Make Double

Attached Double constructor

Make Double

Attached Double constructor

Make Double

Attached Double constructor

Make Double

Attached Double constructor

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"))

Make Float

Attached Float constructor

Make Float

Returns underlying value

Make Float

Attached Float constructor

Make Float

Attached Float constructor

Make Float

Attached Float constructor

Make Float

Attached Float constructor

Make Float

Attached Float constructor

Make Int

Attached Int constructor

Make Int

Attached Int constructor

Make Int

Attached Int constructor

Make Int

Returns underlying value

Make Int

Attached Int constructor

Make Int

Attached Int constructor

Make Int

Attached Int constructor

Make Int

Int constructor attached to Boolean

true is converted to 1, false to 0

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

Make Long

Attached Long constructor