abstractions

package
v0.0.0-...-1318f34 Latest Latest
Warning

This package is not in the latest version of its module.

 Go to latest Published: Nov 20, 2022 License: MIT Imports: 1 Imported by: 0

Documentation

Index

Constants

This section is empty.

Variables

This section is empty.

Functions

This section is empty.

Types

type AcceptClauseLike 

type AcceptClauseLike interface {
	IsAcceptClause() bool
	GetMessage() Expression
	SetMessage(message Expression)
}

This interface defines the methods supported by all accept-clause-like types.

type Annotation 

type Annotation = any

These type assignments hide the dependencies on the package used to implement the collection types. It preserves the collection interfaces in a way that will allow them to evolve separately as needed. Currently, the interfaces are synchronized.

type Arguments 

type Arguments = col.Sequential[Expression]

These type assignments hide the dependencies on the package used to implement the collection types. It preserves the collection interfaces in a way that will allow them to evolve separately as needed. Currently, the interfaces are synchronized.

type ArithmeticLike 

type ArithmeticLike interface {
	IsArithmetic() bool
	GetFirst() Expression
	SetFirst(first Expression)
	GetOperator() Operator
	SetOperator(operator Operator)
	GetSecond() Expression
	SetSecond(second Expression)
}

This interface defines the methods supported by all arithmetic-like expressions.

type AssociationLike 

type AssociationLike = col.AssociationLike[Primitive, ComponentLike]

These type assignments hide the dependencies on the package used to implement the collection types. It preserves the collection interfaces in a way that will allow them to evolve separately as needed. Currently, the interfaces are synchronized.

type Associative 

type Associative = col.Associative[Primitive, ComponentLike]

These type assignments hide the dependencies on the package used to implement the collection types. It preserves the collection interfaces in a way that will allow them to evolve separately as needed. Currently, the interfaces are synchronized.

type AttributeLike 

type AttributeLike interface {
	GetVariable() string
	SetVariable(variable string)
	GetIndices() Indices
	SetIndices(indices Indices)
}

This interface defines the methods supported by all attribute-like types.

type Binding 

type Binding = col.Binding[Primitive, ComponentLike]

These type assignments hide the dependencies on the package used to implement the collection types. It preserves the collection interfaces in a way that will allow them to evolve separately as needed. Currently, the interfaces are synchronized.

type BlockLike 

type BlockLike interface {
	GetExpression() Expression
	SetExpression(expression Expression)
	GetProcedure() ProcedureLike
	SetProcedure(procedure ProcedureLike)
}

This interface defines the methods supported by all block-like types.

type Blocks 

type Blocks = col.Sequential[BlockLike]

These type assignments hide the dependencies on the package used to implement the collection types. It preserves the collection interfaces in a way that will allow them to evolve separately as needed. Currently, the interfaces are synchronized.

type BreakClauseLike 

type BreakClauseLike interface {
	IsBreakClause() bool
}

This interface defines the methods supported by all break-clause-like types.

type Bytes 

type Bytes = col.Sequential[byte]

type CatalogLike 

type CatalogLike = col.CatalogLike[Primitive, ComponentLike]

These type assignments hide the dependencies on the package used to implement the collection types. It preserves the collection interfaces in a way that will allow them to evolve separately as needed. Currently, the interfaces are synchronized.

type ChainingLike 

type ChainingLike interface {
	IsChaining() bool
	GetFirst() Expression
	SetFirst(first Expression)
	GetOperator() Operator
	SetOperator(operator Operator)
	GetSecond() Expression
	SetSecond(second Expression)
}

This interface defines the methods supported by all chaining-like expressions.

type CheckoutClauseLike 

type CheckoutClauseLike interface {
	IsCheckoutClause() bool
	GetRecipient() Recipient
	SetRecipient(recipient Recipient)
	GetLevel() Expression
	SetLevel(level Expression)
	GetMoniker() Expression
	SetMoniker(moniker Expression)
}

This interface defines the methods supported by all checkout-clause-like types.

type Clause 

type Clause = any

These type assignments hide the dependencies on the package used to implement the collection types. It preserves the collection interfaces in a way that will allow them to evolve separately as needed. Currently, the interfaces are synchronized.

type Collection 

type Collection = col.Value

These type assignments hide the dependencies on the package used to implement the collection types. It preserves the collection interfaces in a way that will allow them to evolve separately as needed. Currently, the interfaces are synchronized.

