finos/morphir-ir/versions/v3

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/versions/v3 does not have a README file

Access

using @finos/morphir-ir/common { type Access }

AccessControlled

source

using @finos/morphir-ir/common { type AccessControlled }

Constructors

source

type Constructors[A] = Map[@finos/morphir-ir/common.Name
Name, Array[(@finos/morphir-ir/common.Name
Name, Type[A])]]

Mutable linked hash map that maintains the order of insertion, not thread safe.

Example

test {
  let map = { 3: "three", 8: "eight", 1: "one" }
  @test.assert_eq(map.get(2), None)
  @test.assert_eq(map.get(3), Some("three"))
  map.set(3, "updated")
  @test.assert_eq(map.get(3), Some("updated"))
}

Dependencies

source

type Dependencies = Map[@finos/morphir-ir/common.Path
Path, PackageSpecification[Unit]]

Mutable linked hash map that maintains the order of insertion, not thread safe.

Example

test {
  let map = { 3: "three", 8: "eight", 1: "one" }
  @test.assert_eq(map.get(2), None)
  @test.assert_eq(map.get(3), Some("three"))
  map.set(3, "updated")
  @test.assert_eq(map.get(3), Some("updated"))
}

FQName

source

using @finos/morphir-ir/common { type FQName }

ModuleName

source

using @finos/morphir-ir/common { type Path as ModuleName }

Name

source

using @finos/morphir-ir/common { type Name }

Immutable storage keeps names safe as map keys.

NameError

source

using @finos/morphir-ir/common { type NameError }

NameSegment

source

using @finos/morphir-ir/common { type NameSegment }

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

PackageName

source

using @finos/morphir-ir/common { type Path as PackageName }

Path

source

using @finos/morphir-ir/common { type Path }

RawValue

source

type RawValue = Value[Unit, Unit]

TypedValue

source

type TypedValue = Value[Unit, Type[Unit]]

DerivedTypeDetails

source

pub(all) struct DerivedTypeDetails[A] {
  base_type : Type[A]
  from_base_type : @finos/morphir-ir/common.FQName
FQName
  to_base_type : @finos/morphir-ir/common.FQName
FQName
} derive(Eq, @moonbitlang/core/debug.Debug
Debug)

DerivedTypeDetails::equal

source

fn[A : Eq] DerivedTypeDetails::equal(DerivedTypeDetails[A], DerivedTypeDetails[A]) -> Bool

DerivedTypeDetails::not_equal

source

fn[A : Eq] DerivedTypeDetails::not_equal(x : DerivedTypeDetails[A], y : DerivedTypeDetails[A]) -> Bool

DerivedTypeDetails::to_repr

source

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

Distribution

source

pub(all) enum Distribution {
  Library(@finos/morphir-ir/common.Path
Path, Map[@finos/morphir-ir/common.Path
Path, PackageSpecification[Unit]], PackageDefinition[Unit, Type[Unit]])
  Specs(@finos/morphir-ir/common.Path
Path, Map[@finos/morphir-ir/common.Path
Path, PackageSpecification[Unit]], PackageSpecification[Unit])
} derive(Eq, @moonbitlang/core/debug.Debug
Debug)

Distribution::equal

source

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

Distribution::not_equal

source

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

Distribution::to_repr

source

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

Documented

source

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

Elm documentation defaults to the empty string when its wrapper is absent.

Documented::equal

source

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

Documented::not_equal

source

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

Documented::to_repr

source

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

Field

source

pub(all) struct Field[A] {
  name : @finos/morphir-ir/common.Name
Name
  tpe : Type[A]
} derive(Eq, @moonbitlang/core/debug.Debug
Debug)

Field::equal

source

fn[A : Eq] Field::equal(Field[A], Field[A]) -> Bool

Field::not_equal

source

fn[A : Eq] Field::not_equal(x : Field[A], y : Field[A]) -> Bool

Field::to_repr

source

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

IRFile

source

pub struct IRFile {
  format_version : @finos/morphir-ir/version.FormatVersion
FormatVersion
  distribution : Distribution
} derive(Eq, @moonbitlang/core/debug.Debug
Debug)

