In che cosa si inseriscono le parentesi speciali (| ... |)?

Question

Ho letto il arrow notation documentation page, ma non mi è del tutto chiaro quali siano le "parentesi del tubo" utilizzate in "7.10.3. Definire le proprie strutture di controllo".

dato l'esempio nel documento sopra

proc x -> do 
    y <- f -< x+1 
    (|untilA (increment -< x+y) (within 0.5 -< x)|) 

Qual è il codice equivalente senza usare la notazione freccia?

Answer 1

Le parentesiquelle (| ... |) (di solito chiamate parentesi quadre) servono per applicare una funzione che opera sui comandi, all'interno della notazione proc. Sono usati per disambiguare una funzione che opera su comandi (chiamati "operatori") da un normale comando. Gli operatori di file binari sono gestiti in modo speciale, quindi non è necessario scrivere (| (&&&) x y |).

Per quanto riguarda il desugaring, sono la versione di GHC della parola chiave da the Arrows paper.

forma è definito come segue:

proc p ->formae c1 c2 ... cn

=

e (proc p -> c1) (proc p -> c2) ... (proc p -> cn)

Quindi, proc x -> (|untilA (increment -< x+y) (within 0.5 -< x)|) diventerebbe:

untilA (proc x -> increment -< x+y) (proc x -> within 0.5 -< x) 

Se volete desugar questo del tutto quindi non c'è freccia sinistra sintassi, diventerebbe:

untilA (arr (\x -> x+y) >>> increment) (arr (\x -> x) >>> within 0.5) 

Answer 2

Questa è una risposta molto ruvida e intuitivo e io non sono certo che sia corretto, ma ci si sente come esso è. Se si dispone

proc a -> do 
    a1 <- command1 <- ... 
    ... 
    an <- commandn <- ... 

    (| structure (block1 -< expression1[a, a1, ..., an]) 
       ... 
       (blockm -< expressionm[a, a1, ..., an]) 
    |) 

poi (||) è un modo di alimentazione in tutte le variabili <- -bound a portata nelle block s, cioè diventa (equivalente a)

proc a -> do 
    a1 <- command1 <- ... 
    ... 
    an <- commandn <- ... 

    structure (proc (a, a1, ..., an) -> do 
        block1 -< expression1[a, a1, ..., an]) 
       ... 
       (proc (a, a1, ..., an) -> do 
        blockm -< expressionm[a, a1, ..., an]) 
         -< (a, a1, ..., an) 

ho compreso solo questo quando leggi i documenti di Oliver Charles per antijoins in Rel8. Lo trovo ancora piuttosto sconvolgente.