necoherence - v0.2.0

necoherence/semantic_signatures

Types

AdmittedLibrary

opaque 
pub opaque type AdmittedLibrary

Annotation 

pub type Annotation {
  Annotation(
    target: Target,
    key: String,
    value: exact_json.JsonValue,
  )
}

Constructors

CheckedGeneration

opaque 
pub opaque type CheckedGeneration

CheckedLibrary

opaque 
pub opaque type CheckedLibrary

DefinitionGroup 

pub type DefinitionGroup {
  DefinitionGroup(id: String, members: List(String))
}

Constructors 

  • DefinitionGroup(id: String, members: List(String))

DefinitionShape 

pub type DefinitionShape {
  Value(type_id: String)
  Symbol(wire_symbol: String)
  Operation(contract: OperationContract)
  Message(type_id: String)
}

Constructors 

  • Value(type_id: String)
  • Symbol(wire_symbol: String)
  • Operation(contract: OperationContract)
  • Message(type_id: String)

Failure 

pub type Failure {
  Codec(semantic_generation_runtime.ValueFailure)
  Wire(semantic_generation_decode.DecodeFailure)
  Json(semantic_generation_values.ValueCodecFailure)
  Invalid(condition: String)
  Profile(failure: semantic_types.ProfileFailure)
  Meaning(obligations: List(semantic_types.SemanticObligation))
  CompositionInput(semantic_composition.CompositionInputFailure)
  Witness(semantic_composition.WitnessFailure)
}

Constructors

GenerationDifference 

pub type GenerationDifference {
  SignatureSchemaDifference(required: String, observed: String)
  LibraryIdentityDifference(required: String, observed: String)
  LibraryRevisionDifference(required: String, observed: String)
  ProfileDifference(
    required: semantic_types.ProfileRef,
    observed: semantic_types.ProfileRef,
  )
  GraphSha256Difference(required: String, observed: String)
  ProvenanceSha256Difference(required: String, observed: String)
  MetadataSha256Difference(required: String, observed: String)
  ProblemSha256Difference(
    required: option.Option(String),
    observed: option.Option(String),
  )
  EntrypointsSha256Difference(required: String, observed: String)
}

Constructors 

  • SignatureSchemaDifference(required: String, observed: String)
  • LibraryIdentityDifference(required: String, observed: String)
  • LibraryRevisionDifference(required: String, observed: String)
  • ProfileDifference(
  required: semantic_types.ProfileRef,
  observed: semantic_types.ProfileRef,
)
  • GraphSha256Difference(required: String, observed: String)
  • ProvenanceSha256Difference(required: String, observed: String)
  • MetadataSha256Difference(required: String, observed: String)
  • ProblemSha256Difference(
  required: option.Option(String),
  observed: option.Option(String),
)
  • EntrypointsSha256Difference(required: String, observed: String)

GenerationMismatch 

pub type GenerationMismatch {
  GenerationMismatch(differences: List(GenerationDifference))
}

Constructors

GenerationRequirement 

pub type GenerationRequirement {
  GenerationRequirement(
    signature_schema: String,
    library_identity: String,
    library_revision: String,
    profile: semantic_types.ProfileRef,
    graph_sha256: String,
    provenance_sha256: String,
    metadata_sha256: String,
    problem_sha256: option.Option(String),
    entrypoints_sha256: String,
  )
}

Constructors 

  • GenerationRequirement(
  signature_schema: String,
  library_identity: String,
  library_revision: String,
  profile: semantic_types.ProfileRef,
  graph_sha256: String,
  provenance_sha256: String,
  metadata_sha256: String,
  problem_sha256: option.Option(String),
  entrypoints_sha256: String,
)

LibraryArraySpec 

pub type LibraryArraySpec {
  LibraryArraySpec(
    item: LibraryElementContract,
    minimum: option.Option(Int),
    maximum: option.Option(Int),
  )
}

Constructors

LibraryCheckFailure 

pub type LibraryCheckFailure {
  ProfileCheck(failure: semantic_types.ProfileFailure)
  LibraryCheck(failure: LibraryFailure)
}

Constructors

LibraryElementContract 

pub type LibraryElementContract {
  LibraryElementContract(type_id: String, nullable: Bool)
}

Constructors 

  • LibraryElementContract(type_id: String, nullable: Bool)

LibraryExtraMembers 

pub type LibraryExtraMembers {
  LibraryRejectExtras
  LibraryAllowExtras(
    key_format: option.Option(semantic_types.FormatUse),
    value: LibraryElementContract,
  )
}

Constructors

LibraryFailure 

pub type LibraryFailure {
  LibraryFailure(
    reference: String,
    predicate: LibraryPredicate,
    location: List(String),
  )
}

Constructors 

  • LibraryFailure(
  reference: String,
  predicate: LibraryPredicate,
  location: List(String),
)

LibraryNode 

pub type LibraryNode {
  LibraryNode(id: String, shape: LibraryShape)
}

Constructors

LibraryPredicate 

