Product

io.getquill.quat.Quat.Product
See theProduct companion class
object Product

Attributes

Companion
class
Graph
Supertypes
class Object
trait Matchable
class Any
Self type
Product.type

Members list

Type members

Classlikes

case class Id(fields: LinkedHashMap[String, Quat])

Attributes

Supertypes
trait Serializable
trait Product
trait Equals
class Object
trait Matchable
class Any
Show all
object Type

Attributes

Companion
trait
Supertypes
trait Sum
trait Mirror
class Object
trait Matchable
class Any
Self type
Type.type
sealed trait Type

Since Product-Quats can be a representation of abstract product types (e.g. abstract classes, traits, etc...) in some cases we need to keep track of this information in order to know that the present product type does not have all of the needed fields. Currently, this is only really possible in quill-spark where resolution of T (of Query[T]) can be a different class during compile-time and run-type while still having a static-query (since dataframes are lifted via the liftQuery construct that has this unique property, I do not believe that this is currently possible with the standard query[T] method). As outlined in the TypeMemberJoinSpec, there are certain situations where the contents of an Ident(a) are not entirely known and the ident needs to be expanded as either struct(a.*) or just a.* depending on the situation.

Since Product-Quats can be a representation of abstract product types (e.g. abstract classes, traits, etc...) in some cases we need to keep track of this information in order to know that the present product type does not have all of the needed fields. Currently, this is only really possible in quill-spark where resolution of T (of Query[T]) can be a different class during compile-time and run-type while still having a static-query (since dataframes are lifted via the liftQuery construct that has this unique property, I do not believe that this is currently possible with the standard query[T] method). As outlined in the TypeMemberJoinSpec, there are certain situations where the contents of an Ident(a) are not entirely known and the ident needs to be expanded as either struct(a.*) or just a.* depending on the situation.

Attributes

Companion
object
Supertypes
class Object
trait Matchable
class Any
Known subtypes
object Abstract.type
object Concrete.type
object WithRenames

Add staged renames to the Quat. Note that renames should explicit NOT be counted as part of the Type indicated by the Quat since it is typical to beta reduce a Quat without renames to a Quat with them (see PropagateRenames for more detail)

Add staged renames to the Quat. Note that renames should explicit NOT be counted as part of the Type indicated by the Quat since it is typical to beta reduce a Quat without renames to a Quat with them (see PropagateRenames for more detail)

Attributes

Supertypes
class Object
trait Matchable
class Any
Self type

Attributes

Supertypes
class Object
trait Matchable
class Any
Self type

Value members

Concrete methods

def apply(name: String, fields: (String, Quat)*): Product
def apply(name: String, tpe: Type, fields: (String, Quat)*): Product
def apply(name: String, fields: Iterable[(String, Quat)]): Product
def apply(name: String, tpe: Type, fields: Iterable[(String, Quat)]): Product
def apply(name: String, fields: Iterator[(String, Quat)]): Product
def apply(name: String, tpe: Type, fields: Iterator[(String, Quat)]): Product
def apply(name: String, fields: LinkedHashMap[String, Quat]): Product
def apply(name: String, tpe: Type, fields: LinkedHashMap[String, Quat]): Product
def empty(name: String): Product
def fromSerialized(serial: String): Product