Options
All
  • Public
  • Public/Protected
  • All
Menu

Class AbstractRecordStreamlet<I, O>

Type parameters

  • I: Value

  • O: Value

Hierarchy

Implements

Index

Constructors

constructor

Properties

Protected context

context: StreamletContext | null

Protected scope

scope: StreamletScope<O> | null

Accessors

key

  • get key(): Value

length

  • get length(): number

Methods

alias

  • alias(): void

and

appended

attr

bind

bindInput

  • bindInput(key: string, input: Outlet<I>): void

bitwiseAnd

bitwiseNot

  • bitwiseNot(): Value

bitwiseOr

bitwiseXor

body

  • body(): Value

booleanValue

  • booleanValue(): boolean | undefined
  • booleanValue<T>(orElse: T): boolean | T

branch

cast

  • cast<T>(form: Form<T, unknown>): T | undefined
  • cast<T, E>(form: Form<T, unknown>, orElse: E): T | E

castInput

  • castInput<T>(inlet: Inlet<I> | string, form: Form<T, unknown>): T | undefined
  • castInput<T, E>(inlet: Inlet<I> | string, form: Form<T, unknown>, orElse: E): T | E

clear

  • clear(): void

clone

coerce

  • coerce<T>(form: Form<T, unknown>): T
  • coerce<T, E>(form: Form<T, unknown>, orElse: E): T | E

coerceInput

  • coerceInput<T>(inlet: Inlet<I> | string, form: Form<T, unknown>): T
  • coerceInput<T, E>(inlet: Inlet<I> | string, form: Form<T, unknown>, orElse: E): T | E

commit

  • commit(): this

compareTo

  • compareTo(that: Item): 0 | 1 | -1

compile

  • compile(): void

compileInlet

  • compileInlet(inlet: Inlet<I>, name: string): void

concat

conditional

debug

delete

deleted

Protected didInvalidate

  • didInvalidate(): void

didInvalidateInlet

  • didInvalidateInlet(inlet: Inlet<I>): void

didInvalidateOutlet

  • didInvalidateOutlet(outlet: Outlet<O>): void

Protected didReconcile

  • didReconcile(version: number): void

didReconcileInlet

  • didReconcileInlet(inlet: Inlet<I>, version: number): void

didReconcileOutlet

  • didReconcileOutlet(outlet: Outlet<O>, version: number): void

disconnectInputs

  • disconnectInputs(): void

disconnectOutputs

  • disconnectOutputs(): void

display

  • display(output: Output): void

divide

eq

equals

  • equals(that: unknown): boolean

evaluate

fieldCount

  • fieldCount(): number

filter

flattened

  • flattened(): Value
  • Returns the sole member of this Record, if this Record has exactly one member, and its member is a Value; returns Extant if this Record is empty; otherwise returns this if this Record has more than one member.

    Used to convert a unary Record into its member Value. Facilitates writing code that treats a unary Record equivalently to a bare Value.

    Returns Value

forEach

  • forEach<T, S>(callback: function, thisArg?: S): T | undefined

ge

get

getAttr

getField

getInput

  • getInput<I2>(inlet: Inlet<I2> | string): I2 | undefined
  • getInput<I2, E>(inlet: Inlet<I2> | string, orElse: E): I2 | E

getItem

  • getItem(index: AnyNum): Item

getOutput

  • getOutput(outlet: Outlet<O> | string): O | undefined

getSlot

gt

has

hashCode

  • hashCode(): number

head

  • head(): Item

header

  • header(tag: string): Value
  • Returns the value of the first member of this Record, if the first member is an Attr whose key string is equal to tag; otherwise returns Absent if the first member of this Record is not an Attr, or if the first member of this Record is an Attr whose key does not equal the tag.

    Used to conditionally get the value of the head Attr of a structure, if and only if the key string of the head Attr is equal to the tag. Can be used to check if a structure might conform to a nominal type named tag, while simultaneously getting the value of the tag attribute.

    Parameters

    • tag: string

    Returns Value

