necoherence/semantic_generation_runtime

Types

CallbackFailure

pub type CallbackFailure {
  CallbackFailure(condition: String)
  CallbackValue(failure: ValueFailure)
}

Constructors

```
CallbackFailure(condition: String)
```
```
CallbackValue(failure: ValueFailure)
```

Execution

opaque

pub opaque type Execution

FailureCause

pub type FailureCause {
  MissingComposition
  MissingInput(input: semantic_composition.InputId)
  InvalidInput(
    input: semantic_composition.InputId,
    failure: semantic_validation.ValidationFailure,
  )
  InputCoverage(condition: String)
  MissingProvider(function: semantic_composition.FunctionRef)
  ProviderCoverage(condition: String)
  ProviderEffect(function: semantic_composition.FunctionRef)
  ProviderFailed(
    function: semantic_composition.FunctionRef,
    failure: CallbackFailure,
  )
  InvalidOutput(
    function: semantic_composition.FunctionRef,
    port: semantic_composition.PortId,
    failure: semantic_validation.ValidationFailure,
  )
  OutcomeCoverage(
    function: semantic_composition.FunctionRef,
    condition: String,
  )
  BindingProjection(
    failure: semantic_validation.ProjectionValueFailure,
  )
  BindingValue(condition: String)
  GuardMeaning(
    obligations: List(semantic_types.SemanticObligation),
  )
  InvalidGuard(failure: semantic_types.ValueFailure)
  GuardCertificateMismatch(condition: String)
  MissingGuard(guard: semantic_composition.GuardId)
  MissingProducer(producer: semantic_composition.ProducerRef)
  MissingBranch(condition: String)
  InvalidTerminal(
    port: String,
    failure: semantic_validation.ValidationFailure,
  )
  ResourceCondition(condition: String)
  Network(failure: network_effect.NetworkFailure)
  NetworkTerminal(terminal: network_effect.NetworkTerminal)
}

Constructors

```
MissingComposition
```

MissingInput(input: semantic_composition.InputId)

InvalidInput(
  input: semantic_composition.InputId,
  failure: semantic_validation.ValidationFailure,
)

```
InputCoverage(condition: String)
```

MissingProvider(function: semantic_composition.FunctionRef)

```
ProviderCoverage(condition: String)
```

ProviderEffect(function: semantic_composition.FunctionRef)

ProviderFailed(
  function: semantic_composition.FunctionRef,
  failure: CallbackFailure,
)

InvalidOutput(
  function: semantic_composition.FunctionRef,
  port: semantic_composition.PortId,
  failure: semantic_validation.ValidationFailure,
)

OutcomeCoverage(
  function: semantic_composition.FunctionRef,
  condition: String,
)

BindingProjection(
  failure: semantic_validation.ProjectionValueFailure,
)

```
BindingValue(condition: String)
```

GuardMeaning(
  obligations: List(semantic_types.SemanticObligation),
)

InvalidGuard(failure: semantic_types.ValueFailure)

GuardCertificateMismatch(condition: String)

MissingGuard(guard: semantic_composition.GuardId)

MissingProducer(producer: semantic_composition.ProducerRef)

```
MissingBranch(condition: String)
```

InvalidTerminal(
  port: String,
  failure: semantic_validation.ValidationFailure,
)

```
ResourceCondition(condition: String)
```

Network(failure: network_effect.NetworkFailure)

NetworkTerminal(terminal: network_effect.NetworkTerminal)

NetworkOwner

pub type NetworkOwner {
  NetworkOwner(
    encode: fn(
      List(
        #(
          semantic_composition.PortId,
          semantic_types.SlotValue(exact_json.JsonValue),
        ),
      ),
    ) -> Result(network_effect.AttemptInput, CallbackFailure),
    decode: fn(network_effect.RawHttpResponse) -> Result(
      OutcomeValues,
      CallbackFailure,
    ),
    ports: network_host.AdapterPorts,
  )
}

Constructors

NetworkOwner(
  encode: fn(
    List(
      #(
        semantic_composition.PortId,
        semantic_types.SlotValue(exact_json.JsonValue),
      ),
    ),
  ) -> Result(network_effect.AttemptInput, CallbackFailure),
  decode: fn(network_effect.RawHttpResponse) -> Result(
    OutcomeValues,
    CallbackFailure,
  ),
  ports: network_host.AdapterPorts,
)