type CommentLike 

type CommentLike interface {
	Lines
}

This interface defines the interfaces supported by all comment-like types.

type ComparisonLike 

type ComparisonLike interface {
	IsComparison() bool
	GetFirst() Expression
	SetFirst(first Expression)
	GetOperator() Operator
	SetOperator(operator Operator)
	GetSecond() Expression
	SetSecond(second Expression)
}

This interface defines the methods supported by all comparison-like expressions.

type ComplementLike 

type ComplementLike interface {
	IsComplement() bool
	GetOperator() Operator
	SetOperator(operator Operator)
	GetExpression() Expression
	SetExpression(expression Expression)
}

This interface defines the methods supported by all complement-like expressions.

type Complex 

type Complex interface {
	AsRectangular() string
	AsPolar() string
	IsInfinite() bool
	IsUndefined() bool
	GetReal() float64
	GetImaginary() float64
	GetMagnitude() float64
	GetPhase() float64
}

This interface defines the methods supported by all polar elements.

type ComponentLike 

type ComponentLike interface {
	Encapsulated
}

This interface defines the interfaces supported by all component-like types.

type ContextLike 

type ContextLike interface {
	Generic
}

This interface defines the interfaces supported by all context-like types.

type ContinueClauseLike 

type ContinueClauseLike interface {
	IsContinueClause() bool
}

This interface defines the methods supported by all continue-clause-like types.

type Continuous 

type Continuous interface {
	IsZero() bool
	AsReal() float64
}

This interface defines the methods supported by all continuous elements.

type DereferenceLike 

type DereferenceLike interface {
	IsDereference() bool
	GetOperator() Operator
	SetOperator(operator Operator)
	GetExpression() Expression
	SetExpression(expression Expression)
}

This interface defines the methods supported by all dereference-like expressions.

type DiscardClauseLike 

type DiscardClauseLike interface {
	IsDiscardClause() bool
	GetCitation() Expression
	SetCitation(citation Expression)
}

This interface defines the methods supported by all discard-clause-like types.

type Discrete 

type Discrete interface {
	IsZero() bool
	AsBoolean() bool
	AsInteger() int
}

This interface defines the methods supported by all discrete elements.

type Elastic 

type Elastic[V Primitive] interface {
	IsEnumerable() bool
	GetFirst() V
	SetFirst(V)
	GetExtent() Extent
	SetExtent(extent Extent)
	GetLast() V
	SetLast(V)
}

This interface defines the methods supported by all sequences of primitive values that allow their endpoints to be changed. The type is parameterized to force the first and last primitive values to be the same type.

type Element 

type Element = any

type Encapsulated 

type Encapsulated interface {
	GetEntity() Entity
	SetEntity(entity Entity)
	IsGeneric() bool
	GetContext() ContextLike
	SetContext(context ContextLike)
	IsAnnotated() bool
	GetNote() NoteLike
	SetNote(note NoteLike)
}

This interface defines the methods supported by all component-like types.

type Entity 

type Entity = any

These type assignments hide the dependencies on the package used to implement the collection types. It preserves the collection interfaces in a way that will allow them to evolve separately as needed. Currently, the interfaces are synchronized.

type ExponentialLike 

type ExponentialLike interface {
	IsExponential() bool
	GetBase() Expression
	SetBase(base Expression)
	GetOperator() Operator
	SetOperator(operator Operator)
	GetExponent() Expression
	SetExponent(exponent Expression)
}

This interface defines the methods supported by all exponential-like expressions.

type Expression 

type Expression = any

These type assignments hide the dependencies on the package used to implement the collection types. It preserves the collection interfaces in a way that will allow them to evolve separately as needed. Currently, the interfaces are synchronized.

type Extent 

type Extent int
const (
	INCLUSIVE Extent
	LEFT
	RIGHT
	EXCLUSIVE
)

type FIFO 

type FIFO = col.FIFO[ComponentLike]

These type assignments hide the dependencies on the package used to implement the collection types. It preserves the collection interfaces in a way that will allow them to evolve separately as needed. Currently, the interfaces are synchronized.

type Flexible 

type Flexible = col.Flexible[ComponentLike]

These type assignments hide the dependencies on the package used to implement the collection types. It preserves the collection interfaces in a way that will allow them to evolve separately as needed. Currently, the interfaces are synchronized.