An envelope cannot be constructed with a mismatching format family.

IRFile::equal

source

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

IRFile::new

source

fn IRFile::new(distribution : Distribution, format_version? : @finos/morphir-ir/version.FormatVersion
FormatVersion) -> IRFile raise @finos/morphir-ir/version.VersionError
VersionError

IRFile::not_equal

source

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

IRFile::to_repr

source

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

Literal

source

pub(all) enum Literal {
  BoolLiteral(Bool)
  CharLiteral(Char)
  StringLiteral(String)
  WholeNumberLiteral(String)
  FloatLiteral(Double)
  DecimalLiteral(String)
} derive(Eq, @moonbitlang/core/debug.Debug
Debug)

Integer and decimal lexemes retain their precision and decimal scale.

Literal::equal

source

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

Literal::not_equal

source

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

Literal::to_repr

source

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

ModuleDefinition

source

pub(all) struct ModuleDefinition[TA, VA] {
  types : Map[@finos/morphir-ir/common.Name
Name, @finos/morphir-ir/common.AccessControlled
AccessControlled[Documented[TypeDefinition[TA]]]]
  values : Map[@finos/morphir-ir/common.Name
Name, @finos/morphir-ir/common.AccessControlled
AccessControlled[Documented[ValueDefinition[TA, VA]]]]
  doc : String?
} derive(Eq, @moonbitlang/core/debug.Debug
Debug)

ModuleDefinition::equal

source

fn[TA : Eq, VA : Eq] ModuleDefinition::equal(ModuleDefinition[TA, VA], ModuleDefinition[TA, VA]) -> Bool

ModuleDefinition::not_equal

source

fn[TA : Eq, VA : Eq] ModuleDefinition::not_equal(x : ModuleDefinition[TA, VA], y : ModuleDefinition[TA, VA]) -> Bool

ModuleDefinition::to_repr

source

fn[TA : @moonbitlang/core/debug.Debug
Debug, VA : @moonbitlang/core/debug.Debug
Debug] ModuleDefinition::to_repr(ModuleDefinition[TA, VA]) -> @moonbitlang/core/debug.Repr
Repr

ModuleSpecification

source

pub(all) struct ModuleSpecification[TA] {
  types : Map[@finos/morphir-ir/common.Name
Name, Documented[TypeSpecification[TA]]]
  values : Map[@finos/morphir-ir/common.Name
Name, Documented[ValueSpecification[TA]]]
  doc : String?
} derive(Eq, @moonbitlang/core/debug.Debug
Debug)

ModuleSpecification::equal

source

fn[TA : Eq] ModuleSpecification::equal(ModuleSpecification[TA], ModuleSpecification[TA]) -> Bool

ModuleSpecification::not_equal

source

fn[TA : Eq] ModuleSpecification::not_equal(x : ModuleSpecification[TA], y : ModuleSpecification[TA]) -> Bool

ModuleSpecification::to_repr

source

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

PackageDefinition

source

pub(all) struct PackageDefinition[TA, VA] {
  modules : Map[@finos/morphir-ir/common.Path
Path, @finos/morphir-ir/common.AccessControlled
AccessControlled[ModuleDefinition[TA, VA]]]
} derive(Eq, @moonbitlang/core/debug.Debug
Debug)

PackageDefinition::equal

source

fn[TA : Eq, VA : Eq] PackageDefinition::equal(PackageDefinition[TA, VA], PackageDefinition[TA, VA]) -> Bool

PackageDefinition::not_equal

source

fn[TA : Eq, VA : Eq] PackageDefinition::not_equal(x : PackageDefinition[TA, VA], y : PackageDefinition[TA, VA]) -> Bool

PackageDefinition::to_repr

source

fn[TA : @moonbitlang/core/debug.Debug
Debug, VA : @moonbitlang/core/debug.Debug
Debug] PackageDefinition::to_repr(PackageDefinition[TA, VA]) -> @moonbitlang/core/debug.Repr
Repr

PackageSpecification

source

