A pi-calculus interpreter written in Go
It also accepts input in lambda + ref
that's translated to pi before execution
To compile, your Go version must be greater than 1.14.
To verify that, type go version
The parsing is done using goyacc. To install it, run one of the following :
export GOPATH=$HOME/gocode
export PATH=$PATH:$GOPATH/bin
go get -u golang.org/x/tools/cmd/goyacc
or
sudo apt install golang-golang-x-tools
- compile with
make
- run with
./pingo [options] [file]
For pi-calculus:
0
: the null instructionP | Q
: run P and Q in parallel^n m
: send m on channel nn(m).P
: read m on channel n then run P(n)P
: create a new (private) channel called n then run Pprint x
: print the integer xprint x; P
: print the integer x then run P!n(m).P
: read m on channel n then in parrallel:- run P
- run
!n(m).P
(the same instruction)
[x=y]P
or[x!=y]P
: run P if the condition between brackets is meta(x).P + b(x).Q
: non-deterministic choice : we go on with P if we read froma
first, or Q if we read fromb
For lambda-calculus+ref+"ocaml":
fun x -> l
: the function that associates l to the variable xm n
: apply the function m to argument nnew r = v in l
: initialize r to a reference containing v, then execute l!r
: get the value contained in ref rlet x = v in l
: binds the name x to v in lx <- a; l
(read): assign the value contained in reference a to x.a := x; l
(write): assign the value x to ref a.x <- a := v; l
(swap): evaluate v, assign the value contained in a to x and replace it by v.
For the three last constructions, note that :
a
can also be an expression that returns a reference.; l
is optionnal, its default value is; 0
Some names are reserved in lambda. They are listed here, and forbidden by the parser anyway :
funChan
cont0
,cont1
andcont2
valueComp
lresult
andrresult
retrans
Pyyaml is required:
pip3 install pyyaml
Then run:
make tests
The available options are :
-showsrc
to show the parsed input-outcode
to show the code that's going to be executed (different from showsrc only if -lambda is enabled)-lambda
to parse lambda-calculus code and translate it into pi-calculus before execution
The executable reads from a file if provided, or stdin if none was provided or reading from the file failed, until EOF (or Ctrl+D in command line) is met
Go comes with support of yacc through goyacc, but no proper lexer. Lexing is therefore done in a somewhat ugly but seemingly common way, directly in the .y file, by reading characters (called runes) one by one.
[French] Retour sur projet 2 (http://perso.ens-lyon.fr/daniel.hirschkoff/P2)
Nous avons pu remplir nos objectifs sur cette partie du projet :
- Implémentation du pi-calcul
- Puis, traduction du lambda-calcul (avec support des ref) vers le pi-calcul
- Typage monomorphe du pi-calcul
- Enfin, support d'une syntaxe plus proche de OCaml avec
let
,x := bla
.
Nous avons eu quelques difficultés pour gérer les deadlocks de Go lorsqu'un déséquilibre était présent sur les canaux (tous les canaux en attente de pouvoir envoyer ou recevoir). Ce problème a été partiellement résolu en autorisant par défaut les canaux à finir en attendant un message, et sur demande, ils peuvent être autorisés à terminer en attendant de pouvoir envoyer.
Ce projet nous a en tout cas permis de nous initier à Go, ce qui était très intéressant ! Nous avons aussi pu parcourir la superbe doc de goyacc (bon courage pour la trouver!), mais une fois les bases posées nous ne nous en sommes pas si mal sortis.
Nous avons aussi pu nous amuser à écrire des horreurs en Python pour effectuer les tests (mais avec un temps d'exécution correct contrairement au temps exponentiel que nous aurions eu avec une solution jolie mais naïve).
Nous espérons en tout cas que les générations futures de la L3IF pourront aussi se frotter à Go qui a un côté non conventionnel mais fun et réfléchi.