OutcomeValues

pub type OutcomeValues {
  OutcomeValues(
    outcome: semantic_composition.OutcomeId,
    values: List(
      #(
        semantic_composition.PortId,
        semantic_types.SlotValue(exact_json.JsonValue),
      ),
    ),
  )
}

Constructors

OutcomeValues(
  outcome: semantic_composition.OutcomeId,
  values: List(
    #(
      semantic_composition.PortId,
      semantic_types.SlotValue(exact_json.JsonValue),
    ),
  ),
)

PreparedAttempt

pub type PreparedAttempt {
  Ready(input: network_effect.AttemptInput)
  CompletedOutcome(outcome: OutcomeValues)
}

Constructors

Ready(input: network_effect.AttemptInput)

CompletedOutcome(outcome: OutcomeValues)

PreparedNetworkOwner

pub type PreparedNetworkOwner {
  PreparedNetworkOwner(
    prepare: fn(
      List(
        #(
          semantic_composition.PortId,
          semantic_types.SlotValue(exact_json.JsonValue),
        ),
      ),
    ) -> Result(PreparedAttempt, CallbackFailure),
    decode: fn(network_effect.RawHttpResponse) -> Result(
      OutcomeValues,
      CallbackFailure,
    ),
    ports: network_host.AdapterPorts,
  )
}

Constructors

PreparedNetworkOwner(
  prepare: fn(
    List(
      #(
        semantic_composition.PortId,
        semantic_types.SlotValue(exact_json.JsonValue),
      ),
    ),
  ) -> Result(PreparedAttempt, CallbackFailure),
  decode: fn(network_effect.RawHttpResponse) -> Result(
    OutcomeValues,
    CallbackFailure,
  ),
  ports: network_host.AdapterPorts,
)

Progress

pub type Progress {
  Completed(
    terminal: TerminalValues,
    network: network_effect.NetworkState,
  )
  Pending(execution: Execution)
}

Constructors

Completed(
  terminal: TerminalValues,
  network: network_effect.NetworkState,
)

```
Pending(execution: Execution)
```

Provider

pub type Provider {
  Provider(
    reference: semantic_composition.FunctionRef,
    implementation: ProviderImplementation,
  )
}

Constructors

Provider(
  reference: semantic_composition.FunctionRef,
  implementation: ProviderImplementation,
)

ProviderImplementation

pub type ProviderImplementation {
  Pure(
    callback: fn(
      List(
        #(
          semantic_composition.PortId,
          semantic_types.SlotValue(exact_json.JsonValue),
        ),
      ),
    ) -> Result(OutcomeValues, CallbackFailure),
  )
  Http(owner: NetworkOwner)
  PreparedHttp(owner: PreparedNetworkOwner)
}

Constructors

Pure(
  callback: fn(
    List(
      #(
        semantic_composition.PortId,
        semantic_types.SlotValue(exact_json.JsonValue),
      ),
    ),
  ) -> Result(OutcomeValues, CallbackFailure),
)

```
Http(owner: NetworkOwner)
```

PreparedHttp(owner: PreparedNetworkOwner)

RunFailure

pub type RunFailure {
  RunFailure(
    cause: FailureCause,
    network: network_effect.NetworkState,
  )
}

Constructors

RunFailure(
  cause: FailureCause,
  network: network_effect.NetworkState,
)

SemanticRuntimeFailure

pub type SemanticRuntimeFailure {
  UnknownWrapper(name: String)
  WrongWrapperPayload(name: String)
  WrongValueKind(expected: String)
  ConflictingMember(key: String)
  MissingMember(key: String)
  InvalidMember(key: String)
  MissingTagModel
  NoBranchSelected
}

Constructors

```
UnknownWrapper(name: String)
```
```
WrongWrapperPayload(name: String)
```
```
WrongValueKind(expected: String)
```
```
ConflictingMember(key: String)
```
```
MissingMember(key: String)
```
```
InvalidMember(key: String)
```
```
MissingTagModel
```
```
NoBranchSelected
```

TerminalValues

pub type TerminalValues {
  Success(
    outputs: List(
      #(
        semantic_composition.GoalPortId,
        semantic_types.SlotValue(exact_json.JsonValue),
      ),
    ),
  )
  DeclaredFailure(
    embedding: semantic_composition.FailureEmbeddingId,
    value: semantic_types.SlotValue(exact_json.JsonValue),
  )
}

