91 lines
2.3 KiB
Plaintext
91 lines
2.3 KiB
Plaintext
### Abruptly terminating
|
|
|
|
[
|
|
Funcon stuck
|
|
Entity abrupted
|
|
Funcon finalise-abrupting
|
|
Funcon abrupt
|
|
Funcon handle-abrupt
|
|
Funcon finally
|
|
]
|
|
|
|
|
|
Meta-variables
|
|
T, T', T'' <: values
|
|
|
|
|
|
Funcon
|
|
stuck : =>empty-type
|
|
/*
|
|
`stuck` does not have any computation. It is used to represent the result of
|
|
a transition that causes the computation to terminate abruptly.
|
|
*/
|
|
|
|
|
|
Entity
|
|
_ --abrupted(_:values?)-> _
|
|
/*
|
|
`abrupted(V)` in a label on a tranistion indicates abrupt termination for
|
|
reason `V`. `abrupted( )` indicates the absence of abrupt termination.
|
|
*/
|
|
|
|
|
|
Funcon
|
|
finalise-abrupting(X:=>T) : =>T|null-type
|
|
~> handle-abrupt(X, null-value)
|
|
/*
|
|
`finalise-abrupting(X)` handles abrupt termination of `X` for any reason.
|
|
*/
|
|
|
|
|
|
Funcon
|
|
abrupt(_:values) :=>empty-type
|
|
/*
|
|
`abrupt(V)` terminates abruptly for reason `V`.
|
|
*/
|
|
Rule
|
|
abrupt(V:values) --abrupted(V)-> stuck
|
|
|
|
|
|
Funcon
|
|
handle-abrupt(_:T'=>T, _:T''=>T) : T'=>T
|
|
/*
|
|
`handle-abrupt(X, Y)` first evaluates `X`. If `X` terminates normally with
|
|
value `V`, then `V` is returned and `Y` is ignored. If `X` terminates abruptly
|
|
for reason `V`, then `Y` is executed with `V` as `given` value.
|
|
|
|
`handle-abrupt(X, Y)` is associative, with `abrupt(given)` as left and right
|
|
unit. `handle-abrupt(X, else(Y, abrupt(given)))` ensures propagation of
|
|
abrupt termination for the given reason if `Y` fails
|
|
*/
|
|
Rule
|
|
X --abrupted( )-> X'
|
|
--------------------------------------------------------
|
|
handle-abrupt(X, Y) --abrupted( )-> handle-abrupt(X', Y)
|
|
Rule
|
|
X --abrupted(V:T'')-> X'
|
|
----------------------------------------------
|
|
handle-abrupt(X, Y) --abrupted( )-> give(V, Y)
|
|
Rule
|
|
handle-abrupt(V:T, Y) ~> V
|
|
|
|
|
|
Funcon
|
|
finally(_:=>T, _:=>null-type) : =>T
|
|
/*
|
|
`finally(X, Y)` first executes `X`. If `X` terminates normally with
|
|
value `V`, then `Y` is executed before terminating normally with value `V`.
|
|
If `X` terminates abruptly for reason `V`, then `Y` is executed before
|
|
terminating abruptly with the same reason `V`.
|
|
*/
|
|
Rule
|
|
X --abrupted( )-> X'
|
|
--------------------------------------------
|
|
finally(X, Y) --abrupted( )-> finally(X', Y)
|
|
Rule
|
|
X --abrupted(V:values)-> X'
|
|
-----------------------------------------------------
|
|
finally(X, Y) --abrupted()-> sequential(Y, abrupt(V))
|
|
Rule
|
|
finally(V:T, Y) ~> sequential(Y,V)
|
|
|