pub type LibraryPredicate {
  Lb01
  Lb02
  Lb03
  Lb04
  Lb05
  Lb06
  Lb07
  Lb08
  Lb09
  Lb10
  Lb11
  Lb12
  Lb13
  Lb14
  Lb15
  Lb16
  Lb17
  Lb18
  Lb19
}

Constructors 

  • Lb01
  • Lb02
  • Lb03
  • Lb04
  • Lb05
  • Lb06
  • Lb07
  • Lb08
  • Lb09
  • Lb10
  • Lb11
  • Lb12
  • Lb13
  • Lb14
  • Lb15
  • Lb16
  • Lb17
  • Lb18
  • Lb19

LibraryProductSpec 

pub type LibraryProductSpec {
  LibraryProductSpec(
    fields: List(SignatureField),
    extras: LibraryExtraMembers,
  )
}

Constructors

LibraryShape 

pub type LibraryShape {
  UnknownShape(kind: semantic_types.UnknownKind)
  UnitShape
  BooleanShape(spec: semantic_types.BooleanSpec)
  IntegerShape(spec: semantic_types.IntegerSpec)
  DecimalShape(spec: semantic_types.DecimalSpec)
  StringShape(spec: semantic_types.StringSpec)
  BytesShape(spec: semantic_types.LengthSpec)
  ProductShape(spec: LibraryProductSpec)
  ArrayShape(spec: LibraryArraySpec)
  TaggedUnionShape(spec: LibraryUnionSpec)
  SealedShape(
    tag: String,
    refinements: List(semantic_types.SealedRefinement),
  )
  NeverShape
  AliasShape(target: String)
  RawBodyShape(encoding: String)
  OpaqueShape(name: String)
}

Constructors

LibraryUnionBranch 

pub type LibraryUnionBranch {
  LibraryUnionBranch(
    target: String,
    wire_tag: String,
    selector: semantic_types.BranchSelector,
  )
}

Constructors

LibraryUnionSpec 

pub type LibraryUnionSpec {
  LibraryUnionSpec(branches: List(LibraryUnionBranch))
}

Constructors

OperationContract 

pub type OperationContract {
  OperationContract(
    effect: semantic_types.EffectPoint,
    inputs: List(semantic_composition.InputPort),
    outcomes: List(OutcomeContract),
  )
}

Constructors

Origin 

pub type Origin =
  semantic_types.Origin

OutcomeCause 

pub type OutcomeCause {
  ValueContract(origin: semantic_types.Origin)
  ExternalCondition(specification: semantic_types.Origin)
}

Constructors

OutcomeContract 

pub type OutcomeContract {
  OutcomeContract(
    contract: semantic_composition.OutcomeContract,
    cause: OutcomeCause,
  )
}

Constructors

ProvenanceBinding 

pub type ProvenanceBinding {
  ProvenanceBinding(
    target: Target,
    origins: List(semantic_types.Origin),
  )
}

Constructors

SignatureDefinition 

pub type SignatureDefinition {
  SignatureDefinition(
    id: String,
    wire_identity: String,
    shape: DefinitionShape,
  )
}

Constructors 

  • SignatureDefinition(
  id: String,
  wire_identity: String,
  shape: DefinitionShape,
)

SignatureField 

pub type SignatureField {
  SignatureField(wire_name: String, slot: SignatureSlot)
}

Constructors

SignatureSlot 

pub type SignatureSlot {
  SignatureSlot(type_id: String, required: Bool, nullable: Bool)
}

Constructors 

  • SignatureSlot(type_id: String, required: Bool, nullable: Bool)

SourceIdentity 

pub type SourceIdentity =
  semantic_types.SourceIdentity

Target 

pub type Target {
  Library
  Group(id: String)
  Definition(id: String)
  Type(id: String)
  Outcome(definition: String, outcome: String)
}

Constructors 

  • Library
  • Group(id: String)
  • Definition(id: String)
  • Type(id: String)
  • Outcome(definition: String, outcome: String)

TypeSignatureLibrary 

pub type TypeSignatureLibrary {
  TypeSignatureLibrary(
    schema: String,
    identity: String,
    revision: String,
    profile: semantic_types.SemanticProfile,
    sources: List(semantic_types.SourceIdentity),
    provenance: List(ProvenanceBinding),
    groups: List(DefinitionGroup),
    annotations: List(Annotation),
    nodes: List(LibraryNode),
    definitions: List(SignatureDefinition),
  )
}

Constructors

Values

admit_generation 

pub fn admit_generation(
  expected_json: String,
  input_json: String,
) -> Result(CheckedGeneration, Failure)

all_annotations 

pub fn all_annotations(
  library: AdmittedLibrary,
) -> List(Annotation)

annotations 

pub fn annotations(
  library: AdmittedLibrary,
  target: Target,
) -> List(Annotation)

assemble_generation 

