c

Any._library

final class _library[A] extends AnyVal

Any Library

Defines operations universally attached to every single object in Scalqa

Ordering
  1. Alphabetic
Inherited
  1. Any._library
  2. scala.AnyVal
  3. scala.Any
  1. Hide All
  2. Show All
Visibility
  1. Public
  2. All

Constant

  1. val real: A
    Attributes
    protected
    Definition Classes
    _library

Method

  1. final def asInstanceOf[T0]: T0
    Definition Classes
    Any
  2. def I: Any.Itself[A]

    Any.Itself constractor

    Any.Itself constractor

    Built-in constructor for Any.Itself

    Any.Itself becomes another library attached to every single object in Scalqa, but it has to be accessed over ".I" notation

    val txt = "abc".I(_ lp)      // Prints: "abc"
    
    txt.I.id lp                  // Prints: scalqa.String@1
    
    txt.I.hashIndex lp           // Prints: 1
    Definition Classes
    _library
  3. final def isInstanceOf[T0]: Boolean
    Definition Classes
    Any
  4. def isVoid: Boolean

    Void check

    Void check

    This is a universal way to check an instance for voidness

    See Any.isVoid for details

    (null: String).isVoid lp  // Prints: true
    
    "".isVoid lp              // Prints: true
    
    (\/ : Percent).isVoid lp  // Prints: true
    Definition Classes
    _library
  5. def lp: Unit

    Line print

    Line print

    Prints this object to console with next line marker appended

    val i = 12
    
    " Value i = " + i lp;
    
    // same as
    
    println(" Value i = " + i)
    Definition Classes
    _library
  6. def Opt: Opt[A]

    Opt Constructor

    Opt Constructor

    Creates an Opt with current value

    'null' will create Opt.Void

    Definition Classes
    _library
  7. def toString(): String
    Definition Classes
    Any
  8. def tp: Unit

    Text print

    Text print

    Prints this object to console with next line marker appended

    If this implements Any.Able.ToText then toText value used, otherwise toString

    // Compare to lp
    
    (1 <> 3).all lp  // Prints ~(1, 2, 3)
    
    (1 <> 3).all tp  //  Prints -
                     //         ?
                     //         -
                     //         1
                     //         2
                     //         3
                     //         -
    Definition Classes
    _library

Operator

  1. def ~+(that: A): ~[A]

    Stream plus

    Stream plus

    Creates a Stream out of this and appends that

    Essentially: creates a Stream of two elements

     1 ~+ 2 lp                 // Prints: ~(1, 2)
    
    'A' ~+ 'Z' lp              // Prints: ~(A, Z)
    
    "aaa" ~+ "bbb" + "ccc" lp  // Prints: ~(aaa, bbb, ccc)
    Definition Classes
    _library
  2. def ~+~(that: ~[A]): ~[A]

    Stream plus stream

    Stream plus stream

    Creates a Stream out of this and appends that stream

    Essentially: Prepends this to that stream

    1 ~+~ (2 <> 5) lp                 // Prints: ~(1, 2, 3, 4, 5)
    
    "aa" ~+~ ("bb" ~+ "cc" +"dd") lp  // Prints: ~(aa, bb, cc, dd)
    Definition Classes
    _library
  3. def \/(default: ⇒ A): A

    Non void default

    Non void default

    If this isVoid, default is returned

    Otherwise this is returned

    val p : Percent = \/
    val s : String  = null
    
    p \/ 12    lp  // Prints: 12.0%
    
    s \/ "abc" lp  // Prints: abc
    Definition Classes
    _library
  4. final def !=(arg0: Any): Boolean
    Definition Classes
    Any
  5. final def ##(): Int
    Definition Classes
    Any
  6. def +-(that: Any): String

    Plus spaced to String

    Plus spaced to String

    Creates a String concatenation of this, single space, and that

    This is useful for debugging, consider:

    '1' +- 2 +- "34" lp // Prints: 1 2 34
    
    // vs.
    
    '1' + 2 + "34" lp   // Prints: 5134
    Definition Classes
    _library
  7. def <<>(that: A)(implicit o: Ordering[A], i: Ilk[A]): Range[A]

    Exclusive start range

    Exclusive start range

    Creates range from this to that with exclusive start

    'A' <<> 'Z'  // Creates: Range[Char]
    
    10L <<> 20   // Creates: Range[Long]
    Definition Classes
    _library
  8. def <<>>(that: A)(implicit o: Ordering[A], i: Ilk[A]): Range[A]

    All Exclusive range

    All Exclusive range

    Creates range from this to that with exclusive start and end.

    'A' <<>> 'Z'  // Creates: Range[Char]
    
    10L <<>> 20   // Creates: Range[Long]
    Definition Classes
    _library
  9. def <>(that: A)(implicit o: Ordering[A], i: Ilk[A]): Range[A]

    Simple Range

    Simple Range

    Creates range from this to that all inclusive

    'A' <> 'Z'  // Creates: Range[Char]
    
    10L <> 20   // Creates: Range[Long]
    Definition Classes
    _library
  10. def <>!(implicit o: Ordering[A], i: Ilk[A]): Range[A]

    Single value range

    Single value range

    Creates a single value range with this

    'A' <>!  // Creates: Range[Char] = 'A' <> 'A'
    
    10L <>!  // Creates: Range[Long] = 10 <> 10
    Definition Classes
    _library
  11. def <>+(intSize: Int)(implicit n: Numeric[A], i: Ilk[A]): Range[A]

    Value plus size range

    Value plus size range

    Creates range from this to "this plus intSize"

    math.Numeric must be implicitly available to add intSize

    'A' <>+ 5  // Creates: Range[Char] = A <> F
    
    10L <>+ 5  // Creates: Range[Long] = 10 <> 15
    Definition Classes
    _library
  12. def <>>(that: A)(implicit o: Ordering[A], i: Ilk[A]): Range[A]

    Exclusive end range

    Exclusive end range

    Creates range from this to that with exclusive end

    'A' <>> 'Z'  // Creates: Range[Char]
    
    10L <>> 20   // Creates: Range[Long]
    Definition Classes
    _library
  13. def <>>!(implicit o: Ordering[A], i: Ilk[A]): Range[A]

    Single exclusive value range

    Single exclusive value range

    Creates a single value range with this exclusive

    Note. The range will not be capable to contain anything

    'A' <>>!  // Creates: Range[Char] = 'A' <>> 'A'
    
    10L <>>!  // Creates: Range[Long] = 10 <>> 10
    Definition Classes
    _library
  14. def <>>+(intSize: Int)(implicit n: Numeric[A], i: Ilk[A]): Range[A]

    Value plus size exclusive end range

    Value plus size exclusive end range

    Creates range from this to "this plus intSize" with end exclusive

    math.Numeric must be implicitly available to add intSize

    'A' <>>+ 5  // Creates: Range[Char] = A <>> F
    
    10L <>>+ 5  // Creates: Range[Long] = 10 <>> 15
    Definition Classes
    _library
  15. final def ==(arg0: Any): Boolean
    Definition Classes
    Any
Linear Supertypes
AnyVal, Any
Source: _library.scala