🥮 mooncakes.io

    #finos/morphir-engine/ids

    Domain types for source languages, providers, profiles, backends, files and names. Today morphir.json discovery and the package name and exposed modules of plan parse text into them; the other entry points (CLI flags, TOML) follow with bead morphir-ukvn.5.32. Only the wire carries String. Each type wraps a String, has T::parse(String) -> T raise @config.Invalid and Show.

    TypeRuleError prefix
    LanguageIdlowercase letter, then lowercase letters, digits and -; at most 64 charactersfrontend.invalid_language
    ProfileIdsame as LanguageIdfrontend.invalid_profile
    BackendIdsame as LanguageIdfrontend.invalid_backend
    ProviderIdnon-empty, at most 256 characters, no control charactersfrontend.invalid_provider
    FileExtensionstarts with ., has more than the dot, no /, \, : or control charactersfrontend.invalid_extensions
    SourcePathrelative, / separators, no empty, . or .. part, no \, : or control charactersfrontend.invalid_source_path
    SourceModuleNamebounded identifier with no space, / or \; keeps the source syntax (Sub.Util)frontend.invalid_module
    SourcePackageNamebounded identifier that canonical_path converts; keeps its spellingfrontend.invalid_package

    SourcePackageName::to_path gives the canonical @ir.Path. canonical_path converts conventional spelling: My.Pkg and my/pkg both give my/pkg.

    let elm = "elm" |> @ids.LanguageId::parse

    BackendId

    source
    pub struct BackendId(String) derive(Compare, Eq, Hash, 
    Debug    )

    A generation or output backend, for example moonbit.
    impl Show for BackendId

    BackendId::compare

    source
    fn BackendId::compare(BackendId, BackendId) -> Int

    BackendId::equal

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

    BackendId::hash

    source
    fn BackendId::hash(self : BackendId) -> Int

    BackendId::hash_combine

    source
    fn BackendId::hash_combine(BackendId, Hasher) -> Unit

    BackendId::not_equal

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

    BackendId::op_ge

    source
    fn BackendId::op_ge(x : BackendId, y : BackendId) -> Bool

    BackendId::op_gt

    source
    fn BackendId::op_gt(x : BackendId, y : BackendId) -> Bool

    BackendId::op_le

    source
    fn BackendId::op_le(x : BackendId, y : BackendId) -> Bool

    BackendId::op_lt

    source
    fn BackendId::op_lt(x : BackendId, y : BackendId) -> Bool

    BackendId::output

    source
    fn BackendId::output(self : BackendId, logger : &Logger) -> Unit

    BackendId::parse

    source

    BackendId::to_repr

    source

    BackendId::to_string

    source
    fn BackendId::to_string(self : BackendId) -> String

    FileExtension

    source
    pub struct FileExtension(String) derive(Compare, Eq, Hash, 
    Debug    )

    A file extension with its leading dot, for example .elm.

    FileExtension::compare

    source

    FileExtension::equal

    source

    FileExtension::hash

    source
    fn FileExtension::hash(self : FileExtension) -> Int

    FileExtension::hash_combine

    source
    fn FileExtension::hash_combine(FileExtension, Hasher) -> Unit

    FileExtension::not_equal

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

    FileExtension::op_ge

    source
    fn FileExtension::op_ge(x : FileExtension, y : FileExtension) -> Bool

    FileExtension::op_gt

    source
    fn FileExtension::op_gt(x : FileExtension, y : FileExtension) -> Bool

    FileExtension::op_le

    source
    fn FileExtension::op_le(x : FileExtension, y : FileExtension) -> Bool

    FileExtension::op_lt

    source
    fn FileExtension::op_lt(x : FileExtension, y : FileExtension) -> Bool

    FileExtension::output

    source
    fn FileExtension::output(self : FileExtension, logger : &Logger) -> Unit

    FileExtension::parse

    source

    FileExtension::to_repr

    source

    FileExtension::to_string

    source
    fn FileExtension::to_string(self : FileExtension) -> String

    LanguageId

    source
    pub struct LanguageId(String) derive(Compare, Eq, Hash, 
    Debug    )

    A source language, for example elm.
    impl Show for LanguageId

    LanguageId::compare

    source
    fn LanguageId::compare(LanguageId, LanguageId) -> Int

    LanguageId::equal

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

    LanguageId::hash

    source
    fn LanguageId::hash(self : LanguageId) -> Int

    LanguageId::hash_combine

    source
    fn LanguageId::hash_combine(LanguageId, Hasher) -> Unit

    LanguageId::not_equal

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

    LanguageId::op_ge

    source
    fn LanguageId::op_ge(x : LanguageId, y : LanguageId) -> Bool

    LanguageId::op_gt

    source
    fn LanguageId::op_gt(x : LanguageId, y : LanguageId) -> Bool

    LanguageId::op_le

    source
    fn LanguageId::op_le(x : LanguageId, y : LanguageId) -> Bool

    LanguageId::op_lt

    source
    fn LanguageId::op_lt(x : LanguageId, y : LanguageId) -> Bool

    LanguageId::output

    source
    fn LanguageId::output(self : LanguageId, logger : &Logger) -> Unit

    LanguageId::parse

    source

    LanguageId::to_repr

    source

    LanguageId::to_string

    source
    fn LanguageId::to_string(self : LanguageId) -> String

    ProfileId

    source
    pub struct ProfileId(String) derive(Compare, Eq, Hash, 
    Debug    )

    A source profile, for example library.
    impl Show for ProfileId

    ProfileId::compare

    source
    fn ProfileId::compare(ProfileId, ProfileId) -> Int

    ProfileId::equal

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

    ProfileId::hash

    source
    fn ProfileId::hash(self : ProfileId) -> Int

    ProfileId::hash_combine

    source
    fn ProfileId::hash_combine(ProfileId, Hasher) -> Unit

    ProfileId::not_equal

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

    ProfileId::op_ge

    source
    fn ProfileId::op_ge(x : ProfileId, y : ProfileId) -> Bool

    ProfileId::op_gt

    source
    fn ProfileId::op_gt(x : ProfileId, y : ProfileId) -> Bool

    ProfileId::op_le

    source
    fn ProfileId::op_le(x : ProfileId, y : ProfileId) -> Bool

    ProfileId::op_lt

    source
    fn ProfileId::op_lt(x : ProfileId, y : ProfileId) -> Bool

    ProfileId::output

    source
    fn ProfileId::output(self : ProfileId, logger : &Logger) -> Unit

    ProfileId::parse

    source

    ProfileId::to_repr

    source

    ProfileId::to_string

    source
    fn ProfileId::to_string(self : ProfileId) -> String

    ProviderId

    source
    pub struct ProviderId(String) derive(Compare, Eq, Hash, 
    Debug    )

    A source provider, for example finos/morphir-elm. A frontend from register_frontend uses its language name.
    impl Show for ProviderId

    ProviderId::compare

    source
    fn ProviderId::compare(ProviderId, ProviderId) -> Int

    ProviderId::equal

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

    ProviderId::hash

    source
    fn ProviderId::hash(self : ProviderId) -> Int

    ProviderId::hash_combine

    source
    fn ProviderId::hash_combine(ProviderId, Hasher) -> Unit

    ProviderId::not_equal

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

    ProviderId::op_ge

    source
    fn ProviderId::op_ge(x : ProviderId, y : ProviderId) -> Bool

    ProviderId::op_gt

    source
    fn ProviderId::op_gt(x : ProviderId, y : ProviderId) -> Bool

    ProviderId::op_le

    source
    fn ProviderId::op_le(x : ProviderId, y : ProviderId) -> Bool

    ProviderId::op_lt

    source
    fn ProviderId::op_lt(x : ProviderId, y : ProviderId) -> Bool

    ProviderId::output

    source
    fn ProviderId::output(self : ProviderId, logger : &Logger) -> Unit

    ProviderId::parse

    source

    ProviderId::to_repr

    source

    ProviderId::to_string

    source
    fn ProviderId::to_string(self : ProviderId) -> String

    SourceModuleName

    source
    pub struct SourceModuleName(String) derive(Compare, Eq, Hash, 
    Debug    )

    A module name in the source language's own syntax, as morphir.json writes it, for example Sub.Util.

    SourceModuleName::compare

    source

    SourceModuleName::equal

    source

    SourceModuleName::hash

    source
    fn SourceModuleName::hash(self : SourceModuleName) -> Int

    SourceModuleName::hash_combine

    source
    fn SourceModuleName::hash_combine(SourceModuleName, Hasher) -> Unit

    SourceModuleName::not_equal

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

    SourceModuleName::op_ge

    source

    SourceModuleName::op_gt

    source

    SourceModuleName::op_le

    source

    SourceModuleName::op_lt

    source

    SourceModuleName::output

    source
    fn SourceModuleName::output(self : SourceModuleName, logger : &Logger) -> Unit

    SourceModuleName::parse

    source

    SourceModuleName::to_repr

    source

    SourceModuleName::to_string

    source
    fn SourceModuleName::to_string(self : SourceModuleName) -> String

    SourcePackageName

    source
    pub struct SourcePackageName {
      // private fields
    } derive(Compare, Eq, Hash, 
    Debug    )

    A package name as written in the project configuration, for example Parity.Modules. The source language matches module headers against this text; to_path gives the canonical Morphir path.

    SourcePackageName::compare

    source

    SourcePackageName::equal

    source

    SourcePackageName::hash

    source
    fn SourcePackageName::hash(self : SourcePackageName) -> Int

    SourcePackageName::hash_combine

    source
    fn SourcePackageName::hash_combine(SourcePackageName, Hasher) -> Unit

    SourcePackageName::not_equal

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

    SourcePackageName::op_ge

    source

    SourcePackageName::op_gt

    source

    SourcePackageName::op_le

    source

    SourcePackageName::op_lt

    source

    SourcePackageName::output

    source
    fn SourcePackageName::output(self : SourcePackageName, logger : &Logger) -> Unit

    SourcePackageName::parse

    source

    SourcePackageName::to_path

    source

    The canonical Morphir path of the package, computed once by parse.

    SourcePackageName::to_repr

    source

    SourcePackageName::to_string

    source
    fn SourcePackageName::to_string(self : SourcePackageName) -> String

    SourcePath

    source
    pub struct SourcePath(String) derive(Compare, Eq, Hash, 
    Debug    )

    A source file path relative to the source directory, with / separators, for example My/Pkg/Api.elm.
    impl Show for SourcePath

    SourcePath::compare

    source
    fn SourcePath::compare(SourcePath, SourcePath) -> Int

    SourcePath::equal

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

    SourcePath::hash

    source
    fn SourcePath::hash(self : SourcePath) -> Int

    SourcePath::hash_combine

    source
    fn SourcePath::hash_combine(SourcePath, Hasher) -> Unit

    SourcePath::not_equal

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

    SourcePath::op_ge

    source
    fn SourcePath::op_ge(x : SourcePath, y : SourcePath) -> Bool

    SourcePath::op_gt

    source
    fn SourcePath::op_gt(x : SourcePath, y : SourcePath) -> Bool

    SourcePath::op_le

    source
    fn SourcePath::op_le(x : SourcePath, y : SourcePath) -> Bool

    SourcePath::op_lt

    source
    fn SourcePath::op_lt(x : SourcePath, y : SourcePath) -> Bool

    SourcePath::output

    source
    fn SourcePath::output(self : SourcePath, logger : &Logger) -> Unit

    SourcePath::parse

    source

    SourcePath::to_repr

    source

    SourcePath::to_string

    source
    fn SourcePath::to_string(self : SourcePath) -> String

    canonical_path

    source
    fn canonical_path(text : String) -> String raise

    Project metadata and filenames use conventional spelling; IR uses canonical names. My.Pkg and my/pkg both give my/pkg.

    Source Files