Constructors

Success(
  outputs: List(
    #(
      semantic_composition.GoalPortId,
      semantic_types.SlotValue(exact_json.JsonValue),
    ),
  ),
)

DeclaredFailure(
  embedding: semantic_composition.FailureEmbeddingId,
  value: semantic_types.SlotValue(exact_json.JsonValue),
)

ValueFailure

pub type ValueFailure {
  Constraint(failure: semantic_validation.ValidationFailure)
  Wire(
    reference: semantic_types.TypeRef,
    failure: semantic_generation_values.ValueCodecFailure,
  )
  Representation(
    reference: semantic_types.TypeRef,
    condition: String,
  )
}

Constructors

Constraint(failure: semantic_validation.ValidationFailure)

Wire(
  reference: semantic_types.TypeRef,
  failure: semantic_generation_values.ValueCodecFailure,
)

Representation(
  reference: semantic_types.TypeRef,
  condition: String,
)

Values

class_of

pub fn class_of(
  profile: semantic_types.SemanticProfile,
  value: exact_json.JsonValue,
) -> semantic_types.ObjectClass

execution_network

pub fn execution_network(
  execution: Execution,
) -> network_effect.NetworkState

map_slot

pub fn map_slot(
  value: semantic_types.SlotValue(a),
  convert: fn(a) -> Result(b, ValueFailure),
) -> Result(semantic_types.SlotValue(b), ValueFailure)

member_slot

pub fn member_slot(
  members: List(#(String, exact_json.JsonValue)),
  name: String,
) -> semantic_types.SlotValue(exact_json.JsonValue)

ordered_members

pub fn ordered_members(
  members: List(#(String, exact_json.JsonValue)),
  member_order: List(String),
) -> List(#(String, exact_json.JsonValue))

resume

pub fn resume(
  execution: Execution,
) -> Result(Progress, RunFailure)

select_branch

pub fn select_branch(
  profile: semantic_types.SemanticProfile,
  branches: List(#(String, semantic_types.BranchSelector)),
  value: exact_json.JsonValue,
) -> Result(Int, SemanticRuntimeFailure)

slot_members

pub fn slot_members(
  name: String,
  value: semantic_types.SlotValue(exact_json.JsonValue),
) -> List(#(String, exact_json.JsonValue))

start_composition

pub fn start_composition(
  checked_composition: semantic_composition.CheckedComposition,
  arguments: List(
    #(
      semantic_composition.InputId,
      semantic_types.SlotValue(exact_json.JsonValue),
    ),
  ),
  providers: List(Provider),
  expected: List(semantic_composition.FunctionSignature),
  state: network_effect.NetworkState,
  external_failure: fn(
    semantic_composition.FunctionRef,
    semantic_composition.OutcomeId,
  ) -> Bool,
) -> Result(Progress, RunFailure)

tag_object

pub fn tag_object(
  profile: semantic_types.SemanticProfile,
  reference: semantic_types.TypeRef,
  value: exact_json.JsonValue,
  tag: String,
) -> Result(exact_json.JsonValue, ValueFailure)

validate_slot

pub fn validate_slot(
  graph: semantic_types.SemanticGraph,
  contract: semantic_types.SlotContract,
  value: semantic_types.SlotValue(exact_json.JsonValue),
) -> Result(Nil, ValueFailure)

validate_value

pub fn validate_value(
  graph: semantic_types.SemanticGraph,
  reference: semantic_types.TypeRef,
  value: exact_json.JsonValue,
) -> Result(Nil, ValueFailure)

with_member

pub fn with_member(
  key: String,
  text: String,
  value: exact_json.JsonValue,
) -> Result(exact_json.JsonValue, SemanticRuntimeFailure)

wrap_decode

pub fn wrap_decode(
  profile: semantic_types.SemanticProfile,
  wrapper_name: String,
  value: exact_json.JsonValue,
) -> Result(exact_json.JsonValue, SemanticRuntimeFailure)

wrap_encode

pub fn wrap_encode(
  profile: semantic_types.SemanticProfile,
  wrapper_name: String,
  payload: exact_json.JsonValue,
) -> Result(exact_json.JsonValue, SemanticRuntimeFailure)