headers

  • headers(tag: string): Record | undefined

indexOf

  • indexOf(item: AnyItem, index?: number): number

inlet

  • inlet(key: string): Inlet<I> | null
  • inlet<I2>(): Inlet<I2>

inoutlet

invalidate

  • invalidate(): void

inverse

  • inverse(): Value

invoke

  • invoke(args: Value): Item

isAliased

  • isAliased(): boolean

isArray

  • isArray(): boolean

isConstant

  • isConstant(): boolean

isDefined

  • isDefined(): boolean

isDistinct

  • isDistinct(): boolean

isEmpty

  • isEmpty(): boolean

isMutable

  • isMutable(): boolean

isObject

  • isObject(): boolean

item

items

iterator

keyEquals

  • keyEquals(key: unknown): boolean

lambda

  • lambda(template: Value): Value

lastIndexOf

  • lastIndexOf(item: AnyItem, index?: undefined | number): number

le

lt

max

  • max(that: Item): Item

min

  • min(that: Item): Item

minus

modulo

ne

negative

  • negative(): Value

not

  • not(): Value

numberValue

  • numberValue(): number | undefined
  • numberValue<T>(orElse: T): number | T

Protected onInvalidate

  • onInvalidate(): void

Protected onInvalidateOutlets

  • onInvalidateOutlets(): void

Protected onReconcile

  • onReconcile(version: number): void

Protected onReconcileInlets

  • onReconcileInlets(version: number): void

Protected onReconcileOutlets

  • onReconcileOutlets(version: number): void

or

outlet

plus

positive

  • positive(): Value

prepended

push

  • push(...items: AnyItem[]): number

reconcile

  • reconcile(version: number): void

set

setAttr

setItem

  • setItem(index: number, item: AnyItem): this

setSlot

setStreamletContext

setStreamletScope

slice

  • slice(lower?: undefined | number, upper?: undefined | number): Record

slot

splice

  • splice(start: number, deleteCount?: undefined | number, ...newItems: AnyItem[]): Item[]

Protected streamletClass

  • streamletClass(): StreamletClass

streamletContext

streamletScope

stringValue

  • stringValue(): string | undefined
  • stringValue<T>(orElse: T): string | T

subRecord

  • subRecord(lower?: undefined | number, upper?: undefined | number): Record

substitute

tag

  • tag(): string | undefined
  • Returns the key string of the first member of this Record, if the first member is an Attr; otherwise returns undefined if the first member is not an Attr.

    Used to concisely get the name of the discriminating attribute of a structure. The tag can be used to discern the nominal type of a polymorphic structure, similar to an XML element tag.

    Returns string | undefined

tail

target

  • target(): Value

times

toAny

toArray

toObject

  • toObject(): object

toRecon

  • toRecon(): string

toReconBlock

  • toReconBlock(): string

toString

  • toString(): string

toValue

  • toValue(): Value

typeOrder

  • typeOrder(): number

unbindInput

  • unbindInput(key: string): void

unflattened

updated

updatedAttr

updatedSlot

valueCount

  • valueCount(): number

Protected willInvalidate

  • willInvalidate(): void

willInvalidateInlet

  • willInvalidateInlet(inlet: Inlet<I>): void

willInvalidateOutlet

  • willInvalidateOutlet(outlet: Outlet<O>): void

Protected willReconcile

  • willReconcile(version: number): void

willReconcileInlet

  • willReconcileInlet(inlet: Inlet<I>, version: number): void

willReconcileOutlet

  • willReconcileOutlet(outlet: Outlet<O>, version: number): void

Static absent

  • absent(): Value

Static builder

Static create

  • create(initialCapacity?: undefined | number): Record

Static empty

Static extant

  • extant(): Value

Static fromAny

Static fromArray

  • fromArray(array: object): Record

Static fromObject

  • fromObject(object: object): Record

Static globalScope

  • globalScope(): Item

Static of

Static parseRecon

  • parseRecon(recon: string): Value