Pages: [1]   Go Down
Print
Author Topic: Espressioni regolari in PICT  (Read 818 times)
0 Members e 1 Utente non registrato stanno visualizzando questa discussione.
rondey
Matricola
*
Offline Offline

Posts: 74


« on: 29-04-2016, 10:09:49 »

Code:
def q4 [c:?Char r:!String] =
    c?char = (new br:^Bool
                (==![char 'b' (rchan br)]
                | br?b = if b then q3![c r]
                              else r!"failed") )
                                                 
and q3 [c:?Char r:!String] =
    c?char = (new br:^Bool
                (==![char 'b' (rchan br)]
                | br?b = if b then q4![c r]
                              else (new br:^Bool
                                    (==![char 'n' (rchan br)]
                                    | br?b = if b then r!"ok"
                                                  else r!"failed") ) ) )

def q2 [c:?Char r:!String] =
    c?char = (new br:^Bool
                (==![char 'c' (rchan br)]
                | br?b = if b then q2![c r]
                              else (new br:^Bool
                                    (==![char 'n' (rchan br)]
                                    | br?b = if b then r!"ok"
                                                  else r!"failed") ) ) )

def q1 [c:?Char r:!String] =
    c?char = (new br:^Bool
                (==![char 'b' (rchan br)]
                | br?b = if b then q2![c r]
                              else r!"failed") )

def init [c:?Char r:!String] =
    c?char = (new br:^Bool
                (==![char 'a' (rchan br)]
                | br?b = if b then q1![c r]
                              else (new br:^Bool
                                    (==![char 'c' (rchan br)]
                                    | br?b = if b then q3![c r]
                                                  else r!"failed") ) ) )

run( new c:^Char
     (init![c print]|c!'a'|c!'b'|c!'c'|c!'n')) 

Osservare che le def degli stati sono in ordine invertito: se per esempio mettessimo init come prima definizione il compilatore si lamenterebbe perchè non sono stati definiti nè q1 nè q3.
Notare infine che q3 al posto di "def q3" è definito attraverso "and q3".  Questo perchè q4 e q3 sono mutualmente ricorsivi: per definire q4 è necessaria la definizione di q3 e viceversa, per definire q3 è necessario definire q4.
Logged
Franco Barbanera
Moderator
Forumista Eroico
*****
Offline Offline

Posts: 2.794



WWW
« Reply #1 on: 29-04-2016, 11:34:07 »

Bene.

Possiamo ora fare in modo che il sistema si possa creare a partire da una singola def
attraverso la quale si possano creare i singoli stati dell'automa,
analogamente a quanto fatto con Erlang?

Fatemi sapere.

Pace e Bene
FB
Logged
Franco Barbanera
Moderator
Forumista Eroico
*****
Offline Offline

Posts: 2.794



WWW
« Reply #2 on: 29-04-2016, 17:04:24 »

init![c print]|c!'a'|c!'b'|c!'c'|c!'n'

c'e' un problema con questo processo.
La semantica dell'operatore parallelo '|' dice che i processi
messi in parallelo sono eseguiti concorrentemente.
Scrivere |c!'a'|c!'b'|c!'c'|c!'n'
non garantisce affatto che i caratteri vengano inviati
nell'ordine in cui sono scritti nel programma.
Che la nostra implementazione faccia cosi' non significa che
succeda sempre. Potremmo avere una implementazione realmente
parallela di PICT in cui ogni processo e' eseguito su una macchina differente.
Oppure avere uno scheduler dei processi differente da quello dell'implementazione
che abbiamo noi.
Per vedere se si puo' risolvere il problema, leggere la sezione 5.3 del testo [BP].
Logged
Franco Barbanera
Moderator
Forumista Eroico
*****
Offline Offline

Posts: 2.794



WWW
« Reply #3 on: 04-05-2016, 09:01:26 »

Per poter esser sicuri che i caratteri vengano elaborati dall'automa
nella giusta sequenza (utilizzando la parte di PICT che conosciamo) possiamo fare la seguente cosa:
inviare il carattere successivo solo quando si ha la sicurezza che il precedente
sia stato ricevuto.

Si puo' modificare q4 ( e similmente le altre def) nel seguente modo

def q4 [c:?Char ack:![] r:!String] =
    c?char = (new br:^Bool
                (ack![]
                | ==![char 'b' (rchan br)]
                | br?b = if b then q3![c ack r]
                              else r!"failed") )

e poi scrivere il processo che invia i caratteri come
run(  new c:^Char
         new ack:^[]
         (init![c ack print]
          |c!'a'
          |ack?[]=(c!'b'
                       |ack?[] = (c!'c'|
                                       ack?[]=(c!'n'
                                                   |ack?[] = ()
                                                   )
                                       )
                       )
         )
     ) 


Provate a risistemare in codice in questo modo.


Logged
Pages: [1]   Go Up
Print
Jump to: