finos/morphir-ir/common

README
U
Access
U
AccessControlled
U
Annotation
U
AnnotationArgument
U
ApplicationDependencies
U
Constructors
U
Data
U
Dependencies
U
DerivedTypeDetails
U
Distribution
U
Documented
U
EntryPoint
U
EntryPointKind
U
ExternalBinding
U
FQName
U
HoleReason
U
IRFile
U
Incompleteness
U
Literal
U
ModuleDefinition
U
ModuleName
U
ModuleSpecification
U
Name
U
NameError
U
NameSegment
U
NativeHint
U
NativeInfo
U
PackageDefinition
U
PackageName
U
PackageSpecification
U
Path
U
Pattern
U
PatternLiteral
U
SourceLocation
U
Type
U
TypeAttributes
U
TypeDefinition
U
TypeSpecification
U
TypeSpecificationBody
U
Value
U
ValueAttributes
U
ValueDefinition
U
ValueSpecification
V
CURRENT_FORMAT_MAJOR

finos/morphir-ir/common does not have a README file

NameError

pub(all) suberror NameError {
  InvalidName(String)
} derive(Eq, @moonbitlang/core/debug.Debug
Debug)

NameError::equal

source

fn NameError::equal(NameError, NameError) -> Bool

NameError::not_equal

source

fn NameError::not_equal(x : NameError, y : NameError) -> Bool

NameError::to_repr

source

fn NameError::to_repr(NameError) -> @moonbitlang/core/debug.Repr
Repr

Access

source

pub(all) enum Access {
  Public
  Private
} derive(Eq, @moonbitlang/core/debug.Debug
Debug)

Access::equal

source

fn Access::equal(Access, Access) -> Bool

Access::not_equal

source

fn Access::not_equal(x : Access, y : Access) -> Bool

Access::to_repr

source

fn Access::to_repr(Access) -> @moonbitlang/core/debug.Repr
Repr

AccessControlled

source

pub(all) struct AccessControlled[T] {
  access : Access
  value : T
} derive(Eq, @moonbitlang/core/debug.Debug
Debug)

AccessControlled::equal

source

fn[T : Eq] AccessControlled::equal(AccessControlled[T], AccessControlled[T]) -> Bool

AccessControlled::not_equal

source

fn[T : Eq] AccessControlled::not_equal(x : AccessControlled[T], y : AccessControlled[T]) -> Bool

AccessControlled::to_repr

source

fn[T : @moonbitlang/core/debug.Debug
Debug] AccessControlled::to_repr(AccessControlled[T]) -> @moonbitlang/core/debug.Repr
Repr

Data

source

pub(all) enum Data {
  Null
  Boolean(Bool)
  Number(String)
  Text(String)
  Array(Array[Data])
  Object(Map[String, Data])
} derive(Eq, @moonbitlang/core/debug.Debug
Debug)

JSON-shaped extension data. Number lexemes never pass through a floating-point value. This is a data model, not a parser; codecs must validate number lexemes.

Data::equal

source

fn Data::equal(Data, Data) -> Bool

Data::not_equal

source

fn Data::not_equal(x : Data, y : Data) -> Bool

Data::to_repr

source

fn Data::to_repr(Data) -> @moonbitlang/core/debug.Repr
Repr

Documented

source

pub(all) struct Documented[T] {
  doc : String?
  value : T
} derive(Eq, @moonbitlang/core/debug.Debug
Debug)

Documented::equal

source

fn[T : Eq] Documented::equal(Documented[T], Documented[T]) -> Bool

Documented::not_equal

source

fn[T : Eq] Documented::not_equal(x : Documented[T], y : Documented[T]) -> Bool

Documented::to_repr

source

fn[T : @moonbitlang/core/debug.Debug
Debug] Documented::to_repr(Documented[T]) -> @moonbitlang/core/debug.Repr
Repr

FQName

source

pub(all) struct FQName {
  package_name : Path
  module_name : Path
  local_name : Name
} derive(Compare, Eq, Hash, @moonbitlang/core/debug.Debug
Debug)

FQName::compare

source

fn FQName::compare(FQName, FQName) -> Int

FQName::equal

source

fn FQName::equal(FQName, FQName) -> Bool

FQName::hash

source

fn FQName::hash(self : FQName) -> Int

FQName::hash_combine

