Def

object Def

Language Extensions

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

For example:

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

val v: Def.Any.Ref.Buffer[String] = ???
// is same as
val v: Any.Ref.Buffer[String] = ???
// is same as
val v: Ref.Buffer[String] = ???

Source: __.scala

class Object

trait Matchable

class Any

Member

Companion scala.Any

Source: __.scala

Companion for scala.Array

Source: __.scala

Companion for scala.Boolean

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


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

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

   val l: Boolean.Pack = s.><    // Holds (true,false,false)

Source: __.scala

Companion for scala.Byte

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

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

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

   val l: Byte.Pack = s.><     // Holds (2,3,4,5)

Source: __.scala

Companion for scala.Char

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


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

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

   val l: Char.Pack = s.><     // Holds ('b','c','d')

Source: __.scala

Companion for scala.Double

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


   val s: Double.~    = (1.0 <> 5.0).step_~(1)

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

   val l: Double.Pack = s.><     // Holds (2.0, 3.0, 4.0)

Source: __.scala

Companion for scala.Float

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


   val s: Float.~    = (1F <> 5F).step_~(1)

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

   val l: Float.Pack = s.><     // Holds (2.0, 3.0, 4.0)

Source: __.scala

Companion for scala.Int

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


   val s: Int.~    = 1 <> 5

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

   val l: Int.>< = s.><     // Holds (2,3,4,5)

Source: __.scala

Companion for scala.Long

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


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

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

   val l: Long.Pack = s.><     // Holds (2,3,4,5)

Source: __.scala

Companion for scala.Short

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


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

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

   val l: Short.Pack = s.><     // Holds (2,3,4,5)