abstractions

package
v0.0.0-...-d9996d1 Latest Latest
Warning

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

 Go to latest Published: Mar 14, 2023 License: MIT Imports: 0 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 {
	GetMessage() Expression
	SetMessage(message Expression)
}

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

type Accessible 

type Accessible[V Value] interface {
	GetValue(index int) V
	GetValues(first int, last int) Sequential[V]
}

This interface defines the methods supported by all sequences whose values can be accessed using indices. The indices of an accessible sequence are ORDINAL rather than ZERO based (which is "SO last century"). This allows for positive indices starting at the beginning of the sequence, and negative indices starting at the end of the sequence as follows: 

    1           2           3             N
[value 1] . [value 2] . [value 3] ... [value N]
   -N        -(N-1)      -(N-2)          -1

Notice that because the indices are ordinal based, the positive and negative indices are symmetrical.

type AngleLike 

type AngleLike interface {
	Continuous
}

type Annotation 

type Annotation any

type ArithmeticLike 

type ArithmeticLike interface {
	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 AssociationIteratorLike 

type AssociationIteratorLike interface {
	Ratcheted[AssociationLike]
}

type AssociationLike 

type AssociationLike interface {
	Binding[Primitive, ComponentLike]
}

type Associative 

type Associative[K Key, V Value] interface {
	GetKeys() Sequential[K]
	GetValues(keys Sequential[K]) Sequential[V]
	GetValue(key K) V
	SetValue(key K, value V)
	RemoveValue(key K) V
	RemoveValues(keys Sequential[K]) Sequential[V]
	RemoveAll()
}

This interface defines the methods supported by all associative sequences whose values consist of key-value pair associations.

type AttributeLike 

type AttributeLike interface {
	GetVariable() string
	SetVariable(variable string)
	GetIndices() Sequential[Expression]
	SetIndices(indices Sequential[Expression])
}

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

type BinaryLike 

type BinaryLike interface {
	Lexical
	Sequential[byte]
	Accessible[byte]
}

type Binding 

type Binding[K Key, V Value] interface {
	GetKey() K
	GetValue() V
	SetValue(value V)
}

This interface defines the methods supported by all binding types. It binds a readonly key with a setable value.

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 BooleanLike 

type BooleanLike interface {
	Discrete
}

type Bounded 

type Bounded[V Primitive] interface {
	GetFirst() V
	SetFirst(value V)
	GetExtent() Extent
	SetExtent(extent Extent)
	GetLast() V
	SetLast(value V)
}

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

type BreakClauseLike 

type BreakClauseLike interface {
}

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

type ByteIteratorLike 

type ByteIteratorLike interface {
	Ratcheted[byte]
}

type BytecodeLike 

type BytecodeLike interface {
	Lexical
	Sequential[Instruction]
	Accessible[Instruction]
}

type CatalogLike 

type CatalogLike interface {
	Sequential[AssociationLike]
	Associative[Primitive, ComponentLike]
	Sortable[AssociationLike]
}

type CertificateLike 

type CertificateLike interface {
	Encapsulated
	Published
	Typed
	Restricted
	Versioned
}

type Certified 

type Certified interface {
	GenerateCredentials(salt BinaryLike) ContractLike
	NotarizeDocument(document DocumentLike) ContractLike
	SignatureMatches(contract ContractLike, certificate CertificateLike) bool
	CiteDocument(document DocumentLike) CitationLike
	CitationMatches(citation CitationLike, document DocumentLike) bool
}

This interface defines the methods supported by all certified notary agents.

type ChainingLike 

type ChainingLike interface {
	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 {
	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 CitationLike 

type CitationLike interface {
	Encapsulated
	Referential
	Typed
}

type Clause 

type Clause any

type Collection 

type Collection any

type CommentLike 

type CommentLike interface {
	Sequential[string]
}

type ComparisonLike 

type ComparisonLike interface {
	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 {
	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 {
	AsComplex() complex128
	GetReal() float64
	GetImaginary() float64
	GetMagnitude() float64
	GetPhase() AngleLike
}

This interface defines the methods supported by all complex elements.

type ComponentIteratorLike 

type ComponentIteratorLike interface {
	Ratcheted[ComponentLike]
}

type ComponentLike 

type ComponentLike interface {
	Encapsulated
}

type ConfiguratorLike 

type ConfiguratorLike interface {
	Custodial
}

type ContextLike 

type ContextLike interface {
	Parameterized
}

type ContinueClauseLike 

type ContinueClauseLike interface {
}

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

type Continuous 

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

This interface defines the methods supported by all continuum endpoints.

type ContinuumLike 

type ContinuumLike[V Continuous] interface {
	Bounded[V]
	Searchable[V]
}

type ContractLike 

type ContractLike interface {
	Encapsulated
	Notarized
	Typed
}

type ControllerLike 

type ControllerLike interface {
	Mechanized
}

type CredentialsLike 

type CredentialsLike interface {
	Encapsulated
	Salted
	Typed
	Restricted
	Versioned
}

type Custodial 

type Custodial interface {
	Exists() bool
	Load() []byte
	Store(configuration []byte)
	Delete()
}

This interface defines the methods supported by all custodial agents.

type DereferenceLike 

type DereferenceLike interface {
	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 {
	GetDocument() Expression
	SetDocument(document Expression)
}

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

type Discrete 

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

This interface defines the methods supported by all interval endpoints.

type DocumentLike 

type DocumentLike interface {
	Encapsulated
	Typed
	Restricted
	Versioned
}

type DurationLike 

type DurationLike interface {
	Discrete
	Polarized
	Temporal
}

type Element 

type Element any

type Encapsulated 

type Encapsulated interface {
	GetEntity() Entity
	SetEntity(entity Entity)
	ExtractAngle() AngleLike
	ExtractBinary() BinaryLike
	ExtractBoolean() BooleanLike
	ExtractCatalog() CatalogLike
	ExtractContinuum() ContinuumLike[Continuous]
	ExtractDuration() DurationLike
	ExtractInterval() IntervalLike[Discrete]
	ExtractList() ListLike
	ExtractMoment() MomentLike
	ExtractMoniker() MonikerLike
	ExtractNarrative() NarrativeLike
	ExtractNumber() NumberLike
	ExtractPattern() PatternLike
	ExtractPercentage() PercentageLike
	ExtractProbability() ProbabilityLike
	ExtractProcedure() ProcedureLike
	ExtractQueue() QueueLike
	ExtractQuote() QuoteLike
	ExtractResource() ResourceLike
	ExtractSet() SetLike
	ExtractSpectrum() SpectrumLike[Lexical]
	ExtractStack() StackLike
	ExtractSymbol() SymbolLike
	ExtractTag() TagLike
	ExtractVersion() VersionLike
	IsParameterized() 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

type ExponentialLike 

type ExponentialLike interface {
	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

type Extent 

type Extent int
const (
	INCLUSIVE Extent
	LEFT
	RIGHT
	EXCLUSIVE
)

This type and its associated constants define whether or not each endpoint in a bounded collection is included in the range of possible values.

type FIFO 

type FIFO[V Value] interface {
	GetCapacity() int
	AddValue(value V)
	RemoveHead() (head V, ok bool)
	CloseQueue()
}

This interface defines the methods supported by all sequences whose values are accessed using first-in-first-out (FIFO) semantics.

type Flexible 

type Flexible[V Value] interface {
	AddValue(value V)
	AddValues(values Sequential[V])
	RemoveValue(value V)
	RemoveValues(values Sequential[V])
	RemoveAll()
}

This interface defines the methods supported by all sequences of values that allow values to be added and removed.

type Hardened 

type Hardened interface {
	GetTag() string
	GenerateKeys() []byte
	SignBytes(bytes []byte) []byte
	RotateKeys() []byte
	EraseKeys()
}

This interface defines the methods supported by all hardened security modules.

type IfClauseLike 

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

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

type Instruction 

type Instruction uint16

func InstructionFromBytes 

func InstructionFromBytes(leftByte, rightByte byte) Instruction

func (Instruction) GetLeftByte 

func (v Instruction) GetLeftByte() byte

func (Instruction) GetRightByte 

func (v Instruction) GetRightByte() byte

type InstructionIteratorLike 

type InstructionIteratorLike interface {
	Ratcheted[Instruction]
}

type IntegerLike 

type IntegerLike interface {
	Discrete
	Polarized
}

type IntervalLike 

type IntervalLike[V Discrete] interface {
	Bounded[V]
	Sequential[V]
	Accessible[V]
	Searchable[V]
}

type IntrinsicLike 

type IntrinsicLike interface {
	GetFunction() string
	SetFunction(function string)
	GetArguments() Sequential[Expression]
	SetArguments(arguments Sequential[Expression])
}

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

type InversionLike 

type InversionLike interface {
	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 {
	IsSynchronous() bool
	GetTarget() Expression
	SetTarget(target Expression)
	GetOperator() Operator
	SetOperator(operator Operator)
	GetMessage() string
	SetMessage(message string)
	GetArguments() Sequential[Expression]
	SetArguments(arguments Sequential[Expression])
}

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

type Key 

type Key any

type LIFO 

type LIFO[V Value] interface {
	GetCapacity() int
	AddValue(value V)
	GetTop() V
	RemoveTop() V
	RemoveAll()
}

This interface defines the methods supported by all sequences whose values are accessed using last-in-first-out (LIFO) semantics.

type LetClauseLike 

type LetClauseLike interface {
	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 Lexical 

type Lexical interface {
	AsString() string
}

This interface defines the methods supported by all spectrum endpoints.

type Line 

type Line string

type LineIteratorLike 

type LineIteratorLike interface {
	Ratcheted[Line]
}

type ListLike 

type ListLike interface {
	Sequential[ComponentLike]
	Accessible[ComponentLike]
	Updatable[ComponentLike]
	Searchable[ComponentLike]
	Malleable[ComponentLike]
	Sortable[ComponentLike]
}

type LogicalLike 

type LogicalLike interface {
	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 {
	GetExpression() Expression
	SetExpression(expression Expression)
}

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

type Malleable 

type Malleable[V Value] interface {
	AddValue(value V)
	AddValues(values Sequential[V])
	InsertValue(slot int, value V)
	InsertValues(slot int, values Sequential[V])
	RemoveValue(index int) V
	RemoveValues(first int, last int) Sequential[V]
	RemoveAll()
}

This interface defines the methods supported by all indexed sequences whose values may be added, inserted, or removed.

type MappingLike 

type MappingLike interface {
	Sequential[AssociationLike]
}

type Matchable 

type Matchable interface {
	MatchesText(text string) bool
	GetMatches(text string) []string
}

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

type Mechanized 

type Mechanized interface {
	GetState() int
	SetState(state int)
	TransitionState(event int) int
}

This interface defines the methods supported by all mechanized agents.

type MomentLike 

type MomentLike interface {
	Discrete
	Temporal
}

type MonikerLike 

type MonikerLike interface {
	Lexical
	Sequential[Name]
	Accessible[Name]
}

type Name 

type Name string

type NameIteratorLike 

type NameIteratorLike interface {
	Ratcheted[Name]
}

type NarrativeLike 

type NarrativeLike interface {
	Lexical
	Sequential[Line]
	Accessible[Line]
}

type NotarizeClauseLike 

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

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

type Notarized 

type Notarized interface {
	GetDocument() DocumentLike
	GetTimestamp() MomentLike
	GetAccount() TagLike
	GetProtocol() VersionLike
	GetCertificate() CitationLike
	AddSignature(signature BinaryLike)
	RemoveSignature() BinaryLike
}

This interface defines the methods supported by all notarized components.

type NotaryLike 

type NotaryLike interface {
	Prudent
	Certified
}

type NoteLike 

type NoteLike interface {
	Sequential[rune]
}

type NumberLike 

type NumberLike interface {
	Continuous
	Polarized
	Complex
}

type OnClauseLike 

type OnClauseLike interface {
	GetFailure() SymbolLike
	SetFailure(failure SymbolLike)
	GetBlocks() Sequential[BlockLike]
	SetBlocks(blocks Sequential[BlockLike])
}

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 Ordinal 

type Ordinal uint

type OrdinalIteratorLike 

type OrdinalIteratorLike interface {
	Ratcheted[Ordinal]
}

type ParameterLike 

type ParameterLike interface {
	Binding[SymbolLike, ComponentLike]
}

type Parameterized 

type Parameterized interface {
	GetNames() Sequential[SymbolLike]
	GetValue(name SymbolLike) ComponentLike
	SetValue(name SymbolLike, value ComponentLike)
}

This interface defines the methods supported by all parameterized sequences whose values consist of name-value pairs.

type PatternLike 

type PatternLike interface {
	Lexical
	Matchable
}

type PercentageLike 

type PercentageLike interface {
	Discrete
	Continuous
	Polarized
}

type Polarized 

type Polarized interface {
	IsNegative() bool
}

This interface defines the methods supported by all polarized elements.

type PostClauseLike 

type PostClauseLike interface {
	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 {
	GetExpression() Expression
	SetExpression(expression Expression)
}

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

type Primitive 

type Primitive any

type ProbabilityLike 

type ProbabilityLike interface {
	Discrete
	Continuous
}

type ProcedureLike 

type ProcedureLike interface {
	Sequential[StatementLike]
}

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

type Prudent 

type Prudent interface {
	GenerateKey() ContractLike
	GetCitation() CitationLike
	RefreshKey() ContractLike
	ForgetKey()
}

This interface defines the methods supported by all prudent notary agents.

type PublishClauseLike 

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

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

type Published 

type Published interface {
	GetAlgorithms() CatalogLike
	GetKey() BinaryLike
}

This interface defines the methods supported by all published components.

type QueueLike 

type QueueLike interface {
	Sequential[ComponentLike]
	FIFO[ComponentLike]
}

type QuoteLike 

type QuoteLike interface {
	Lexical
	Sequential[rune]
	Accessible[rune]
}

type Range 

type Range any

type Ratcheted 

type Ratcheted[V Value] interface {
	GetSlot() int
	ToSlot(slot int)
	ToStart()
	ToEnd()
	HasPrevious() bool
	GetPrevious() V
	HasNext() bool
	GetNext() V
}

This interface defines the methods supported by all ratcheted agents that are capable of moving forward and backward over the values in a sequence. It is used to implement the GoF Iterator Pattern:

A ratcheted agent locks into the slots that reside between each value in the sequence: 

    [value 1] . [value 2] . [value 3] ... [value N]
  ^           ^           ^                         ^
slot 0      slot 1      slot 2                    slot N

It moves from slot to slot and has access to the values (if they exist) on each side of the slot.

type RealLike 

type RealLike interface {
	Continuous
	Polarized
}

type Recipient 

type Recipient any

type Referential 

type Referential interface {
	GetTag() TagLike
	GetVersion() VersionLike
	GetProtocol() VersionLike
	GetDigest() BinaryLike
}

This interface defines the methods supported by all referential components.

type RejectClauseLike 

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

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

type ResourceLike 

type ResourceLike interface {
	Lexical
	Segmented
}

type Restricted 

type Restricted interface {
	GetPermissions() MonikerLike
}

This interface defines the methods supported by all restricted components.

type RetrieveClauseLike 

type RetrieveClauseLike interface {
	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 {
	GetResult() Expression
	SetResult(result Expression)
}

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

type RuneIteratorLike 

type RuneIteratorLike interface {
	Ratcheted[rune]
}

type RuneLike 

type RuneLike interface {
	Discrete
}

type Salted 

type Salted interface {
	GetSalt() BinaryLike
}

This interface defines the methods supported by all salted components.

type SaveClauseLike 

type SaveClauseLike interface {
	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[V Value] interface {
	GetIndex(value V) int
	ContainsValue(value V) bool
	ContainsAny(values Sequential[V]) bool
	ContainsAll(values Sequential[V]) bool
}

This interface defines the methods supported by all searchable sequences of values.

type SecurityModuleLike 

type SecurityModuleLike interface {
	Trusted
	Hardened
}

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 {
	GetTarget() Expression
	SetTarget(control Expression)
	GetBlocks() Sequential[BlockLike]
	SetBlocks(blocks Sequential[BlockLike])
}

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

type Sequential 

type Sequential[V Value] interface {
	IsEmpty() bool
	GetSize() int
	AsArray() []V
}

This interface defines the methods supported by all sequences of values.

type SeriesLike 

type SeriesLike interface {
	Sequential[ComponentLike]
}

type SetLike 

type SetLike interface {
	Sequential[ComponentLike]
	Accessible[ComponentLike]
	Searchable[ComponentLike]
	Flexible[ComponentLike]
}

type Sortable 

type Sortable[V Value] interface {
	SortValues()
	ReverseValues()
	ShuffleValues()
}

This interface defines the methods supported by all sequences whose values may be sorted using various sorting algorithms.

type SpectrumLike 

type SpectrumLike[V Lexical] interface {
	Bounded[V]
	Searchable[V]
}

type StackLike 

type StackLike interface {
	Sequential[ComponentLike]
	LIFO[ComponentLike]
}

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 String 

type String any

type SubcomponentLike 

type SubcomponentLike interface {
	GetComposite() Expression
	SetComposite(composite Expression)
	GetIndices() Sequential[Expression]
	SetIndices(indices Sequential[Expression])
}

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

type SymbolLike 

type SymbolLike interface {
	Lexical
	Sequential[rune]
}

type TagLike 

type TagLike interface {
	Lexical
	Sequential[byte]
}

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 {
	GetException() Expression
	SetException(exception Expression)
}

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

type Trusted 

type Trusted interface {
	GetProtocol() string
	DigestBytes(bytes []byte) []byte
	IsValid(key []byte, signature []byte, bytes []byte) bool
}

This interface defines the methods supported by all trusted security modules.

type TypeLike 

type TypeLike interface {
	Encapsulated
	Typed
}

type Typed 

type Typed interface {
	GetType() MonikerLike
}

This interface defines the methods supported by all typed components.

type Updatable 

type Updatable[V Value] interface {
	SetValue(index int, value V)
	SetValues(index int, values Sequential[V])
}

This interface defines the methods supported by all updatable sequences of values.

type Value 

type Value any

type VariableLike 

type VariableLike interface {
	GetIdentifier() string
	SetIdentifier(identifier string)
}

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

type VersionLike 

type VersionLike interface {
	Lexical
	Sequential[Ordinal]
	Accessible[Ordinal]
}

type Versioned 

type Versioned interface {
	GetTag() TagLike
	GetVersion() VersionLike
	GetPrevious() CitationLike
}

This interface defines the methods supported by all versioned components.

type WhileClauseLike 

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

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

type WithClauseLike 

type WithClauseLike interface {
	GetItem() SymbolLike
	SetItem(item SymbolLike)
	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.