Lastnosti

Stanja in prehodi

lolo

trait Approval -> Expense [interaction, instance] {
  initial: draft

  state draft {
    SUBMIT -> submitted when (> @entity.amount 0)
      (render-ui main { type: typography, content: "Submitted", variant: h4 })
  }

  state submitted {
    APPROVE -> approved when (<= @entity.amount 500)
      (set @entity.note "Approved")
    REJECT -> rejected
      (set @entity.note "Rejected")
  }
}

EVENT -> target je prehod. Učinki sledijo v svojih vrsticah in se izvedejo po vrsti.
when (…) je pogoj: če ne drži, je dogodek zavrnjen in nič se ne spremeni.
Prvo stanje je začetno, razen če initial: navede drugega.
Vsak prehod stoji sam. Dva prehoda, ki se razlikujeta le v izvornem stanju, se zapišeta dvakrat; nič se ne deli implicitno.
Stanje brez izhoda je napaka, razen če naj se program v njem konča.

Oklepaj v glavi vsebuje kategorijo (interaction, lifecycle, integration, …) in instance (en avtomat za vsako vrstico entitete, privzeto) ali collection (en avtomat za celo entiteto).

Tu teče celoten postopek odobritve. Poskusi oddati zahtevek nad 500 EUR in ga odobriti; pogoj ga zavrne:

Avtomat stanj

Approval

on Expense · states: 4 · transitions: 7

emitsMOVED

INIT

RAISE

SUBMIT

(> @entity.amount 0)

APPROVE

(<= @entity.amount 500)

REJECT

NEW_CLAIM

REVISE

nowdraft

submitted

approved

rejected

Teče v živo

Draft claim: EUR

Ista lastnost kot avtomat stanj: vsak okvir je stanje, vsaka puščica dogodek, ki ga premakne, ikone na puščici pa so učinki, ki jih ta dogodek izvede. Z miško pojdite čez simbol in videli boste, kaj naredi. Kako brati AVL

std-orb-docex-expense.lolololo

app std-orb-docex-expense "1.0.0"
"std-orb-docex-expense — an approval flow: four states, a guard on the amount, and a rule the shape of the program enforces."
orbital ExpenseOrbital {
  entity Expense [runtime] {
    id : string!
    amount : number = 120
    note : string = ""
  }

  trait Approval -> Expense [interaction, instance] {
    initial: draft

    state draft {
      INIT -> draft
        (render-ui main { type: stack, direction: vertical, gap: sm, children: [
          { type: typography, content: (str/concat "Draft claim: " @entity.amount " EUR"), variant: h4 },
          { type: stack, direction: horizontal, gap: sm, children: [
            { type: button, label: "Add 50 EUR", action: RAISE, variant: ghost },
            { type: button, label: "Submit", action: SUBMIT, variant: primary }
          ] }
        ] })
      RAISE -> draft
        (emit MOVED { event: "RAISE" })
        (set @entity.amount (+ @entity.amount 50))
      SUBMIT -> submitted when (> @entity.amount 0)
        (emit MOVED { event: "SUBMIT" })
        (render-ui main { type: stack, direction: vertical, gap: sm, children: [
          { type: typography, content: (str/concat "Submitted: " @entity.amount " EUR"), variant: h4 },
          { type: typography, content: "Claims over 500 EUR cannot be approved here.", variant: small, color: muted },
          { type: stack, direction: horizontal, gap: sm, children: [
            { type: button, label: "Approve", action: APPROVE, variant: primary },
            { type: button, label: "Reject", action: REJECT, variant: secondary }
          ] }
        ] })
    }

    state submitted {
      APPROVE -> approved when (<= @entity.amount 500)
        (emit MOVED { event: "APPROVE" })
        (set @entity.note "Approved")
        (render-ui main { type: stack, direction: vertical, gap: sm, children: [
          { type: badge, label: "Approved", variant: success },
          { type: button, label: "New claim", action: NEW_CLAIM, variant: ghost }
        ] })
      REJECT -> rejected
        (emit MOVED { event: "REJECT" })
        (set @entity.note "Rejected")
        (render-ui main { type: stack, direction: vertical, gap: sm, children: [
          { type: badge, label: "Rejected", variant: error },
          { type: button, label: "Revise", action: REVISE, variant: primary }
        ] })
    }

    state approved {
      NEW_CLAIM -> draft
        (emit MOVED { event: "NEW_CLAIM" })
        (set @entity.amount 120)
        (render-ui main { type: stack, direction: vertical, gap: sm, children: [
          { type: typography, content: (str/concat "Draft claim: " @entity.amount " EUR"), variant: h4 },
          { type: stack, direction: horizontal, gap: sm, children: [
            { type: button, label: "Add 50 EUR", action: RAISE, variant: ghost },
            { type: button, label: "Submit", action: SUBMIT, variant: primary }
          ] }
        ] })
    }

    state rejected {
      REVISE -> draft
        (emit MOVED { event: "REVISE" })
        (render-ui main { type: stack, direction: vertical, gap: sm, children: [
          { type: typography, content: (str/concat "Draft claim: " @entity.amount " EUR"), variant: h4 },
          { type: stack, direction: horizontal, gap: sm, children: [
            { type: button, label: "Add 50 EUR", action: RAISE, variant: ghost },
            { type: button, label: "Submit", action: SUBMIT, variant: primary }
          ] }
        ] })
    }

    emits {
      MOVED -> external {
        event : string!
      }
        @description "Each move names the event it took, so the diagram beside the demo can follow it."
    }
  }

  page "/expenses" -> Approval
}