source

fn FQName::hash_combine(FQName, Hasher) -> Unit

FQName::not_equal

source

fn FQName::not_equal(x : FQName, y : FQName) -> Bool

FQName::op_ge

source

fn FQName::op_ge(x : FQName, y : FQName) -> Bool

FQName::op_gt

source

fn FQName::op_gt(x : FQName, y : FQName) -> Bool

FQName::op_le

source

fn FQName::op_le(x : FQName, y : FQName) -> Bool

FQName::op_lt

source

fn FQName::op_lt(x : FQName, y : FQName) -> Bool

FQName::parse

source

fn FQName::parse(text : String) -> FQName raise NameError

FQName::to_canonical

source

fn FQName::to_canonical(self : FQName) -> String

FQName::to_repr

source

fn FQName::to_repr(FQName) -> @moonbitlang/core/debug.Repr
Repr

Name

source

pub struct Name {
  segments : @moonbitlang/core/list.List
List[NameSegment]
} derive(Compare, Eq, Hash, @moonbitlang/core/debug.Debug
Debug)

Immutable storage keeps names safe as map keys.

Name::compare

source

fn Name::compare(Name, Name) -> Int

Name::equal

source

fn Name::equal(Name, Name) -> Bool

Name::from_words

source

fn Name::from_words(words : Array[String]) -> Name

Decode legacy words using the upstream maximal-single-letter-run rule.

Name::hash

source

fn Name::hash(self : Name) -> Int

Name::hash_combine

source

fn Name::hash_combine(Name, Hasher) -> Unit

Name::not_equal

source

fn Name::not_equal(x : Name, y : Name) -> Bool

Name::op_ge

source

fn Name::op_ge(x : Name, y : Name) -> Bool

Name::op_gt

source

fn Name::op_gt(x : Name, y : Name) -> Bool

Name::op_le

source

fn Name::op_le(x : Name, y : Name) -> Bool

Name::op_lt

source

fn Name::op_lt(x : Name, y : Name) -> Bool

Name::parse

source

fn Name::parse(text : String) -> Name raise NameError

Parse the v4 canonical name grammar without guessing from camel case.

Name::to_canonical

source

fn Name::to_canonical(self : Name) -> String

Name::to_repr

source

fn Name::to_repr(Name) -> @moonbitlang/core/debug.Repr
Repr

Name::to_segments

source

fn Name::to_segments(self : Name) -> Array[NameSegment]

A fresh array; changing it cannot change the name.

Name::to_words

source

fn Name::to_words(self : Name) -> Array[String]

Legacy spelling. Some canonical v4 names have no lossless legacy spelling; version migration must check the round trip instead of silently collapsing them.

NameSegment

source

pub(all) enum NameSegment {
  Word(String)
  Initialism(String)
} derive(Compare, Eq, Hash, @moonbitlang/core/debug.Debug
Debug)

A word and an initialism remain distinct in the semantic name.

NameSegment::compare

source

fn NameSegment::compare(NameSegment, NameSegment) -> Int

NameSegment::equal

source

fn NameSegment::equal(NameSegment, NameSegment) -> Bool

NameSegment::hash

source

fn NameSegment::hash(self : NameSegment) -> Int

NameSegment::hash_combine

source

fn NameSegment::hash_combine(NameSegment, Hasher) -> Unit

NameSegment::not_equal

source

fn NameSegment::not_equal(x : NameSegment, y : NameSegment) -> Bool

NameSegment::op_ge

source

fn NameSegment::op_ge(x : NameSegment, y : NameSegment) -> Bool

NameSegment::op_gt

source

fn NameSegment::op_gt(x : NameSegment, y : NameSegment) -> Bool

NameSegment::op_le

source

fn NameSegment::op_le(x : NameSegment, y : NameSegment) -> Bool

NameSegment::op_lt

source

fn NameSegment::op_lt(x : NameSegment, y : NameSegment) -> Bool

NameSegment::to_repr

source

fn NameSegment::to_repr(NameSegment) -> @moonbitlang/core/debug.Repr
Repr

Path

source

#alias(PackageName)
#alias(ModuleName)
pub struct Path {
  segments : @moonbitlang/core/list.List
List[Name]
} derive(Compare, Eq, Hash, @moonbitlang/core/debug.Debug
Debug)

Path::compare

