Aide-mémoire

L'essentiel d'arche-lang sur une page : les déclarations avec lesquelles s'écrit tout modèle (le jeu core du langage), une ligne chacune. Les idées qui les sous-tendent sont dans les concepts ; chaque propriété figure dans la référence du langage.

Déclarations#

Écrire	Ce que c'est
`project Pump "Water pump" { version "0.1" }`	Le projet : son nom, sa version, les bibliothèques qu'il utilise. Un seul par modèle.
`include "parts/motor.arche"`	Un autre fichier du modèle.
`type Flow = float32 unit l/min range 0..120`	Un type de données : un type de base, une unité, une plage.
`enum Mode { Off, On }`	Un choix parmi des valeurs nommées.
`struct Point { x: float32; y: float32 }`	Un enregistrement de champs.
`const MAX_FLOW = 100 unit l/min`	Une valeur nommée.
`message PRESS "Press" { count: uint8 }`	Ce qui circule entre les parts (ou `message GO: bool`, une seule valeur).
`component Lamp "Lamp" { … }`	Une définition : ses ports, variables, fonctions et états.
`in cmd: can receives PRESS`	Un port qui reçoit. `out click: can sends PRESS` envoie ; `inout` fait les deux.
`var level: uint8 = 0`	Une variable du composant, avec sa valeur initiale.
fn dim "Dim" ```arche … ```	Une fonction et ce qu'elle fait, dans le langage d'action. `main` s'exécute dès le démarrage.
`states { state Off; state On; Off -> On on PRESS [level > 0] }`	La machine à états : elle démarre dans le premier état ; `A -> B on trigger [guard] / action`.
`system Room "Room" { … }`	Ce qu'Arche affiche et exécute : des parts et les liens qui les relient.
`part lamp: Lamp`	Une instance d'un composant, dans un système.
`button.click -> lamp.cmd { latency 1ms }`	Un lien d'un port vers un port.
`requirement REQ-ON "Turn on" { text "The lamp shall …" }`	Ce qui doit être vrai. `verified-by TP-ON` désigne son test.
`trace satisfies Room.lamp -> REQ-ON`	Une trace écrite à part (ou `satisfies REQ-ON` dans le composant).
`test-plan TP-ON "Turning on" { case TC-1 "…" { … } }`	Des tests, exécutés dans le simulateur : `at 0ms do …`, `within 50ms expect …`.

Dans un corps ```arche#

Écrire	Ce que cela fait
`var d = speed * 2.0`	Une variable locale.
`level = 0`, `level += 1`	Affecte une variable de la part.
`if level > 0 { … } else { … }`	Un choix. `while c { … }` et `for i in 0..4 { … }` sont des boucles.
`send click PRESS { count: 1 }`	Envoie un message sur un port.
`goto On`, `state == On`	Change d'état ; teste l'état courant.
`wait 10ms`	Attend.
`dim()`, `return x`	Appelle une fonction de la part ; retourne une valeur.
`log "pressed", level`	Écrit dans le journal du simulateur.

Un corps écrit en ```python fonctionne toujours : le correctif rapide Convert to arche body (ou archec fix --only arche-body) réécrit les corps simples.

Commandes#

Lancer	Pour
`archec new`	Démarrer un projet à partir d'un modèle de projet.
`archec check main.arche`	Vérifier le modèle.
`archec sim main.arche`	Le voir fonctionner dans le navigateur.
`archec test main.arche`	Exécuter ses plans de test dans le simulateur.
`archec gen main.arche --target c`	Générer du code (`embassy`, `go`, `ros2`…).
`archec build main.arche`	Écrire le projet Arche, à ouvrir dans Arche.

Tout à la fois#

project Room "Room" {
  version "0.1"
}

message PRESS "Press" { count: uint8 }

const MAX_LEVEL = 10

requirement REQ-ON "Turn on" {
  text "The lamp shall turn on within 50 ms of a press."
  verified-by TP-ON
}

component Button "Button" {
  out click: can sends PRESS
}

component Lamp "Lamp" {
  satisfies REQ-ON
  in cmd: can receives PRESS
  var level: uint8 = 0
  states {
    state Off
    state On
    Off -> On on PRESS
    On -> Off on PRESS
  }
  fn main "Brighten" ```arche
    while true {
      wait 100ms
      if state == On and level < MAX_LEVEL {
        level += 1
      }
    }

}

system Home "Home" { part button: Button part lamp: Lamp button.click -> lamp.cmd }

test-plan TP-ON "Turning on" { case TC-ON-01 "A press turns it on" { verifies REQ-ON at 0ms do send(button.click, PRESS(count=1)) within 50ms expect lamp.state == "On" } }