Traitements

Les traitements sont à la base de Mélodium, ils décrivent le flux des opérations qui s'appliquent aux données. Ils sont analogues à des cartes dont les chemins relient des points de départ à des destinations, parcourant divers lieux pour diverses raisons.

Les traitements peuvent eux-mêmes contenir d'autres traitements, de la même manière que les fonctions peuvent en appeler d'autres. Cependant, au sein d'un traitment, l'ordre de déclaration n'a aucune importance, les traitements s'effectuant lorsque des données sont diponibles pour être traitées. Tous les traitements peuvent être considérés comme s'exécutant simultanément.

Un traitement dispose d'entrées et de sorties, qui peuvent être reliées au moyen de connexions.

treatment main(url: string, file: string, log: string)
{
    startup()
    get(url=url)
    write(path=file)

    startup.trigger -> get.trigger

    log: writeText(path=log)
    stream<string>()

    get.data ---------------------------> write.data
    get.failure -> stream.block,stream ---> log.text
}

Entrées et sorties

Les entrées input et sorties output sont le moyen dont disposent les traitements pour interagir avec l'extérieur. Les entrées et sorties d'un traitement sont accessibles par les traitements hôtes.

treatment my_treatment()
  // Entrée `data` acceptant un flux d'octets
  input data:   Stream<byte>
  // Sortie `text` envoyant un flux de chaînes de caractères
  output text:  Stream<string>
{
    /*
        …
    */
}

Sous-traitements

Les sous-traitements sont des traitements instanciés par un traitement hôte, à l'instar de fonctions en appelant d'autres. Il est possible de nommer les sous-traitements, et d'en avoir un nombre quelconque.

treatment foo()
  input raw:   Stream<byte>
  output text: Stream<string>
{
    // Un sous-traitement nommé `bar` de type `my_treatment` est instancié.
    bar: my_treatment()
    // Un autre sous-traitement nommé `baz` de type `my_treatment` est instancié.
    baz: my_treatment()

    /* … */
}

treatment my_treatment()
  input data:   Stream<byte>
  output stuff: Stream<string>
{
    /*
        …
    */
}

Connexions

Les connexions permettent de lier les entrées et sorties des traitements entre-elles. Il est possible de lier une sortie output de sous-traitement à autant d'entrées input que nécessaire. Une entrée ne peut cependant recevoir que d'une origine à la fois.

Une connexion ne peut lier que des points véhiculant le même type de données.

Le mot-clé Self se réfère au traitement hôte et permet d'accéder à ses entrées et sorties.

treatment foo()
  input raw:  Stream<byte>
  output text: Stream<string>
{
    bar: my_treatment()

    // L'entrée `raw` de ce traitement `foo` est connectée à l'entrée `data` du
    // traitement `bar`, dont la sortie `stuff` est elle-même retransmise à `text`.
    Self.raw -> bar.data,stuff -> Self.text
}

treatment my_treatment()
  input data:   Stream<byte>
  output stuff: Stream<string>
{
    /* … */
}