Kaj se zgodi, ko se sproži APPROVE:

submittedAPPROVE

→

approved

GuardThe transition only fires when this check is true.

(<= @entity.amount 500)

Effects (2)What runs, in order, when the transition fires.

(set @entity.note "Approved")

Učinki

Učinek	Kaj naredi
`(set @entity.f v)`	Nastavi polje. Edina oblika prirejanja.
`(fetch E { … })` / `(persist create\|update\|delete E data)`	Bere in piše shranjene vrstice.
`(emit EVENT { … })`	Odda navedeni dogodek.
`(render-ui slot { … })`	Nariše drevo vzorcev v režo (`main`, `modal`, `drawer`, `toast`, …); `null` jo izprazni.
`(navigate "/path")` / `(navigate-back)`	Premik na drugo stran.
`(notify info "Saved")`	Pokaže obvestilo.
`(call-service provider action { … })`	Pokliče integracijo (jezikovni model, e-pošta, plačila, …).

Operatorji računajo vrednosti: (+ a b), (str/concat …), (array/map xs (fn x …)). Vsi so predponski; infiksnih ni. Referenca operatorjev našteje vsakega.

Znak	Pomen
`@entity.field`	Polje vezane entitete
`?field`	Polje tovora prihajajočega dogodka
`@config.key`	Vrednost iz `config` lastnosti
`@user.field`	Prijavljeni obiskovalec
`now` / `state`	Časovni žig te obdelave / trenutno stanje

Znak

Pomen

@entity.field

Polje vezane entitete

?field

Polje tovora prihajajočega dogodka

@config.key

Vrednost iz config lastnosti

@user.field

Prijavljeni obiskovalec

now / state

Časovni žig te obdelave / trenutno stanje

Oddajanje in poslušanje

Lastnost navede, kaj oddaja, druga pa, na kaj se odziva. Tu gumb oddaja TARGET_CHANGED, stanje pa ga posluša in preslika v svoj dogodek SHOW:

Avtomat stanj

Dial

on Thermostat · states: 1 · transitions: 3

emitsTARGET_CHANGEDemitsMOVED

INIT

UP

(< @entity.target 28)

DOWN

(> @entity.target 16)

nowidle

Status

on Thermostat · states: 1 · transitions: 2

listensTARGET_CHANGEDemitsMOVED

INIT

SHOW

nowwatching

Teče v živo

21 °C

Set a temperature between 16 and 28 °C.

std-orb-docex-thermostat.lolololo

app std-orb-docex-thermostat "1.0.0"
"std-orb-docex-thermostat — two traits in one orbital: one guards and emits, the other listens and reacts."
orbital ThermostatOrbital {
  entity Thermostat [runtime, shared] {
    id : string!
    target : number = 21
  }

  trait Dial -> Thermostat [interaction, instance] {
    initial: idle

    state idle {
      INIT -> idle
        (render-ui main { type: stack, direction: horizontal, gap: md, align: center, children: [
          { type: button, label: "Colder", action: DOWN, variant: secondary },
          { type: typography, content: (str/concat @entity.target " °C"), variant: h2 },
          { type: button, label: "Warmer", action: UP, variant: secondary }
        ] })
      UP -> idle when (< @entity.target 28)
        (emit MOVED { event: "UP" })
        (set @entity.target (+ @entity.target 1))
        (emit TARGET_CHANGED { target: @entity.target })
      DOWN -> idle when (> @entity.target 16)
        (emit MOVED { event: "DOWN" })
        (set @entity.target (- @entity.target 1))
        (emit TARGET_CHANGED { target: @entity.target })
    }

    emits {
      TARGET_CHANGED {
        target : number!
      }
        @description "The target temperature moved."
      MOVED -> external {
        event : string!
      }
        @description "Each move names the event it took, so the diagram beside the demo can follow it."
    }
  }

  trait Status -> Thermostat [interaction, instance] {
    initial: watching

    state watching {
      INIT -> watching
        (render-ui main { type: typography, content: "Set a temperature between 16 and 28 °C.", variant: body, color: muted })
      SHOW -> watching
        (emit MOVED { event: "SHOW" })
        (render-ui main { type: badge, label: (if (> ?target 23) "Heating up" (if (< ?target 19) "Cooling down" "Comfortable")), variant: (if (> ?target 23) warning (if (< ?target 19) info success)) })
    }

    emits {
      MOVED -> external {
        event : string!
      }
        @description "Each move names the event it took, so the diagram beside the demo can follow it."
    }

    listens {
      Dial.TARGET_CHANGED -> SHOW
      SHOW {
        target : number!
      }
    }
  }

  page "/thermostat" -> Dial, Status
}