type Generic 

type Generic interface {
	GetParameters() Parameters
	SetParameters(parameters Parameters)
}

This interface defines the methods supported by all generic types.

type IfClauseLike 

type IfClauseLike interface {
	IsIfClause() bool
	GetBlock() BlockLike
	SetBlock(block BlockLike)
}

This interface defines the methods supported by all if-clause-like types.

type Indices 

type Indices = col.Sequential[Expression]

These type assignments hide the dependencies on the package used to implement the collection types. It preserves the collection interfaces in a way that will allow them to evolve separately as needed. Currently, the interfaces are synchronized.

type IntrinsicLike 

type IntrinsicLike interface {
	IsIntrinsic() bool
	GetFunction() string
	SetFunction(function string)
	GetArguments() Arguments
	SetArguments(arguments Arguments)
}

This interface defines the methods supported by all intrinsic-like expressions.

type InversionLike 

type InversionLike interface {
	IsInversion() bool
	GetOperator() Operator
	SetOperator(operator Operator)
	GetExpression() Expression
	SetExpression(expression Expression)
}

This interface defines the methods supported by all inversion-like expressions.

type InvocationLike 

type InvocationLike interface {
	IsInvocation() bool
	IsSynchronous() bool
	GetTarget() Expression
	SetTarget(target Expression)
	GetOperator() Operator
	SetOperator(operator Operator)
	GetMessage() string
	SetMessage(message string)
	GetArguments() Arguments
	SetArguments(arguments Arguments)
}

This interface defines the methods supported by all invocation-like expressions.

type ItemLike 

type ItemLike interface {
	IsItem() bool
	GetComposite() Expression
	SetComposite(composite Expression)
	GetIndices() Indices
	SetIndices(indices Indices)
}

This interface defines the methods supported by all item-like expressions.

type LIFO 

type LIFO = col.LIFO[ComponentLike]

These type assignments hide the dependencies on the package used to implement the collection types. It preserves the collection interfaces in a way that will allow them to evolve separately as needed. Currently, the interfaces are synchronized.

type LetClauseLike 

type LetClauseLike interface {
	IsLetClause() bool
	HasRecipient() bool
	GetRecipient() (Recipient, Operator)
	SetRecipient(recipient Recipient, operator Operator)
	GetExpression() Expression
	SetExpression(expression Expression)
}

This interface defines the methods supported by all let-clause-like types.

type Lines 

type Lines = col.Sequential[string]

These type assignments hide the dependencies on the package used to implement the collection types. It preserves the collection interfaces in a way that will allow them to evolve separately as needed. Currently, the interfaces are synchronized.

type ListLike 

type ListLike = col.ListLike[ComponentLike]

These type assignments hide the dependencies on the package used to implement the collection types. It preserves the collection interfaces in a way that will allow them to evolve separately as needed. Currently, the interfaces are synchronized.

type LogicalLike 

type LogicalLike interface {
	IsLogical() bool
	GetFirst() Expression
	SetFirst(first Expression)
	GetOperator() Operator
	SetOperator(operator Operator)
	GetSecond() Expression
	SetSecond(second Expression)
}

This interface defines the methods supported by all logical-like expressions.

type MagnitudeLike 

type MagnitudeLike interface {
	IsMagnitude() bool
	GetExpression() Expression
	SetExpression(expression Expression)
}

This interface defines the methods supported by all magnitude-like expressions.

type Malleable 

type Malleable = col.Malleable[ComponentLike]

These type assignments hide the dependencies on the package used to implement the collection types. It preserves the collection interfaces in a way that will allow them to evolve separately as needed. Currently, the interfaces are synchronized.

type Matchable 

type Matchable interface {
	MatchesText(text string) bool
}

This interface defines the methods supported by all matchable pattern elements.

type Names 

type Names = col.Sequential[string]

type NotarizeClauseLike 

type NotarizeClauseLike interface {
	IsNotarizeClause() bool
	GetDocument() Expression
	SetDocument(document Expression)
	GetMoniker() Expression
	SetMoniker(moniker Expression)
}

This interface defines the methods supported by all notarize-clause-like types.

type NoteLike 

type NoteLike interface {
	Runes
}

This interface defines the interfaces supported by all note-like types.

type OnClauseLike 

