Enum Effect 

pub enum Effect {
    Ingress,
    Durable,
    Dom,
    Nondet,
    NetOut(Arc<str>),
    NetIn,
    FsRead(Arc<str>),
    FsWrite(Arc<str>),
    Env,
    Spawn,
    Cap(Arc<str>),
    Partial,
    Raises(Arc<str>),
    ExternalRead(Arc<str>),
    ExternalWrite(Arc<str>),
    Ambient(Ambient),
}

An effect atom. §3.2’s list, with the one correction Phase 2 makes to it (see Effect::Nondet).

Variants

Ingress

A merge point: arbitrary interleaving. “there is exactly one of these” (§3.7).

Durable

A persistent accumulator — the log.

Dom

Touches the document.

Nondet

Reads a clock, a random source, or mints an id.

§3.2 files time and rand under the ambient set — “implicitly available outside folds and elided from signatures”. Phase 2 does not, and the reason is §3.3’s own table: the fold engine is a tier, and whether a tier can discharge time and randomness is precisely §3.7’s determinism rule. An effect that decides a placement cannot also be elided from the signature that placement is derived from. log and metrics stay ambient (Effect::Ambient); these do not.

NetOut(Arc<str>)

net.out(host) — an outbound call to a named host. The host is what docs/06-kubernetes-and-packaging.md §6.5 turns into a NetworkPolicy peer.

NetIn

net.in — accepts inbound connections.

FsRead(Arc<str>)

fs.read(path) and fs.write(path) — two atoms for one resource.

§3.2 listed a single fs(path) until docs/81. One atom naming a resource without saying what is done to it cannot answer the two questions that are actually asked of it: whether two things may happen at once (crate::check’s parallel: rule) and whether a mount needs to be writable (docs/06 §6.5). §3.8’s escape hatches were already two — Effect::ExternalRead and Effect::ExternalWrite — and this is the same split for the same reason.

FsWrite(Arc<str>)

Env

Reads process environment.

Spawn

Starts concurrent work.

Cap(Arc<str>)

cap.X — a capability the caller must hold. §3.5: “forgetting an auth check means the cap.* effect goes undischarged — a compile error, not a pentest finding”.

Partial

May diverge or panic.

Raises(Arc<str>)

raises(E) — this may fail with a value of the named type.

An error is a row label, not a mechanism: a signature without one provably cannot fail, and Result[T, E] is the reified form a handler produces rather than a parallel channel (docs/38 §38.4, adopting Koka’s exn). The atom names the error’s type because a handler has to say what it catches — a try that caught everything would turn a caller’s unknown failure into this one’s Result.

ExternalRead(Arc<str>)

§3.8’s escape hatches: an existing store the team already has.

ExternalWrite(Arc<str>)

Ambient(Ambient)

The ambient set that survives §3.2’s description: available everywhere, elided from signatures, and never a reason to place anything.

Implementations

impl Effect

pub fn name(&self) -> String

pub fn parse(s: &str) -> Option<Effect>

Parse an atom as written in a uses clause: durable, net.out(api.example.com), cap.session.

pub fn is_ambient(&self) -> bool

Ambient effects are available on every tier and elided from printed signatures (§3.2).

pub fn family(&self) -> &'static str

The atom without its argument — what a tier’s discharge table and a cost model key on.

impl Effect

pub fn breaks_replay(&self) -> bool

Does this effect make a fold a different function of the log? §3.7’s replay-purity rule, stated as a property of the atom rather than as “the row is empty”.

log and metrics do not (they are write-only observations, §19.8), partial does not (a fold that aborts produces no state, rather than a different one), and raises does not (the same value raised for the same input, every replay). Everything else does.

Trait Implementations

impl Clone for Effect

fn clone(&self) -> Effect

Returns a duplicate of the value.

fn clone_from(&mut self, source: &Self)

Performs copy-assignment from source.

impl Debug for Effect

fn fmt(&self, f: &mut Formatter<'_>) -> Result

Formats the value using the given formatter.

impl Display for Effect

fn fmt(&self, f: &mut Formatter<'_>) -> Result

Formats the value using the given formatter.

impl Hash for Effect

fn hash<__H: Hasher>(&self, state: &mut __H)

Feeds this value into the given Hasher.

fn hash_slice<H>(data: &[Self], state: &mut H)

where H: Hasher, Self: Sized,

Feeds a slice of this type into the given Hasher.

impl Ord for Effect

fn cmp(&self, other: &Effect) -> Ordering

This method returns an Ordering between self and other.

fn max(self, other: Self) -> Self

where Self: Sized,

Compares and returns the maximum of two values.

fn min(self, other: Self) -> Self

where Self: Sized,

Compares and returns the minimum of two values.

fn clamp(self, min: Self, max: Self) -> Self

where Self: Sized,

Restrict a value to a certain interval.

impl PartialEq for Effect

fn eq(&self, other: &Effect) -> bool

Tests for self and other values to be equal, and is used by ==.

fn ne(&self, other: &Rhs) -> bool

Tests for !=. The default implementation is almost always sufficient, and should not be overridden without very good reason.

impl PartialOrd for Effect

fn partial_cmp(&self, other: &Effect) -> Option<Ordering>

This method returns an ordering between self and other values if one exists.

fn lt(&self, other: &Rhs) -> bool

Tests less than (for self and other) and is used by the < operator.

fn le(&self, other: &Rhs) -> bool

Tests less than or equal to (for self and other) and is used by the <= operator.

fn gt(&self, other: &Rhs) -> bool

Tests greater than (for self and other) and is used by the > operator.

fn ge(&self, other: &Rhs) -> bool

Tests greater than or equal to (for self and other) and is used by the >= operator.

impl Eq for Effect

impl StructuralPartialEq for Effect