Kaj se zgodi, ko se sproži UP:

idleUP

→

idle

GuardThe transition only fires when this check is true.

(< @entity.target 28)

Effects (2)What runs, in order, when the transition fires.

(set @entity.target (+ @entity.target 1))

(emit "TARGET_CHANGED" { target: @entity.target })

lolo

emits {
  TARGET_CHANGED {
    target : number!
  }
}

listens {
  Dial.TARGET_CHANGED -> SHOW
  SHOW {
    target : number!
  }
}

Dogodki internal (privzeto) ostanejo v orbitalu; dogodki external prestopijo v druge orbitale in morajo navesti tovor. Trait.EVENT se razreši znotraj orbitala poslušalca; med orbitali pišeš Orbital.Trait.EVENT. Dogodki med orbitali pokažejo oboje.

Tiki

Tik je periodični učinek. Teče le, dokler drži njegov when, zato se tik, vezan na stanje, ustavi takoj, ko lastnost stanje zapusti:

Avtomat stanj

Timing

on Stopwatch · states: 2 · transitions: 4

emitsMOVED

INIT

START

RESET

STOP

nowstopped

running

Teče v živo

s

std-orb-docex-stopwatch.lolololo

app std-orb-docex-stopwatch "1.0.0"
"std-orb-docex-stopwatch — a tick: a periodic effect that runs only while the trait is in the running state."
orbital StopwatchOrbital {
  entity Stopwatch [runtime] {
    id : string!
    seconds : number = 0
  }

  trait Timing -> Stopwatch [interaction, instance] {
    initial: stopped

    state stopped {
      INIT -> stopped
        (render-ui main { type: stack, direction: horizontal, gap: md, align: center, children: [
          { type: typography, content: (str/concat @entity.seconds " s"), variant: h2 },
          { type: button, label: "Start", action: START, variant: primary },
          { type: button, label: "Reset", action: RESET, variant: ghost }
        ] })
      START -> running
        (emit MOVED { event: "START" })
        (render-ui main { type: stack, direction: horizontal, gap: md, align: center, children: [
          { type: typography, content: (str/concat @entity.seconds " s"), variant: h2 },
          { type: button, label: "Stop", action: STOP, variant: secondary }
        ] })
      RESET -> stopped
        (emit MOVED { event: "RESET" })
        (set @entity.seconds 0)
    }

    state running {
      STOP -> stopped
        (emit MOVED { event: "STOP" })
        (render-ui main { type: stack, direction: horizontal, gap: md, align: center, children: [
          { type: typography, content: (str/concat @entity.seconds " s"), variant: h2 },
          { type: button, label: "Start", action: START, variant: primary },
          { type: button, label: "Reset", action: RESET, variant: ghost }
        ] })
    }

    emits {
      MOVED -> external {
        event : string!
      }
        @description "Each move names the event it took, so the diagram beside the demo can follow it."
    }

    ticks {
      second every 1s when (= state "running")
        (set @entity.seconds (+ @entity.seconds 1))
    }
  }

  page "/stopwatch" -> Timing
}

Kaj se zgodi, ko se sproži START:

stoppedSTART

→

running

Effects (1)What runs, in order, when the transition fires.

lolo

▼ticks {
  second every 1s when (= state "running")
    (set @entity.seconds (+ @entity.seconds 1))
}

Intervali so milisekunde, trajanje (5s, 1m, 1h, 1d) ali niz cron. Tik na shranjeni entiteti teče na strežniku, dokler ima lastnost odprta neka stran; z oznako [background] teče tudi, ko nihče ne gleda.

Orb

Orb

Lastnosti

Stanja in prehodi

Draft claim: EUR

→

Učinki

Vezave

Oddajanje in poslušanje

21 °C

→

Tiki

s

→

Nastavitve

Naprej

Orb