type OnClauseLike interface {
	GetException() Symbolic
	SetException(exception Symbolic)
	GetBlocks() Blocks
	SetBlocks(blocks Blocks)
}

This interface defines the methods supported by all on-clause-like types.

type Operator 

type Operator int
const (
	ASSIGN     Operator // :=
	DEFAULT             // ?=
	SUM                 // +=
	DIFFERENCE          // -=
	PRODUCT             // *=
	QUOTIENT            // /=
	DOT                 // .
	ARROW               // <-
	AMPERSAND           // &
	AT                  // @
	BAR                 // |
	TILDA               // ~
	PLUS                // +
	MINUS               // -
	STAR                // *
	SLASH               // /
	MODULO              // //
	CARET               // ^
	LESS                // <
	EQUAL               // =
	UNEQUAL             // ≠
	MORE                // >
	IS                  // IS
	MATCHES             // MATCHES
	NOT                 // NOT
	AND                 // AND
	SANS                // SANS
	OR                  // OR
	XOR                 // XOR
)

type Ordinals 

type Ordinals = col.Sequential[int]

type Parameter 

type Parameter = col.Binding[Symbolic, ComponentLike]

These type assignments hide the dependencies on the package used to implement the collection types. It preserves the collection interfaces in a way that will allow them to evolve separately as needed. Currently, the interfaces are synchronized.

type Parameters 

type Parameters = col.Sequential[col.Binding[Symbolic, ComponentLike]]

These type assignments hide the dependencies on the package used to implement the collection types. It preserves the collection interfaces in a way that will allow them to evolve separately as needed. Currently, the interfaces are synchronized.

type Polarized 

type Polarized interface {
	IsNegative() bool
}

This interface defines the methods supported by all polarized elements.

type PostClauseLike 

type PostClauseLike interface {
	IsPostClause() bool
	GetMessage() Expression
	SetMessage(message Expression)
	GetBag() Expression
	SetBag(bag Expression)
}

This interface defines the methods supported by all post-clause-like types.

type PrecedenceLike 

type PrecedenceLike interface {
	IsPrecedence() bool
	GetExpression() Expression
	SetExpression(expression Expression)
}

This interface defines the methods supported by all precedence-like expressions.

type Primitive 

type Primitive = col.Key

These type assignments hide the dependencies on the package used to implement the collection types. It preserves the collection interfaces in a way that will allow them to evolve separately as needed. Currently, the interfaces are synchronized.

type ProcedureLike 

type ProcedureLike interface {
	GetStatements() Statements
	SetStatements(statements Statements)
}

This interface consolidates all the interfaces supported by procedure-like types.

type PublishClauseLike 

type PublishClauseLike interface {
	IsPublishClause() bool
	GetEvent() Expression
	SetEvent(event Expression)
}

This interface defines the methods supported by all publish-clause-like types.

type QueueLike 

type QueueLike = col.QueueLike[ComponentLike]

These type assignments hide the dependencies on the package used to implement the collection types. It preserves the collection interfaces in a way that will allow them to evolve separately as needed. Currently, the interfaces are synchronized.

type RangeLike 

type RangeLike[V Primitive] interface {
	col.Sequential[V]
	col.Indexed[V]
	Elastic[V]
}

This interface consolidates all of the interfaces supported by range-like sequences.

type Recipient 

type Recipient = any

These type assignments hide the dependencies on the package used to implement the collection types. It preserves the collection interfaces in a way that will allow them to evolve separately as needed. Currently, the interfaces are synchronized.

type RejectClauseLike 

type RejectClauseLike interface {
	IsRejectClause() bool
	GetMessage() Expression
	SetMessage(message Expression)
}

This interface defines the methods supported by all reject-clause-like types.

type RetrieveClauseLike 

type RetrieveClauseLike interface {
	IsRetrieveClause() bool
	GetRecipient() Recipient
	SetRecipient(recipient Recipient)
	GetBag() Expression
	SetBag(bag Expression)
}

This interface defines the methods supported by all retrieve-clause-like types.

type ReturnClauseLike 

type ReturnClauseLike interface {
	IsReturnClause() bool
	GetResult() Expression
	SetResult(result Expression)
}

This interface defines the methods supported by all return-clause-like types.

type Runes 

type Runes = col.Sequential[rune]