pub(all) struct PackageSpecification[TA] {
  modules : Map[@finos/morphir-ir/common.Path
Path, ModuleSpecification[TA]]
} derive(Eq, @moonbitlang/core/debug.Debug
Debug)

PackageSpecification::equal

source

fn[TA : Eq] PackageSpecification::equal(PackageSpecification[TA], PackageSpecification[TA]) -> Bool

PackageSpecification::not_equal

source

fn[TA : Eq] PackageSpecification::not_equal(x : PackageSpecification[TA], y : PackageSpecification[TA]) -> Bool

PackageSpecification::to_repr

source

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

Pattern

source

pub(all) enum Pattern[A] {
  WildcardPattern(A)
  AsPattern(A, Pattern[A], @finos/morphir-ir/common.Name
Name)
  TuplePattern(A, Array[Pattern[A]])
  ConstructorPattern(A, @finos/morphir-ir/common.FQName
FQName, Array[Pattern[A]])
  EmptyListPattern(A)
  HeadTailPattern(A, Pattern[A], Pattern[A])
  LiteralPattern(A, Literal)
  UnitPattern(A)
} derive(Eq, @moonbitlang/core/debug.Debug
Debug)

Pattern::equal

source

fn[A : Eq] Pattern::equal(Pattern[A], Pattern[A]) -> Bool

Pattern::not_equal

source

fn[A : Eq] Pattern::not_equal(x : Pattern[A], y : Pattern[A]) -> Bool

Pattern::to_repr

source

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

Type

source

pub(all) enum Type[A] {
  Variable(A, @finos/morphir-ir/common.Name
Name)
  Reference(A, @finos/morphir-ir/common.FQName
FQName, Array[Type[A]])
  Tuple(A, Array[Type[A]])
  Record(A, Array[Field[A]])
  ExtensibleRecord(A, @finos/morphir-ir/common.Name
Name, Array[Field[A]])
  Function(A, Type[A], Type[A])
  Unit(A)
} derive(Eq, @moonbitlang/core/debug.Debug
Debug)

Type::equal

source

fn[A : Eq] Type::equal(Type[A], Type[A]) -> Bool

Type::map_attributes

source

fn[A, B] Type::map_attributes(self : Type[A], f : (A) -> B) -> Type[B]

Type::not_equal

source

fn[A : Eq] Type::not_equal(x : Type[A], y : Type[A]) -> Bool

Type::to_repr

source

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

TypeDefinition

source

pub(all) enum TypeDefinition[A] {
  TypeAliasDefinition(Array[@finos/morphir-ir/common.Name
Name], Type[A])
  CustomTypeDefinition(Array[@finos/morphir-ir/common.Name
Name], @finos/morphir-ir/common.AccessControlled
AccessControlled[Map[@finos/morphir-ir/common.Name
Name, Array[(@finos/morphir-ir/common.Name
Name, Type[A])]]])
} derive(Eq, @moonbitlang/core/debug.Debug
Debug)

TypeDefinition::equal

source

fn[A : Eq] TypeDefinition::equal(TypeDefinition[A], TypeDefinition[A]) -> Bool

TypeDefinition::not_equal

source

fn[A : Eq] TypeDefinition::not_equal(x : TypeDefinition[A], y : TypeDefinition[A]) -> Bool

TypeDefinition::to_repr

source

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

TypeDefinition::to_specification

source

fn[A] TypeDefinition::to_specification(self : TypeDefinition[A]) -> TypeSpecification[A]

Public constructors appear in the specification; private ones become opaque.

TypeSpecification

source

pub(all) enum TypeSpecification[A] {
  TypeAliasSpecification(Array[@finos/morphir-ir/common.Name
Name], Type[A])
  OpaqueTypeSpecification(Array[@finos/morphir-ir/common.Name
Name])
  CustomTypeSpecification(Array[@finos/morphir-ir/common.Name
Name], Map[@finos/morphir-ir/common.Name
Name, Array[(@finos/morphir-ir/common.Name
Name, Type[A])]])
  DerivedTypeSpecification(Array[@finos/morphir-ir/common.Name
Name], DerivedTypeDetails[A])
} derive(Eq, @moonbitlang/core/debug.Debug
Debug)