pub fn assemble_generation(
  library_json: String,
  composition: exact_json.JsonValue,
  entrypoints: exact_json.JsonValue,
) -> Result(#(String, String), Failure)

canonical 

pub fn canonical(
  value: exact_json.JsonValue,
) -> Result(String, Failure)

check_library 

pub fn check_library(
  library: TypeSignatureLibrary,
) -> Result(CheckedLibrary, LibraryCheckFailure)

checked_composition 

pub fn checked_composition(
  checked: CheckedGeneration,
) -> option.Option(semantic_composition.CheckedComposition)

checked_graph 

pub fn checked_graph(
  checked: CheckedGeneration,
) -> semantic_types.SemanticGraph

checked_library 

pub fn checked_library(
  checked: CheckedGeneration,
) -> AdmittedLibrary

checked_library_value 

pub fn checked_library_value(
  checked: CheckedLibrary,
) -> TypeSignatureLibrary

checked_outcomes 

pub fn checked_outcomes(
  checked: CheckedGeneration,
  function: semantic_composition.FunctionRef,
) -> List(OutcomeContract)

decode_library 

pub fn decode_library(
  wire: String,
) -> Result(AdmittedLibrary, Failure)

decode_library_shape 

pub fn decode_library_shape(
  value: exact_json.JsonValue,
) -> Result(LibraryShape, Failure)

decode_library_value 

pub fn decode_library_value(
  value: exact_json.JsonValue,
) -> Result(AdmittedLibrary, Failure)

decode_outcome 

pub fn decode_outcome(
  checked: CheckedGeneration,
  definition: String,
  wire: String,
) -> Result(semantic_generation_runtime.OutcomeValues, Failure)

definition_ref 

pub fn definition_ref(
  library: AdmittedLibrary,
  id: String,
) -> Result(semantic_types.DefinitionRef, Failure)

definitions 

pub fn definitions(
  library: AdmittedLibrary,
) -> List(SignatureDefinition)

encode_basis 

pub fn encode_basis(
  checked: CheckedGeneration,
) -> Result(String, Failure)

encode_checked 

pub fn encode_checked(
  checked: CheckedGeneration,
) -> Result(String, Failure)

encode_library 

pub fn encode_library(
  library: AdmittedLibrary,
) -> Result(String, Failure)

encode_library_shape 

pub fn encode_library_shape(
  value: LibraryShape,
) -> Result(exact_json.JsonValue, Failure)

encode_outcome 

pub fn encode_outcome(
  checked: CheckedGeneration,
  definition: String,
  output: semantic_generation_runtime.OutcomeValues,
) -> Result(String, Failure)

field 

pub fn field(
  value: exact_json.JsonValue,
  key: String,
) -> Result(exact_json.JsonValue, Failure)

generated_definitions 

pub fn generated_definitions(
  checked: CheckedGeneration,
) -> List(SignatureDefinition)

generation_basis 

pub fn generation_basis(
  library: AdmittedLibrary,
  composition: exact_json.JsonValue,
  entrypoints: exact_json.JsonValue,
) -> Result(exact_json.JsonValue, Failure)

generation_requirement 

pub fn generation_requirement(
  checked: CheckedGeneration,
) -> GenerationRequirement

groups 

pub fn groups(library: AdmittedLibrary) -> List(DefinitionGroup)

is_external_failure 

pub fn is_external_failure(
  checked: CheckedGeneration,
  function: semantic_composition.FunctionRef,
  outcome: semantic_composition.OutcomeId,
) -> Bool

library_graph 

pub fn library_graph(
  library: AdmittedLibrary,
) -> semantic_types.SemanticGraph

object 

pub fn object(
  value: exact_json.JsonValue,
  keys: List(String),
) -> Result(List(#(String, exact_json.JsonValue)), Failure)

prepare_composition 

pub fn prepare_composition(
  library: AdmittedLibrary,
  input: semantic_composition.CompositionInput,
  causes: List(
    #(semantic_composition.FunctionRef, List(OutcomeContract)),
  ),
) -> Result(
  semantic_composition.PreparedCompositionInput,
  Failure,
)

require_generation 

pub fn require_generation(
  required: GenerationRequirement,
  checked: CheckedGeneration,
) -> Result(CheckedGeneration, GenerationMismatch)

signature_digests 

pub fn signature_digests(
  library: AdmittedLibrary,
) -> Result(#(String, String, String), Failure)

start_generation 

pub fn start_generation(
  checked: CheckedGeneration,
  arguments: List(
    #(
      semantic_composition.InputId,
      semantic_types.SlotValue(exact_json.JsonValue),
    ),
  ),
  providers: List(semantic_generation_runtime.Provider),
  state: network_effect.NetworkState,
) -> Result(
  semantic_generation_runtime.Progress,
  semantic_generation_runtime.RunFailure,
)

translate_composition 

pub fn translate_composition(
  library: AdmittedLibrary,
  value: exact_json.JsonValue,
) -> Result(exact_json.JsonValue, Failure)

type_ref 

pub fn type_ref(
  library: AdmittedLibrary,
  id: String,
) -> semantic_types.TypeRef

validate_outcome 

pub fn validate_outcome(
  checked: CheckedGeneration,
  definition: String,
  output: semantic_generation_runtime.OutcomeValues,
) -> Result(Nil, Failure)

validate_value 

pub fn validate_value(
  library: AdmittedLibrary,
  id: String,
  value: exact_json.JsonValue,
) -> Result(Nil, semantic_generation_runtime.ValueFailure)
✨ Search Document