Documentation

Overview

Package typex contains full type representation for PCollections and DoFns, and utilities for type checking.

Index

Constants

This section is empty.

Variables

var (
	TType = reflect.TypeOf((*T)(nil)).Elem()
	UType = reflect.TypeOf((*U)(nil)).Elem()
	VType = reflect.TypeOf((*V)(nil)).Elem()
	WType = reflect.TypeOf((*W)(nil)).Elem()
	XType = reflect.TypeOf((*X)(nil)).Elem()
	YType = reflect.TypeOf((*Y)(nil)).Elem()
	ZType = reflect.TypeOf((*Z)(nil)).Elem()

	EventTimeType = reflect.TypeOf((*EventTime)(nil)).Elem()
	WindowType    = reflect.TypeOf((*Window)(nil)).Elem()

	KVType            = reflect.TypeOf((*KV)(nil)).Elem()
	CoGBKType         = reflect.TypeOf((*CoGBK)(nil)).Elem()
	WindowedValueType = reflect.TypeOf((*WindowedValue)(nil)).Elem()
)

Functions

func Bind

func Bind(types, models []FullType) (map[string]reflect.Type, error)

Bind returns a substitution from universals to types in the given models, such as {"T" -> X, "X" -> int}. Each model must be assignable to the corresponding type. For example, Bind(KV<T,int>, KV<string, int>) would produce {"T" -> string}.

func IsBound

func IsBound(t FullType) bool

IsBound returns true iff the type has no universal type components. Nodes and coders need bound types.

func IsCoGBK

func IsCoGBK(t FullType) bool

IsCoGBK returns true iff the type is a CoGBK.

func IsComposite

func IsComposite(t reflect.Type) bool

IsComposite returns true iff the given type is one of the predefined Composite marker types: KV, CoGBK or WindowedValue.

func IsConcrete

func IsConcrete(t reflect.Type) bool

IsConcrete returns true iff the given type is a valid "concrete" data type. Such data must be fully serializable. Functions and channels are examples of invalid types. Aggregate types with no universals are considered concrete here.

func IsContainer

func IsContainer(t reflect.Type) bool

IsContainer returns true iff the given type is an container data type, such as []int or []T.

func IsEqual

func IsEqual(from, to FullType) bool

IsEqual returns true iff the types are equal.

func IsEqualList

func IsEqualList(from, to []FullType) bool

IsEqualList returns true iff the lists of types are equal.

func IsKV

func IsKV(t FullType) bool

IsKV returns true iff the type is a KV.

func IsList

func IsList(t reflect.Type) bool

IsList returns true iff the given type is a slice.

func IsStructurallyAssignable

func IsStructurallyAssignable(from, to FullType) bool

IsStructurallyAssignable returns true iff a from value is structurally assignable to the to value of the given types. Types that are "structurally assignable" (SA) are assignable if type variables are disregarded. In other words, depending on the bindings of universal type variables, types may or may not be assignable. However, types that are not SA are not assignable under any bindings.

For example:

SA:  KV<int,int>    := KV<int,int>
SA:  KV<int,X>      := KV<int,string>  // X bound to string by assignment
SA:  KV<int,string> := KV<int,X>       // Assignable only if X is already bound to string
SA:  KV<int,string> := KV<X,X>         // Not assignable under any binding

Not SA:  KV<int,string> := KV<string,X>
Not SA:  X              := KV<int,string>
Not SA:  GBK(X,Y)       := KV<int,string>

func IsUniversal

func IsUniversal(t reflect.Type) bool

IsUniversal returns true iff the given type is one of the predefined universal types: T, U, V, W, X, Y or Z.

func IsW

func IsW(t FullType) bool

IsW returns true iff the type is a WindowedValue.

Types

type Class

type Class int

Class is the type "class" of data as distinguished by the runtime. The class determines what kind of coding and/or conversion to be inserted. Special types such EventTime, error and reflect.Type are Invalid in this context.

const (
	// Invalid type, such as Function, which is not valid as data.
	Invalid Class = iota
	// Concrete type, such as int, string, struct { .. }.
	Concrete
	// Universal type: T, U, V, W, X, Y, Z. They act as type variables
	// for type checking purposes, but -- unlike type variables -- are
	// not instantiated at runtime.
	Universal
	// Container type: []. A Go-generic container type that both can be
	// represented as a reflect.Type and may incur runtime conversions.
	// The component cannot be a Composite.
	Container
	// Composite type: KV, CoGBk, WindowedValue. Beam-generic types
	// that cannot be represented as a single reflect.Type.
	Composite
)

func ClassOf

func ClassOf(t reflect.Type) Class

ClassOf returns the class of a given type. The class is Invalid, if the type is not suitable as data.

func (Class) String

func (c Class) String() string

type CoGBK

type CoGBK struct{}

type EventTime

type EventTime = mtime.Time

EventTime is a timestamp that Beam understands as attached to an element.

type FullType

type FullType interface {
	// Class returns the class of the FullType. It is never Illegal.
	Class() Class
	// Type returns the Go type at the root of the tree, such as KV, X
	// or int.
	Type() reflect.Type
	// Components returns the real components of the root type, if Composite.
	Components() []FullType
}

FullType represents the tree structure of data types processed by the graph. It allows representation of composite types, such as KV<int, string> or W<CoGBK<int, int>>, as well as "generic" such types, KV<int,T> or CoGBK<X,Y>, where the free "type variables" are the fixed universal types: T, X, etc.

func New

func New(t reflect.Type, components ...FullType) FullType

New constructs a new full type with the given elements. It panics if not valid.

func NewCoGBK

func NewCoGBK(components ...FullType) FullType

NewCoGBK constructs a new CoGBK of the given component types.

func NewKV

func NewKV(components ...FullType) FullType

NewKV constructs a new KV of the given key and value types.

func NewW

func NewW(t FullType) FullType

NewW constructs a new WindowedValue of the given type.

func SkipK

func SkipK(t FullType) FullType

SkipK skips the key in a KV layer, if present. If no, returns the input.

func SkipW

func SkipW(t FullType) FullType

SkipW skips a WindowedValue layer, if present. If no, returns the input.

func Substitute

func Substitute(list []FullType, m map[string]reflect.Type) ([]FullType, error)

Substitute returns types identical to the given types, but with all universals substituted. All free type variables must be present in the substitution.

type KV

type KV struct{}

type T

type T interface{}

type U

type U interface{}

type V

type V interface{}

type W

type W interface{}

type Window

type Window interface {
	// MaxTimestamp returns the the inclusive upper bound of timestamps for values in this window.
	MaxTimestamp() EventTime

	// Equals returns true iff the windows are identical.
	Equals(o Window) bool
}

Window represents a concrete Window.

type WindowedValue

type WindowedValue struct{}

type X

type X interface{}

type Y

type Y interface{}

type Z

type Z interface{}