Lang

object Lang

Language Extensions

Lang is fully exported to scalqa root, thus all members of Lang can be called with or without "Lang." prefix.

For example:

val v: Lang.Byte.Idx = ???
// is same as
val v: Byte.Idx      = ???

val v: Lang.Int.Buffer = ???
// is same as
val v: Int.Buffer      = ???
Source
__.scala
class java.lang.Object
trait scala.Matchable
class Any

Member

object Any

Companion to scala.Any

Source
__.scala
object AnyRef

scala.AnyRef type is an alias for java.lang.Object, they can be used interchangebly.

AnyRef object is a companion for scala.AnyRef type

Source
__.scala
object Boolean extends Boolean.G.Companion.Containers[scala.Boolean]

Companion Object for scala.Boolean

This object also defines specialized custom containers for Boolean type, so the following code can run without boxing:


   val s: Boolean.Stream = Boolean.Stream(true,true,false,false)

   val o: Boolean.Opt    = s.readRawOpt // Holds Boolean.Opt(true)

   val l: Boolean.Pack   = s.pack      // Holds (true,false,false)
Source
__.scala
object Byte extends Byte.G.Companion.Containers[scala.Byte]

Companion Object for scala.Byte

This object also defines specialized custom containers for Byte type, so the following code can run without boxing:

   val s: Byte.Stream = 1.Byte <> 5.Byte

   val o: Byte.Opt    = s.readRawOpt  // Holds Byte.Opt(1)

   val l: Byte.Pack   = s.pack       // Holds (2,3,4,5)
Source
__.scala
object Char extends Char.G.Companion.Containers[scala.Char]

Companion Object for scala.Char

This object also defines specialized custom containers for Char type, so the following code can run without boxing:


   val s: Char.Stream = 'a' <> 'd'

   val o: Char.Opt    = s.readRawOpt  // Holds Char.Opt('a')

   val l: Char.Pack   = s.pack       // Holds ('b','c','d')
Source
__.scala
object Double extends Double.G.Companion.Containers[scala.Double]

Companion Object for scala.Double

This object also defines specialized custom containers for Double type, so the following code can run without boxing:


   val s: Double.Stream = (1.0 <> 5.0).stepStream(_ + 1)

   val o: Double.Opt    = s.readRawOpt  // Holds Double.Opt(1.0)

   val l: Double.Pack   = s.pack       // Holds (2.0, 3.0, 4.0)
Source
__.scala
object Float extends Float.G.Companion.Containers[scala.Float]

Companion Object for scala.Float

This object also defines specialized custom containers for Float type, so the following code can run without boxing:


   val s: Float.Stream = (1F <> 5F).stepStream(_ + 1)

   val o: Float.Opt    = s.readRawOpt  // Holds Float.Opt(1.0)

   val l: Float.Pack   = s.pack       // Holds (2.0, 3.0, 4.0)
Source
__.scala
object Int extends Int.G.Companion.Containers[scala.Int]

Companion Object for scala.Int

This object also defines specialized custom containers for Int type, so the following code can run without boxing:


   val s: Int.Stream = 1 <> 5

   val o: Int.Opt    = s.readRawOpt  // Holds Int.Opt(1)

   val l: Int.Pack   = s.pack       // Holds (2,3,4,5)
Source
__.scala
object Long extends Long.G.Companion.Containers[scala.Long]

Companion Object for scala.Long

This object also defines specialized custom containers for Long type, so the following code can run without boxing:

   val s: Long.Stream = 1L <> 5L

   val o: Long.Opt    = s.readRawOpt  // Holds Long.Opt(1)

   val l: Long.Pack   = s.pack       // Holds (2,3,4,5)
Source
__.scala
object More
Source
__.scala
object Short extends Short.G.Companion.Containers[scala.Short]

Companion Object for scala.Short

This object also defines specialized custom containers for Short type, so the following code can run without boxing:


   val s: Short.Stream = 1.Short <> 5.Short

   val o: Short.Opt    = s.readRawOpt  // Holds Short.Opt(1)

   val l: Short.Pack   = s.pack       // Holds (2,3,4,5)
Source
__.scala
object String extends AnyRef.G.Companion.Containers[scala.Predef.String]

java.lang.String Companion

This object also defines custom containers for String type, which are parameterazed generic containers

Source
__.scala