🥮 mooncakes.io

    finos/morphir-conceptual/intent does not have a README file

    InvalidInput

    source
    pub(all) suberror InvalidInput {
      InvalidInput(String)
    } derive(
    Debug    )

    AbsentReason

    source
    pub(all) enum AbsentReason {
      NotInvoked
      ExecutionError
      MissingResult
    }

    AdaptedSource

    source
    pub(all) struct AdaptedSource {
      origin : KbOrigin
      source : Source
      intent : Entity
    }

    Category

    source
    pub struct Category(String) derive(Eq, 
    Debug    )

    Category IDs have a namespace and a nonempty local part. Notation is separate.

    Category::equal

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

    Category::not_equal

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

    Category::parse

    source
    fn Category::parse(value : String) -> Category raise InvalidInput

    Category::to_repr

    source

    Category::value

    source
    fn Category::value(self : Category) -> String

    Claim

    source
    pub(all) struct Claim {
      subject : ResolvedRef
      proposition : String
      author : Id
      scope : 
    Ion
      context : RevisionContext
    }

    ClaimAssessment

    source
    pub(all) struct ClaimAssessment {
      claim : ResolvedRef
      claim_freshness : Freshness
      availability : EvidenceAvailability
      observations : Array[EvidenceAssessment]
      inspection : Inspection
    }

    ClauseKind

    source
    pub(all) enum ClauseKind {
      Refinement
      Invariant
      Precondition
      Postcondition
    }

    ClauseObservation

    source
    pub(all) enum ClauseObservation {
      Satisfied
      Violated
      NotApplicable
      InvalidArgument
      Unsupported
      Error
      InconclusiveObservation
    }

    ClauseResult

    source
    pub(all) struct ClauseResult {
      entity : Snapshot
      observation : ClauseObservation
    }

    Content

    source
    pub(all) enum Content {
      Intent(String, String?)
      Requirement(Category, String, 
    Ion    ?)
      SourceFragment(SourceRef)
      Declaration(DeclarationRole, ResolvedRef?)
      Contract(ResolvedRef, ClauseKind, Expression)
      Scenario(
    Ion    )
      Implementation(Snapshot)
      Claim(Claim)
      Evidence(Evidence)
    }

    DeclarationRole

    source
    pub(all) enum DeclarationRole {
      Function
      Type
      Field
      Parameter
      Result
    }

    Diagnostic

    source
    pub(all) struct Diagnostic {
      code : DiagnosticCode
      owner : Id
      path : String
    }

    DiagnosticCode

    source
    pub(all) enum DiagnosticCode {
      DuplicateIdentity
      RelationshipKind
      MissingResolvedTarget
      ReferenceRevision
      MissingSourceFragment
      InvalidSource
      UnresolvedReference
      SourceUnpinned
      MissingFormalization
      MissingExamples
      MissingEvidence
      StaleEvidence
      InconclusiveEvidence
      ImplementationUnbound
      UnsupportedSemantics
    } derive(Eq, 
    Debug    )

    DiagnosticCode::equal

    source

    DiagnosticCode::not_equal

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

    DiagnosticCode::to_repr

    source

    Document

    source
    pub(all) struct Document {
      id : Id
      revision : Revision?
    } derive(Eq, 
    Debug    )

    Document::equal

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

    Document::not_equal

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

    Document::to_repr

    source

    Entity

    source
    pub(all) struct Entity {
      identity : Snapshot
      name : String
      source_refs : Array[SourceRef]
      content : Content
      descriptive : 
    Ion    ?
    }

    EntityKind

    source
    pub(all) enum EntityKind {
      IntentKind
      RequirementKind
      SourceFragmentKind
      DeclarationKind
      ContractKind
      ScenarioKind
      ImplementationKind
      ClaimKind
      EvidenceKind
    } derive(Eq, 
    Debug    )

    EntityKind::equal

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

    EntityKind::not_equal

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

    EntityKind::to_repr

    source

    EntityRef

    source
    pub(all) enum EntityRef {
      Resolved(ResolvedRef)
      Unresolved(NonemptyText, EntityKind, NonemptyText)
    }

    EntityRef::unresolved

    source
    fn EntityRef::unresolved(locator : String, expected_kind : EntityKind, reason : String) -> EntityRef raise InvalidInput

    Evidence

    source
    pub(all) struct Evidence {
      origin : String
      context : RevisionContext
      observation : Observation
    }

    EvidenceAssessment

    source
    pub(all) struct EvidenceAssessment {
      relationship_model : Snapshot
      relationship : Id
      reference : ResolvedRef
      polarity : Polarity
      evidence : Evidence
      freshness : Freshness
    }

    EvidenceAvailability

    source
    pub(all) enum EvidenceAvailability {
      Unknown
      Present
      InvalidClaim
    } derive(Eq, 
    Debug    )

    EvidenceAvailability::equal

    source

    EvidenceAvailability::not_equal

    source

    EvidenceAvailability::to_repr

    source

    Expression

    source
    pub(all) enum Expression {
      UnresolvedExpression(NonemptyText)
      ResolvedExpression(Id, 
    Ion    )
    }

    Fragment

    source
    pub(all) struct Fragment {
      anchor : Id
      text : String
    }

    Freshness

    source
    pub(all) enum Freshness {
      Current
      Stale
      Inconclusive
    } derive(Eq, 
    Debug    )

    Freshness::equal

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

    Freshness::not_equal

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

    Freshness::to_repr

    source

    pub struct Id(String) derive(Eq, 
    Debug    )

    M1 identities are opaque nonempty strings, not necessarily URIs.

    Id::equal

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

    Id::not_equal

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

    Id::parse

    source
    fn Id::parse(value : String) -> Id raise InvalidInput

    Id::to_repr

    source

    Id::value

    source
    fn Id::value(self : Id) -> String

    Inspection

    source
    pub(all) struct Inspection {
      diagnostics : Array[Diagnostic]
    }

    Inspection::has_errors

    source
    fn Inspection::has_errors(self : Inspection) -> Bool

    KbOrigin

    source
    pub(all) struct KbOrigin {
      bundle : Id
      short_id : Id
      slug : String
      state : KbState?
    }

    KbSnapshot

    source
    pub(all) struct KbSnapshot {
      origin : KbOrigin
      document : Snapshot
      source_id : Id
      intent : Snapshot
      name : String
      locator : String
      fragment : Fragment
      descriptive : 
    Ion    ?
    }

    KbState

    source
    pub(all) enum KbState {
      Backlog
      Refinement
      InProgress
      Released
      Cancelled
      Superseded
    } derive(Eq, 
    Debug    )

    Vocabulary of the existing morphir-kb service. This library has no transitions.

    KbState::equal

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

    KbState::not_equal

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

    KbState::to_repr

    source

    Model

    source
    pub(all) struct Model {
      identity : Snapshot
      sources : Array[Source]
      entities : Array[Entity]
      relationships : Array[Relationship]
      dependencies : Array[Model]
    }

    These records are an inspection projection of constructed M1 inputs, not a decoder or complete M1 structural validator. Fields outside this link slice remain the caller's responsibility; descriptive rich values stay opaque.

    NonemptyText

    source
    pub struct NonemptyText(String) derive(Eq, 
    Debug    )

    Required descriptive text has no identity semantics.

    NonemptyText::equal

    source

    NonemptyText::not_equal

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

    NonemptyText::parse

    source
    fn NonemptyText::parse(value : String) -> NonemptyText raise InvalidInput

    NonemptyText::to_repr

    source

    NonemptyText::value

    source
    fn NonemptyText::value(self : NonemptyText) -> String

    Observation

    source
    pub(all) enum Observation {
      Run(RunObservation)
      Analysis(Producer, 
    Ion    , 
    Ion    )
      Review(Id, ReviewDecision, String)
    }

    Polarity

    source
    pub(all) enum Polarity {
      Supporting
      Contradicting
    } derive(Eq, 
    Debug    )

    Polarity::equal

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

    Polarity::not_equal

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

    Polarity::to_repr

    source

    PrdRow

    source
    pub(all) struct PrdRow {
      requirement : ResolvedRef
      name : String
      category : Category
      text : String
      notation : 
    Ion    ?
      source_refs : Array[SourceRef]
      intents : Array[ResolvedRef]
      sources : Array[ResolvedRef]
      contracts : Array[ResolvedRef]
      scenarios : Array[ResolvedRef]
      claims : Array[ResolvedRef]
      evidence : Array[ResolvedRef]
    }

    PrdView

    source
    pub(all) struct PrdView {
      model : Snapshot
      rows : Array[PrdRow]
      inspection : Inspection
    }

    Predicate

    source
    pub(all) enum Predicate {
      DerivedFrom
      Refines
      Formalizes
      GovernedBy
      Exercises
      Implements
      Supports
      Contradicts
    } derive(Eq, 
    Debug    )

    Predicate::equal

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

    Predicate::not_equal

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

    Predicate::to_repr

    source

    Producer

    source
    pub(all) struct Producer {
      id : Id
      version : Revision
      profile : Id
    }

    Relationship

    source
    pub(all) struct Relationship {
      id : Id
      predicate : Predicate
      subject : ResolvedRef
      target : EntityRef
      source_refs : Array[SourceRef]
      descriptive : 
    Ion    ?
    }

    ResolvedRef

    source
    pub(all) struct ResolvedRef {
      model : Snapshot
      entity : Snapshot
    } derive(Eq, 
    Debug    )

    ResolvedRef::equal

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

    ResolvedRef::not_equal

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

    ResolvedRef::to_repr

    source

    ReviewDecision

    source
    pub(all) enum ReviewDecision {
      Accepted
      Rejected
    }

    Revision

    source
    pub struct Revision(String) derive(Eq, 
    Debug    )

    Revision::equal

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

    Revision::not_equal

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

    Revision::parse

    source
    fn Revision::parse(value : String) -> Revision raise InvalidInput

    Revision::to_repr

    source

    Revision::value

    source
    fn Revision::value(self : Revision) -> String

    RevisionContext

    source
    pub struct RevisionContext {
      model : Snapshot
      // private fields
    }

    Exact caller-declared dependency set. Copies prevent a caller from adding a duplicate or changing the set after construction. Lists retain authored order.

    RevisionContext::entities

    source

    RevisionContext::implementations

    source
    fn RevisionContext::implementations(self : RevisionContext) -> Array[Snapshot]

    RevisionContext::new

    source
    fn RevisionContext::new(model : Snapshot, entities~ : Array[Snapshot], sources~ : Array[Snapshot], implementations~ : Array[Snapshot]) -> RevisionContext raise InvalidInput

    RevisionContext::sources

    source

    RunLimits

    source
    pub struct RunLimits {
      steps : Int
      depth : Int
    }

    RunLimits::new

    source
    fn RunLimits::new(steps : Int, depth : Int) -> RunLimits raise InvalidInput

    RunObservation

    source
    pub(all) struct RunObservation {
      value_profile : Id
      input : 
    Ion
      output : RunOutput
      clauses : Array[ClauseResult]
      evaluator : Producer
      target : String
      configuration : 
    Ion
      limits : RunLimits
      generated_case : 
    Ion    ?
      type_arguments : 
    Ion    ?
    }

    RunOutput

    source
    pub(all) enum RunOutput {
      Observed(
    Ion    )
      Absent(AbsentReason)
    }

    Snapshot

    source
    pub(all) struct Snapshot {
      id : Id
      revision : Revision
    } derive(Eq, 
    Debug    )

    Snapshot::equal

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

    Snapshot::not_equal

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

    Snapshot::to_repr

    source

    Source

    source
    pub(all) struct Source {
      id : Id
      document : Document
      locator : String
      resolution : SourceResolution
      fragments : Array[Fragment]
      descriptive : 
    Ion    ?
    }

    Constructed M1 source slice. Digest verification belongs to source admission; this revision-only API never claims to have verified document bytes.

    SourceRef

    source
    pub(all) struct SourceRef {
      source_id : Id
      anchor : Id
    } derive(Eq, 
    Debug    )

    SourceRef::equal

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

    SourceRef::not_equal

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

    SourceRef::to_repr

    source

    SourceResolution

    source
    pub(all) enum SourceResolution {
      Retained
      Unresolved(NonemptyText)
    }

    adapt_kb_source

    source
    fn adapt_kb_source(input : KbSnapshot) -> AdaptedSource raise InvalidInput

    Keep the caller's identity, revision and exact excerpt. Neither a KB state nor an excerpt creates requirements, contracts, claims or observations.

    assess_claim

    source
    fn assess_claim(model : Model, reference : ResolvedRef, requested : RevisionContext) -> ClaimAssessment

    Currency is an exact revision comparison, never a proof. An observation's payload and kind survive even when stale, inconclusive or contradicting.

    inspect

    source
    fn inspect(model : Model) -> Inspection

    prd_view

    source
    fn prd_view(model : Model) -> PrdView

    Authored order is retained. A row is an identified requirement, never a new authority. Link assertions do not establish fulfillment or prose equivalence.

    Source Files