TypeSpecification::equal

source

fn[A : Eq] TypeSpecification::equal(TypeSpecification[A], TypeSpecification[A]) -> Bool

TypeSpecification::not_equal

source

fn[A : Eq] TypeSpecification::not_equal(x : TypeSpecification[A], y : TypeSpecification[A]) -> Bool

TypeSpecification::to_repr

source

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

Value

source

pub(all) enum Value[TA, VA] {
  Literal(VA, Literal)
  Constructor(VA, @finos/morphir-ir/common.FQName
FQName)
  Tuple(VA, Array[Value[TA, VA]])
  List(VA, Array[Value[TA, VA]])
  Record(VA, Map[@finos/morphir-ir/common.Name
Name, Value[TA, VA]])
  Variable(VA, @finos/morphir-ir/common.Name
Name)
  Reference(VA, @finos/morphir-ir/common.FQName
FQName)
  Field(VA, Value[TA, VA], @finos/morphir-ir/common.Name
Name)
  FieldFunction(VA, @finos/morphir-ir/common.Name
Name)
  Apply(VA, Value[TA, VA], Value[TA, VA])
  Lambda(VA, Pattern[VA], Value[TA, VA])
  LetDefinition(VA, @finos/morphir-ir/common.Name
Name, ValueDefinition[TA, VA], Value[TA, VA])
  LetRecursion(VA, Map[@finos/morphir-ir/common.Name
Name, ValueDefinition[TA, VA]], Value[TA, VA])
  Destructure(VA, Pattern[VA], Value[TA, VA], Value[TA, VA])
  IfThenElse(VA, Value[TA, VA], Value[TA, VA], Value[TA, VA])
  PatternMatch(VA, Value[TA, VA], Array[(Pattern[VA], Value[TA, VA])])
  UpdateRecord(VA, Value[TA, VA], Map[@finos/morphir-ir/common.Name
Name, Value[TA, VA]])
  Unit(VA)
} derive(Eq, @moonbitlang/core/debug.Debug
Debug)

Value::equal

source

fn[TA : Eq, VA : Eq] Value::equal(Value[TA, VA], Value[TA, VA]) -> Bool

Value::not_equal

source

fn[TA : Eq, VA : Eq] Value::not_equal(x : Value[TA, VA], y : Value[TA, VA]) -> Bool

Value::to_repr

source

fn[TA : @moonbitlang/core/debug.Debug
Debug, VA : @moonbitlang/core/debug.Debug
Debug] Value::to_repr(Value[TA, VA]) -> @moonbitlang/core/debug.Repr
Repr

ValueDefinition

source

pub(all) struct ValueDefinition[TA, VA] {
  input_types : Array[(@finos/morphir-ir/common.Name
Name, VA, Type[TA])]
  output_type : Type[TA]
  body : Value[TA, VA]
} derive(Eq, @moonbitlang/core/debug.Debug
Debug)

ValueDefinition::equal

source

fn[TA : Eq, VA : Eq] ValueDefinition::equal(ValueDefinition[TA, VA], ValueDefinition[TA, VA]) -> Bool

ValueDefinition::not_equal

source

fn[TA : Eq, VA : Eq] ValueDefinition::not_equal(x : ValueDefinition[TA, VA], y : ValueDefinition[TA, VA]) -> Bool

ValueDefinition::to_repr

source

fn[TA : @moonbitlang/core/debug.Debug
Debug, VA : @moonbitlang/core/debug.Debug
Debug] ValueDefinition::to_repr(ValueDefinition[TA, VA]) -> @moonbitlang/core/debug.Repr
Repr

ValueDefinition::to_specification

source

fn[TA, VA] ValueDefinition::to_specification(self : ValueDefinition[TA, VA]) -> ValueSpecification[TA]

ValueSpecification

source

pub(all) struct ValueSpecification[TA] {
  inputs : Array[(@finos/morphir-ir/common.Name
Name, Type[TA])]
  output : Type[TA]
} derive(Eq, @moonbitlang/core/debug.Debug
Debug)