source

fn Path::compare(Path, Path) -> Int

Path::equal

source

fn Path::equal(Path, Path) -> Bool

Path::from_names

source

fn Path::from_names(segments : Array[Name]) -> Path

Path::hash

source

fn Path::hash(self : Path) -> Int

Path::hash_combine

source

fn Path::hash_combine(Path, Hasher) -> Unit

Path::not_equal

source

fn Path::not_equal(x : Path, y : Path) -> Bool

Path::op_ge

source

fn Path::op_ge(x : Path, y : Path) -> Bool

Path::op_gt

source

fn Path::op_gt(x : Path, y : Path) -> Bool

Path::op_le

source

fn Path::op_le(x : Path, y : Path) -> Bool

Path::op_lt

source

fn Path::op_lt(x : Path, y : Path) -> Bool

Path::parse

source

fn Path::parse(text : String) -> Path raise NameError

Path::to_canonical

source

fn Path::to_canonical(self : Path) -> String

Path::to_names

source

fn Path::to_names(self : Path) -> Array[Name]

Path::to_repr

source

fn Path::to_repr(Path) -> @moonbitlang/core/debug.Repr
Repr

#NameError

#NameError::equal

#NameError::not_equal

#NameError::to_repr

#Access

#Access::equal

#Access::not_equal

#Access::to_repr

#AccessControlled

#AccessControlled::equal

#AccessControlled::not_equal

#AccessControlled::to_repr

#Data

#Data::equal

#Data::not_equal

#Data::to_repr

#Documented

#Documented::equal

#Documented::not_equal

#Documented::to_repr

#FQName

#FQName::compare

#FQName::equal

#FQName::hash

#FQName::hash_combine

#FQName::not_equal

#FQName::op_ge

#FQName::op_gt

#FQName::op_le

#FQName::op_lt

#FQName::parse

#FQName::to_canonical

#FQName::to_repr

#Name

#Name::compare

#Name::equal

#Name::from_words

#Name::hash

#Name::hash_combine

#Name::not_equal

#Name::op_ge

#Name::op_gt

#Name::op_le

#Name::op_lt

#Name::parse

#Name::to_canonical

#Name::to_repr

#Name::to_segments

#Name::to_words

#NameSegment

#NameSegment::compare

#NameSegment::equal

#NameSegment::hash

#NameSegment::hash_combine

#NameSegment::not_equal

#NameSegment::op_ge

#NameSegment::op_gt

#NameSegment::op_le

#NameSegment::op_lt

#NameSegment::to_repr

#Path

#Path::compare

#Path::equal

#Path::from_names

#Path::hash

#Path::hash_combine

#Path::not_equal

#Path::op_ge

#Path::op_gt

#Path::op_le

#Path::op_lt

#Path::parse

#Path::to_canonical

#Path::to_names

#Path::to_repr

Source Files

NameError

NameError::equal

NameError::not_equal

NameError::to_repr

Access

Access::equal

Access::not_equal

Access::to_repr

AccessControlled

AccessControlled::equal

AccessControlled::not_equal

AccessControlled::to_repr

Data

Data::equal

Data::not_equal

Data::to_repr

Documented

Documented::equal

Documented::not_equal

Documented::to_repr

FQName

FQName::compare

FQName::equal

FQName::hash

FQName::hash_combine

FQName::not_equal

FQName::op_ge

FQName::op_gt

FQName::op_le

FQName::op_lt

FQName::parse

FQName::to_canonical

FQName::to_repr

Name

Name::compare

Name::equal

Name::from_words

Name::hash

Name::hash_combine

Name::not_equal

Name::op_ge

Name::op_gt

Name::op_le

Name::op_lt

Name::parse

Name::to_canonical

Name::to_repr

Name::to_segments

Name::to_words

NameSegment

NameSegment::compare

NameSegment::equal

NameSegment::hash

NameSegment::hash_combine

NameSegment::not_equal

NameSegment::op_ge

NameSegment::op_gt

NameSegment::op_le

NameSegment::op_lt

NameSegment::to_repr

Path

Path::compare

Path::equal

Path::from_names

Path::hash

Path::hash_combine

Path::not_equal

Path::op_ge

Path::op_gt

Path::op_le

Path::op_lt

Path::parse

Path::to_canonical

Path::to_names

Path::to_repr