These type assignments hide the dependencies on the package used to implement the collection types. It preserves the collection interfaces in a way that will allow them to evolve separately as needed. Currently, the interfaces are synchronized.

type SaveClauseLike 

type SaveClauseLike interface {
	IsSaveClause() bool
	GetDocument() Expression
	SetDocument(document Expression)
	GetRecipient() Recipient
	SetRecipient(recipient Recipient)
}

This interface defines the methods supported by all save-clause-like types.

type Searchable 

type Searchable = col.Searchable[ComponentLike]

These type assignments hide the dependencies on the package used to implement the collection types. It preserves the collection interfaces in a way that will allow them to evolve separately as needed. Currently, the interfaces are synchronized.

type Segmented 

type Segmented interface {
	GetScheme() string
	GetAuthority() string
	GetPath() string
	GetQuery() string
	GetFragment() string
}

This interface defines the methods supported by all segmented resource elements.

type SelectClauseLike 

type SelectClauseLike interface {
	IsSelectClause() bool
	GetTarget() Expression
	SetTarget(control Expression)
	GetBlocks() Blocks
	SetBlocks(blocks Blocks)
}

This interface defines the methods supported by all select-clause-like types.

type SetLike 

type SetLike = col.SetLike[ComponentLike]

These type assignments hide the dependencies on the package used to implement the collection types. It preserves the collection interfaces in a way that will allow them to evolve separately as needed. Currently, the interfaces are synchronized.

type StackLike 

type StackLike = col.StackLike[ComponentLike]

These type assignments hide the dependencies on the package used to implement the collection types. It preserves the collection interfaces in a way that will allow them to evolve separately as needed. Currently, the interfaces are synchronized.

type StatementLike 

type StatementLike interface {
	GetAnnotation() Annotation
	SetAnnotation(annotation Annotation)
	GetMainClause() Clause
	SetMainClause(mainClause Clause)
	GetNote() NoteLike
	SetNote(note NoteLike)
	GetOnClause() OnClauseLike
	SetOnClause(onClause OnClauseLike)
}

This interface defines the methods supported by all statement-like types.

type Statements 

type Statements = col.Sequential[StatementLike]

These type assignments hide the dependencies on the package used to implement the collection types. It preserves the collection interfaces in a way that will allow them to evolve separately as needed. Currently, the interfaces are synchronized.

type String 

type String = any

type Symbolic 

type Symbolic interface {
	GetIdentifier() string
}

This interface defines the methods supported by all symbolic types.

type Temporal 

type Temporal interface {
	// Return the entire time in specific units.
	AsMilliseconds() float64
	AsSeconds() float64
	AsMinutes() float64
	AsHours() float64
	AsDays() float64
	AsWeeks() float64
	AsMonths() float64
	AsYears() float64

	// Return a specific part of the entire time.
	GetMilliseconds() int
	GetSeconds() int
	GetMinutes() int
	GetHours() int
	GetDays() int
	GetWeeks() int
	GetMonths() int
	GetYears() int
}

This interface defines the methods supported by all temporal elements.

type ThrowClauseLike 

type ThrowClauseLike interface {
	IsThrowClause() bool
	GetException() Expression
	SetException(exception Expression)
}

This interface defines the methods supported by all throw-clause-like types.

type Updatable 

type Updatable = col.Updatable[ComponentLike]

These type assignments hide the dependencies on the package used to implement the collection types. It preserves the collection interfaces in a way that will allow them to evolve separately as needed. Currently, the interfaces are synchronized.

type VariableLike 

type VariableLike interface {
	IsVariable() bool
	GetIdentifier() string
}

This interface defines the methods supported by all variable-like expressions.

type WhileClauseLike 

type WhileClauseLike interface {
	IsWhileClause() bool
	GetBlock() BlockLike
	SetBlock(block BlockLike)
}

This interface defines the methods supported by all while-clause-like types.

type WithClauseLike 

type WithClauseLike interface {
	IsWithClause() bool
	GetValue() Symbolic
	SetValue(exception Symbolic)
	GetBlock() BlockLike
	SetBlock(block BlockLike)
}

This interface defines the methods supported by all with-clause-like types.

Source Files

View all Source files

Jump to

Keyboard shortcuts

? : This menu
/ : Search site
f or F : Jump to
y or Y : Canonical URL
go.dev uses cookies from Google to deliver and enhance the quality of its services and to analyze traffic. Learn more.