ValueSpecification::equal

source

fn[TA : Eq] ValueSpecification::equal(ValueSpecification[TA], ValueSpecification[TA]) -> Bool

ValueSpecification::not_equal

source

fn[TA : Eq] ValueSpecification::not_equal(x : ValueSpecification[TA], y : ValueSpecification[TA]) -> Bool

ValueSpecification::to_repr

source

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

#Access

#AccessControlled

#Constructors

Example

#Dependencies

Example

#FQName

#ModuleName

#Name

#NameError

#NameSegment

#PackageName

#Path

#RawValue

#TypedValue

#DerivedTypeDetails

#DerivedTypeDetails::equal

#DerivedTypeDetails::not_equal

#DerivedTypeDetails::to_repr

#Distribution

#Distribution::equal

#Distribution::not_equal

#Distribution::to_repr

#Documented

#Documented::equal

#Documented::not_equal

#Documented::to_repr

#Field

#Field::equal

#Field::not_equal

#Field::to_repr

#IRFile

#IRFile::equal

#IRFile::new

#IRFile::not_equal

#IRFile::to_repr

#Literal

#Literal::equal

#Literal::not_equal

#Literal::to_repr

#ModuleDefinition

#ModuleDefinition::equal

#ModuleDefinition::not_equal

#ModuleDefinition::to_repr

#ModuleSpecification

#ModuleSpecification::equal

#ModuleSpecification::not_equal

#ModuleSpecification::to_repr

#PackageDefinition

#PackageDefinition::equal

#PackageDefinition::not_equal

#PackageDefinition::to_repr

#PackageSpecification

#PackageSpecification::equal

#PackageSpecification::not_equal

#PackageSpecification::to_repr

#Pattern

#Pattern::equal

#Pattern::not_equal

#Pattern::to_repr

#Type

#Type::equal

#Type::map_attributes

#Type::not_equal

#Type::to_repr

#TypeDefinition

#TypeDefinition::equal

#TypeDefinition::not_equal

#TypeDefinition::to_repr

#TypeDefinition::to_specification

#TypeSpecification

#TypeSpecification::equal

#TypeSpecification::not_equal

#TypeSpecification::to_repr

#Value

#Value::equal

#Value::not_equal

#Value::to_repr

#ValueDefinition

#ValueDefinition::equal

Access

AccessControlled

Constructors

Dependencies

FQName

ModuleName

Name

NameError

NameSegment

PackageName

Path

RawValue

TypedValue

DerivedTypeDetails

DerivedTypeDetails::equal

DerivedTypeDetails::not_equal

DerivedTypeDetails::to_repr

Distribution

Distribution::equal

Distribution::not_equal

Distribution::to_repr

Documented

Documented::equal

Documented::not_equal

Documented::to_repr

Field

Field::equal

Field::not_equal

Field::to_repr

IRFile

IRFile::equal

IRFile::new

IRFile::not_equal

IRFile::to_repr

Literal

Literal::equal

Literal::not_equal

Literal::to_repr

ModuleDefinition

ModuleDefinition::equal

ModuleDefinition::not_equal

ModuleDefinition::to_repr

ModuleSpecification

ModuleSpecification::equal

ModuleSpecification::not_equal

ModuleSpecification::to_repr

PackageDefinition

PackageDefinition::equal

PackageDefinition::not_equal

PackageDefinition::to_repr

PackageSpecification

PackageSpecification::equal

PackageSpecification::not_equal

PackageSpecification::to_repr

Pattern

Pattern::equal

Pattern::not_equal

Pattern::to_repr

Type

Type::equal

Type::map_attributes

Type::not_equal

Type::to_repr

TypeDefinition

TypeDefinition::equal

TypeDefinition::not_equal

TypeDefinition::to_repr

TypeDefinition::to_specification

TypeSpecification

TypeSpecification::equal

TypeSpecification::not_equal

TypeSpecification::to_repr

Value

Value::equal

Value::not_equal

Value::to_repr

ValueDefinition

ValueDefinition::equal

ValueDefinition::not_equal

ValueDefinition::to_repr