🥮 mooncakes.io

    finos/morphir-ir/versions/v4 does not have a README file

    Access

    source

    AccessControlled

    source

    ApplicationDependencies

    source

    Application dependencies carry implementations for static linking.

    Constructors

    source

    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"))
    }

    Data

    source

    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.

    Dependencies

    source

    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"))
    }

    Documented

    source

    FQName

    source

    ModuleName

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

    Name

    source

    Immutable storage keeps names safe as map keys.

    NameError

    source

    NameSegment

    source

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

    PackageName

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

    Path

    source

    Annotation

    source

    Annotation::equal

    source
    fn Annotation::equal(Annotation, Annotation) -> Bool

    Annotation::not_equal

    source
    fn Annotation::not_equal(x : Annotation, y : Annotation) -> Bool

    Annotation::required_types

    source
    fn Annotation::required_types(self : Annotation) -> Array[Type]

    Annotation::to_repr

    source

    AnnotationArgument

    source
    pub(all) enum AnnotationArgument {
      Positional(Value)
      Named(
    Name    , Value)
    } derive(Eq, 
    Debug    )

    AnnotationArgument::equal

    source

    AnnotationArgument::not_equal

    source

    AnnotationArgument::to_repr

    source

    DerivedTypeDetails

    source
    pub(all) struct DerivedTypeDetails {
      base_type : Type
      from_base_type : 
    FQName
      to_base_type : 
    FQName
    } derive(Eq, 
    Debug    )

    DerivedTypeDetails::equal

    source

    DerivedTypeDetails::not_equal

    source

    DerivedTypeDetails::to_repr

    source

    Distribution

    source

    Distribution::equal

    source

    Distribution::not_equal

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

    Distribution::to_repr

    source

    EntryPoint

    source
    pub(all) struct EntryPoint {
      target : 
    FQName
      kind : EntryPointKind
      doc : String?
    } derive(Eq, 
    Debug    )

    EntryPoint::equal

    source
    fn EntryPoint::equal(EntryPoint, EntryPoint) -> Bool

    EntryPoint::not_equal

    source
    fn EntryPoint::not_equal(x : EntryPoint, y : EntryPoint) -> Bool

    EntryPoint::to_repr

    source

    EntryPointKind

    source
    pub(all) enum EntryPointKind {
      Main
      Command
      Handler
      Job
      Policy
    } derive(Eq, 
    Debug    )

    EntryPointKind::equal

    source

    EntryPointKind::not_equal

    source
    fn EntryPointKind::not_equal(x : EntryPointKind, y : EntryPointKind) -> Bool

    EntryPointKind::to_repr

    source

    ExternalBinding

    source
    pub(all) struct ExternalBinding {
      target_platform : String
      external_name : String
    } derive(Eq, 
    Debug    )

    ExternalBinding::equal

    source

    ExternalBinding::not_equal

    source
    fn ExternalBinding::not_equal(x : ExternalBinding, y : ExternalBinding) -> Bool

    ExternalBinding::to_repr

    source

    HoleReason

    source
    pub(all) enum HoleReason {
      UnresolvedReference(
    FQName    )
      DeletedDuringRefactor(String)
      TypeMismatch(String, String)
    } derive(Eq, 
    Debug    )

    HoleReason::equal

    source
    fn HoleReason::equal(HoleReason, HoleReason) -> Bool

    HoleReason::not_equal

    source
    fn HoleReason::not_equal(x : HoleReason, y : HoleReason) -> Bool

    HoleReason::to_repr

    source

    IRFile

    source

    IRFile::equal

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

    IRFile::new

    source

    IRFile::not_equal

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

    IRFile::required_types

    source
    fn IRFile::required_types(self : IRFile) -> Array[Type]

    Whole-file requirements include dependencies. A selected consumer must validate its closure before pruning.

    IRFile::to_repr

    source

    Incompleteness

    source
    pub(all) enum Incompleteness {
      Hole(HoleReason, Type?)
      Draft
    } derive(Eq, 
    Debug    )

    Incompleteness::equal

    source

    Incompleteness::not_equal

    source
    fn Incompleteness::not_equal(x : Incompleteness, y : Incompleteness) -> Bool

    Incompleteness::to_repr

    source

    Literal

    source
    pub(all) enum Literal {
      BoolLiteral(Bool)
      CharLiteral(Char)
      StringLiteral(String)
      IntegerLiteral(String)
      FloatLiteral(Double)
      DecimalLiteral(String)
      DocumentLiteral(
    Data    )
    } derive(Eq, 
    Debug    )

    Integers and decimals retain their original lexemes, including arbitrary precision.

    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

    ModuleDefinition

    source

    ModuleDefinition::equal

    source

    ModuleDefinition::not_equal

    source
    fn ModuleDefinition::not_equal(x : ModuleDefinition, y : ModuleDefinition) -> Bool

    ModuleDefinition::to_repr

    source

    ModuleSpecification

    source

    ModuleSpecification::equal

    source

    ModuleSpecification::not_equal

    source

    ModuleSpecification::to_repr

    source

    NativeHint

    source
    pub(all) enum NativeHint {
      Arithmetic
      Comparison
      StringOp
      CollectionOp
      PlatformSpecific(String)
    } derive(Eq, 
    Debug    )

    NativeHint::equal

    source
    fn NativeHint::equal(NativeHint, NativeHint) -> Bool

    NativeHint::not_equal

    source
    fn NativeHint::not_equal(x : NativeHint, y : NativeHint) -> Bool

    NativeHint::to_repr

    source

    NativeInfo

    source
    pub(all) struct NativeInfo {
      hint : NativeHint
      description : String?
    } derive(Eq, 
    Debug    )

    NativeInfo::equal

    source
    fn NativeInfo::equal(NativeInfo, NativeInfo) -> Bool

    NativeInfo::not_equal

    source
    fn NativeInfo::not_equal(x : NativeInfo, y : NativeInfo) -> Bool

    NativeInfo::to_repr

    source

    PackageDefinition

    source

    PackageDefinition::equal

    source

    PackageDefinition::not_equal

    source
    fn PackageDefinition::not_equal(x : PackageDefinition, y : PackageDefinition) -> Bool

    PackageDefinition::required_types

    source
    fn PackageDefinition::required_types(self : PackageDefinition) -> Array[Type]

    PackageDefinition::to_repr

    source

    PackageSpecification

    source
    pub(all) struct PackageSpecification {
      modules : Map[
    Path    , ModuleSpecification]
    } derive(Eq, 
    Debug    )

    PackageSpecification::equal

    source

    PackageSpecification::not_equal

    source

    PackageSpecification::required_types

    source
    fn PackageSpecification::required_types(self : PackageSpecification) -> Array[Type]

    PackageSpecification::to_repr

    source

    Pattern

    source

    Pattern::equal

    source
    fn Pattern::equal(Pattern, Pattern) -> Bool

    Pattern::not_equal

    source
    fn Pattern::not_equal(x : Pattern, y : Pattern) -> Bool

    Pattern::to_repr

    source

    PatternLiteral

    source
    pub(all) enum PatternLiteral {
      BoolLiteral(Bool)
      CharLiteral(Char)
      StringLiteral(String)
      IntegerLiteral(String)
      FloatLiteral(Double)
      DecimalLiteral(String)
    } derive(Eq, 
    Debug    )

    Document literals cannot occur in a literal pattern.

    PatternLiteral::equal

    source

    PatternLiteral::not_equal

    source
    fn PatternLiteral::not_equal(x : PatternLiteral, y : PatternLiteral) -> Bool

    PatternLiteral::to_repr

    source

    SourceLocation

    source
    pub(all) struct SourceLocation {
      start_line : Int
      start_column : Int
      end_line : Int
      end_column : Int
    } derive(Eq, 
    Debug    )

    SourceLocation::equal

    source

    SourceLocation::not_equal

    source
    fn SourceLocation::not_equal(x : SourceLocation, y : SourceLocation) -> Bool

    SourceLocation::to_repr

    source

    Type

    source

    Type::equal

    source
    fn Type::equal(Type, Type) -> Bool

    Type::has_union

    source
    fn Type::has_union(self : Type) -> Bool

    Whether native Union occurs in this authored type. This does not expand references.

    Type::not_equal

    source
    fn Type::not_equal(x : Type, y : Type) -> Bool

    Type::references

    source

    Named type dependencies, including references under every alternative.

    Type::to_repr

    source

    TypeAttributes

    source
    pub(all) struct TypeAttributes {
      source : SourceLocation?
      constraints : Map[String, 
    Data    ]
      extensions : Map[String, 
    Data    ]
    } derive(Default, Eq, 
    Debug    )

    TypeAttributes::default

    source

    TypeAttributes::equal

    source

    TypeAttributes::is_unknown

    source
    fn TypeAttributes::is_unknown(self : TypeAttributes) -> Bool

    Whether the attributes carry the unknown marker. A variable with the marker is not rigid: inference may solve it to any type. An extensible record with the marker has an unknown row variable.

    TypeAttributes::not_equal

    source
    fn TypeAttributes::not_equal(x : TypeAttributes, y : TypeAttributes) -> Bool

    TypeAttributes::to_repr

    source

    TypeAttributes::with_unknown

    source
    fn TypeAttributes::with_unknown(self : TypeAttributes) -> TypeAttributes

    The attributes with the unknown marker added. The other extensions stay.

    TypeDefinition

    source

    TypeDefinition::equal

    source

    TypeDefinition::not_equal

    source
    fn TypeDefinition::not_equal(x : TypeDefinition, y : TypeDefinition) -> Bool

    TypeDefinition::required_types

    source
    fn TypeDefinition::required_types(self : TypeDefinition) -> Array[Type]

    TypeDefinition::to_repr

    source

    TypeSpecification

    source
    pub(all) struct TypeSpecification {
      annotations : Array[Annotation]
      body : TypeSpecificationBody
    } derive(Eq, 
    Debug    )

    TypeSpecification::equal

    source

    TypeSpecification::not_equal

    source
    fn TypeSpecification::not_equal(x : TypeSpecification, y : TypeSpecification) -> Bool

    TypeSpecification::required_types

    source
    fn TypeSpecification::required_types(self : TypeSpecification) -> Array[Type]

    TypeSpecification::to_repr

    source

    TypeSpecificationBody

    source

    TypeSpecificationBody::equal

    source

    TypeSpecificationBody::not_equal

    source

    TypeSpecificationBody::to_repr

    source

    Value

    source
    pub(all) enum Value {
      Literal(ValueAttributes, Literal)
      Constructor(ValueAttributes, 
    FQName    )
      Tuple(ValueAttributes, Array[Value])
      List(ValueAttributes, Array[Value])
      Record(ValueAttributes, Map[
    Name    , Value])
      Variable(ValueAttributes, 
    Name    )
      Reference(ValueAttributes, 
    FQName    )
      Field(ValueAttributes, Value, 
    Name    )
      FieldFunction(ValueAttributes, 
    Name    )
      Apply(ValueAttributes, Value, Value)
      Lambda(ValueAttributes, Pattern, Value)
      LetDefinition(ValueAttributes, 
    Name    , ValueDefinition, Value)
      LetRecursion(ValueAttributes, Map[
    Name    , ValueDefinition], Value)
      Destructure(ValueAttributes, Pattern, Value, Value)
      IfThenElse(ValueAttributes, Value, Value, Value)
      PatternMatch(ValueAttributes, Value, Array[(Pattern, Value)])
      UpdateRecord(ValueAttributes, Value, Map[
    Name    , Value])
      Unit(ValueAttributes)
      Hole(ValueAttributes, HoleReason, Type?)
    } derive(Eq, 
    Debug    )

    Value::equal

    source
    fn Value::equal(Value, Value) -> Bool

    Value::not_equal

    source
    fn Value::not_equal(x : Value, y : Value) -> Bool

    Value::required_types

    source
    fn Value::required_types(self : Value) -> Array[Type]

    Types explicitly required by this expression, including nested definitions and pattern facts. Data and arbitrary extension payloads are never interpreted as type syntax.

    Value::to_repr

    source

    ValueAttributes

    source
    pub(all) struct ValueAttributes {
      source : SourceLocation?
      inferred_type : Type?
      extensions : Map[String, 
    Data    ]
    } derive(Default, Eq, 
    Debug    )

    ValueAttributes::default

    source

    ValueAttributes::equal

    source

    ValueAttributes::not_equal

    source
    fn ValueAttributes::not_equal(x : ValueAttributes, y : ValueAttributes) -> Bool

    ValueAttributes::to_repr

    source

    ValueDefinition

    source

    Ordered inputs preserve parameter order independently of any wire map spelling.

    ValueDefinition::equal

    source

    ValueDefinition::not_equal

    source
    fn ValueDefinition::not_equal(x : ValueDefinition, y : ValueDefinition) -> Bool

    ValueDefinition::required_types

    source
    fn ValueDefinition::required_types(self : ValueDefinition) -> Array[Type]

    ValueDefinition::to_repr

    source

    ValueDefinition::to_specification

    source
    fn ValueDefinition::to_specification(self : ValueDefinition) -> ValueSpecification?

    Incomplete definitions without an output type do not yet have a specification.

    ValueSpecification

    source
    pub(all) struct ValueSpecification {
      annotations : Array[Annotation]
      inputs : Array[(
    Name    , Type)]
      output : Type
    } derive(Eq, 
    Debug    )

    ValueSpecification::equal

    source

    ValueSpecification::not_equal

    source

    ValueSpecification::required_types

    source
    fn ValueSpecification::required_types(self : ValueSpecification) -> Array[Type]

    ValueSpecification::to_repr

    source

    INFERENCE_EXTENSION

    source
    let INFERENCE_EXTENSION : String

    The extension key of the inference marker.

    UNKNOWN_MARKER

    source
    let UNKNOWN_MARKER : String

    The value of INFERENCE_EXTENSION on a type variable that inference may solve to any type.

    is_classic_placeholder_name

    source
    fn is_classic_placeholder_name(name : 
    Name    ) -> Bool

    Whether name is a morphir-elm let placeholder: t- and one or more digits, as in t-8. Classic IR cannot carry the unknown marker, so on such a variable the name has the same meaning.

    Source Files