peter/IBAFLang
1
0
Fork 0
Code Issues Pull Requests Packages Projects Releases Wiki Activity

init commit again

Browse Source
This commit is contained in:
Peter
2023-11-01 09:29:33 +01:00
parent 448147e7da
commit d6c745207b
250 changed files with 15552 additions and 1 deletions
Download Patch File Download Diff File Expand all files Collapse all files

1
IBAF-cbs/Funcons-beta
View File

@@ -1 +0,0 @@
/home/peter/cbs-all/CBS-beta/Funcons-beta

5
IBAF-cbs/Funcons-beta/.gitignore vendored Normal file
View File

@@ -0,0 +1,5 @@
/.cache
/target
/.project
/.settings

91
IBAF-cbs/Funcons-beta/Computations/Abnormal/Abrupting/Abrupting.cbs Normal file
View File

@@ -0,0 +1,91 @@
### 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)

131
IBAF-cbs/Funcons-beta/Computations/Abnormal/Abrupting/index.md Normal file
View File

@@ -0,0 +1,131 @@
---
layout: default
title: "Abrupting"
parent: Abnormal
ancestor: Funcons-beta
---
[Funcons-beta] : [Abrupting.cbs]
-----------------------------
### Abruptly terminating
<div class="highlighter-rouge"><pre class="highlight"><code>[
<i class="keyword">Funcon</i> <span class="name"><a href="#Name_stuck">stuck</a></span>
<i class="keyword">Entity</i> <span class="name"><a href="#Name_abrupted">abrupted</a></span>
<i class="keyword">Funcon</i> <span class="name"><a href="#Name_finalise-abrupting">finalise-abrupting</a></span>
<i class="keyword">Funcon</i> <span class="name"><a href="#Name_abrupt">abrupt</a></span>
<i class="keyword">Funcon</i> <span class="name"><a href="#Name_handle-abrupt">handle-abrupt</a></span>
<i class="keyword">Funcon</i> <span class="name"><a href="#Name_finally">finally</a></span>
]</code></pre></div>
<div class="highlighter-rouge"><pre class="highlight"><code><i class="keyword">Meta-variables</i>
<span id="PartVariable_T"><i class="var">T</i></span>, <span id="PartVariable_T'"><i class="var">T&prime;</i></span>, <span id="PartVariable_T''"><i class="var">T&prime;&prime;</i></span> <: <span class="name"><a href="../../../Values/Value-Types/index.html#Name_values">values</a></span></code></pre></div>
<div class="highlighter-rouge"><pre class="highlight"><code><i class="keyword">Funcon</i>
<span class="name"><span id="Name_stuck">stuck</span></span> : =><span class="name"><a href="../../../Values/Value-Types/index.html#Name_empty-type">empty-type</a></span></code></pre></div>
<code><span class="name"><a href="#Name_stuck">stuck</a></span></code> does not have any computation. It is used to represent the result of
a transition that causes the computation to terminate abruptly.
<div class="highlighter-rouge"><pre class="highlight"><code><i class="keyword">Entity</i>
_ --<span class="ent-name"><span id="Name_abrupted">abrupted</span></span>(_:<span class="name"><a href="../../../Values/Value-Types/index.html#Name_values">values</a></span><sup class="sup">?</sup>)-> _</code></pre></div>
<code><span class="name"><a href="#Name_abrupted">abrupted</a></span>(<i class="var">V</i>)</code> in a label on a tranistion indicates abrupt termination for
reason <code><i class="var">V</i></code>. <code><span class="name"><a href="#Name_abrupted">abrupted</a></span>( )</code> indicates the absence of abrupt termination.
<div class="highlighter-rouge"><pre class="highlight"><code><i class="keyword">Funcon</i>
<span class="name"><span id="Name_finalise-abrupting">finalise-abrupting</span></span>(<span id="Variable153_X"><i class="var">X</i></span>:=><span id="Variable158_T"><i class="var">T</i></span>) : =><span id="Variable173_T"><i class="var">T</i></span>|<span class="name"><a href="../../../Values/Primitive/Null/index.html#Name_null-type">null-type</a></span>
~> <span class="name"><a href="#Name_handle-abrupt">handle-abrupt</a></span>(<a href="#Variable153_X"><i class="var">X</i></a>, <span class="name"><a href="../../../Values/Primitive/Null/index.html#Name_null-value">null-value</a></span>)</code></pre></div>
<code><span class="name"><a href="#Name_finalise-abrupting">finalise-abrupting</a></span>(<i class="var">X</i>)</code> handles abrupt termination of <code><i class="var">X</i></code> for any reason.
<div class="highlighter-rouge"><pre class="highlight"><code><i class="keyword">Funcon</i>
<span class="name"><span id="Name_abrupt">abrupt</span></span>(_:<span class="name"><a href="../../../Values/Value-Types/index.html#Name_values">values</a></span>) :=><span class="name"><a href="../../../Values/Value-Types/index.html#Name_empty-type">empty-type</a></span></code></pre></div>
<code><span class="name"><a href="#Name_abrupt">abrupt</a></span>(<i class="var">V</i>)</code> terminates abruptly for reason <code><i class="var">V</i></code>.
<div class="highlighter-rouge"><pre class="highlight"><code><i class="keyword">Rule</i>
<span class="name"><a href="#Name_abrupt">abrupt</a></span>(<span id="Variable300_V"><i class="var">V</i></span>:<span class="name"><a href="../../../Values/Value-Types/index.html#Name_values">values</a></span>) --<span class="ent-name"><a href="#Name_abrupted">abrupted</a></span>(<a href="#Variable300_V"><i class="var">V</i></a>)-> <span class="name"><a href="#Name_stuck">stuck</a></span></code></pre></div>
<div class="highlighter-rouge"><pre class="highlight"><code><i class="keyword">Funcon</i>
<span class="name"><span id="Name_handle-abrupt">handle-abrupt</span></span>(_:<span id="Variable344_T'"><i class="var">T&prime;</i></span>=><span id="Variable350_T"><i class="var">T</i></span>, _:<span id="Variable363_T''"><i class="var">T&prime;&prime;</i></span>=><span id="Variable369_T"><i class="var">T</i></span>) : <span id="Variable385_T'"><i class="var">T&prime;</i></span>=><span id="Variable391_T"><i class="var">T</i></span></code></pre></div>
<code><span class="name"><a href="#Name_handle-abrupt">handle-abrupt</a></span>(<i class="var">X</i>, <i class="var">Y</i>)</code> first evaluates <code><i class="var">X</i></code>. If <code><i class="var">X</i></code> terminates normally with
value <code><i class="var">V</i></code>, then <code><i class="var">V</i></code> is returned and <code><i class="var">Y</i></code> is ignored. If <code><i class="var">X</i></code> terminates abruptly
for reason <code><i class="var">V</i></code>, then <code><i class="var">Y</i></code> is executed with <code><i class="var">V</i></code> as <code><span class="name"><a href="../../Normal/Giving/index.html#Name_given">given</a></span></code> value.
<code><span class="name"><a href="#Name_handle-abrupt">handle-abrupt</a></span>(<i class="var">X</i>, <i class="var">Y</i>)</code> is associative, with <code><span class="name"><a href="#Name_abrupt">abrupt</a></span>(<span class="name"><a href="../../Normal/Giving/index.html#Name_given">given</a></span>)</code> as left and right
unit. <code><span class="name"><a href="#Name_handle-abrupt">handle-abrupt</a></span>(<i class="var">X</i>, <span class="name"><a href="../Failing/index.html#Name_else">else</a></span>(<i class="var">Y</i>, <span class="name"><a href="#Name_abrupt">abrupt</a></span>(<span class="name"><a href="../../Normal/Giving/index.html#Name_given">given</a></span>)))</code> ensures propagation of
abrupt termination for the given reason if <code><i class="var">Y</i></code> fails
<div class="highlighter-rouge"><pre class="highlight"><code><i class="keyword">Rule</i>
<a href="#Variable690_X"><i class="var">X</i></a> --<span class="ent-name"><a href="#Name_abrupted">abrupted</a></span>( )-> <span id="Variable677_X'"><i class="var">X&prime;</i></span>
--------------------------------------------------------
<span class="name"><a href="#Name_handle-abrupt">handle-abrupt</a></span>(<span id="Variable690_X"><i class="var">X</i></span>, <span id="Variable695_Y"><i class="var">Y</i></span>) --<span class="ent-name"><a href="#Name_abrupted">abrupted</a></span>( )-> <span class="name"><a href="#Name_handle-abrupt">handle-abrupt</a></span>(<a href="#Variable677_X'"><i class="var">X&prime;</i></a>, <a href="#Variable695_Y"><i class="var">Y</i></a>)
<i class="keyword">Rule</i>
<a href="#Variable789_X"><i class="var">X</i></a> --<span class="ent-name"><a href="#Name_abrupted">abrupted</a></span>(<span id="Variable752_V"><i class="var">V</i></span>:<i class="var">T&prime;&prime;</i>)-> <span id="Variable776_X'"><i class="var">X&prime;</i></span>
----------------------------------------------
<span class="name"><a href="#Name_handle-abrupt">handle-abrupt</a></span>(<span id="Variable789_X"><i class="var">X</i></span>, <span id="Variable794_Y"><i class="var">Y</i></span>) --<span class="ent-name"><a href="#Name_abrupted">abrupted</a></span>( )-> <span class="name"><a href="../../Normal/Giving/index.html#Name_give">give</a></span>(<a href="#Variable752_V"><i class="var">V</i></a>, <a href="#Variable794_Y"><i class="var">Y</i></a>)
<i class="keyword">Rule</i>
<span class="name"><a href="#Name_handle-abrupt">handle-abrupt</a></span>(<span id="Variable842_V"><i class="var">V</i></span>:<i class="var">T</i>, <span id="Variable853_Y"><i class="var">Y</i></span>) ~> <a href="#Variable842_V"><i class="var">V</i></a></code></pre></div>
<div class="highlighter-rouge"><pre class="highlight"><code><i class="keyword">Funcon</i>
<span class="name"><span id="Name_finally">finally</span></span>(_:=><span id="Variable878_T"><i class="var">T</i></span>, _:=><span class="name"><a href="../../../Values/Primitive/Null/index.html#Name_null-type">null-type</a></span>) : =><span id="Variable904_T"><i class="var">T</i></span></code></pre></div>
<code><span class="name"><a href="#Name_finally">finally</a></span>(<i class="var">X</i>, <i class="var">Y</i>)</code> first executes <code><i class="var">X</i></code>. If <code><i class="var">X</i></code> terminates normally with
value <code><i class="var">V</i></code>, then <code><i class="var">Y</i></code> is executed before terminating normally with value <code><i class="var">V</i></code>.
If <code><i class="var">X</i></code> terminates abruptly for reason <code><i class="var">V</i></code>, then <code><i class="var">Y</i></code> is executed before
terminating abruptly with the same reason <code><i class="var">V</i></code>.
<div class="highlighter-rouge"><pre class="highlight"><code><i class="keyword">Rule</i>
<a href="#Variable1094_X"><i class="var">X</i></a> --<span class="ent-name"><a href="#Name_abrupted">abrupted</a></span>( )-> <span id="Variable1081_X'"><i class="var">X&prime;</i></span>
--------------------------------------------
<span class="name"><a href="#Name_finally">finally</a></span>(<span id="Variable1094_X"><i class="var">X</i></span>, <span id="Variable1099_Y"><i class="var">Y</i></span>) --<span class="ent-name"><a href="#Name_abrupted">abrupted</a></span>( )-> <span class="name"><a href="#Name_finally">finally</a></span>(<a href="#Variable1081_X'"><i class="var">X&prime;</i></a>, <a href="#Variable1099_Y"><i class="var">Y</i></a>)
<i class="keyword">Rule</i>
<a href="#Variable1189_X"><i class="var">X</i></a> --<span class="ent-name"><a href="#Name_abrupted">abrupted</a></span>(<span id="Variable1156_V"><i class="var">V</i></span>:<span class="name"><a href="../../../Values/Value-Types/index.html#Name_values">values</a></span>)-> <span id="Variable1176_X'"><i class="var">X&prime;</i></span>
-----------------------------------------------------
<span class="name"><a href="#Name_finally">finally</a></span>(<span id="Variable1189_X"><i class="var">X</i></span>, <span id="Variable1194_Y"><i class="var">Y</i></span>) --<span class="ent-name"><a href="#Name_abrupted">abrupted</a></span>()-> <span class="name"><a href="../../Normal/Flowing/index.html#Name_sequential">sequential</a></span>(<a href="#Variable1194_Y"><i class="var">Y</i></a>, <span class="name"><a href="#Name_abrupt">abrupt</a></span>(<a href="#Variable1156_V"><i class="var">V</i></a>))
<i class="keyword">Rule</i>
<span class="name"><a href="#Name_finally">finally</a></span>(<span id="Variable1249_V"><i class="var">V</i></span>:<i class="var">T</i>, <span id="Variable1260_Y"><i class="var">Y</i></span>) ~> <span class="name"><a href="../../Normal/Flowing/index.html#Name_sequential">sequential</a></span>(<a href="#Variable1260_Y"><i class="var">Y</i></a>,<a href="#Variable1249_V"><i class="var">V</i></a>)</code></pre></div>
____
From the [PLanCompS Project] | [CBS-beta issues...] | [Suggest an improvement...]
[Abrupting.cbs]: Abrupting.cbs
"CBS SOURCE FILE"
[Funcons-beta]: /CBS-beta/docs/Funcons-beta
"FUNCONS-BETA"
[Unstable-Funcons-beta]: /CBS-beta/docs/Unstable-Funcons-beta
"UNSTABLE-FUNCONS-BETA"
[Languages-beta]: /CBS-beta/docs/Languages-beta
"LANGUAGES-BETA"
[Unstable-Languages-beta]: /CBS-beta/docs/Unstable-Languages-beta
"UNSTABLE-LANGUAGES-BETA"
[CBS-beta]: /CBS-beta "CBS-BETA"
[PLanCompS Project]: https://plancomps.github.io
"PROGRAMMING LANGUAGE COMPONENTS AND SPECIFICATIONS PROJECT HOME PAGE"
[CBS-beta issues...]: https://github.com/plancomps/CBS-beta/issues
"CBS-BETA ISSUE REPORTS ON GITHUB"
[Suggest an improvement...]: mailto:plancomps@gmail.com?Subject=CBS-beta%20-%20comment&Body=Re%3A%20CBS-beta%20specification%20at%20Computations/Abnormal/Abrupting/Abrupting.cbs%0A%0AComment/Query/Issue/Suggestion%3A%0A%0A%0ASignature%3A%0A
"GENERATE AN EMAIL TEMPLATE"

15
IBAF-cbs/Funcons-beta/Computations/Abnormal/Abrupting/tests/finally.config Normal file
View File

@@ -0,0 +1,15 @@
general {
funcon-term:
finalise-abrupting
sequential(
print finally(2, print 1),
finally(print 3, print 4),
else(finally(fail, print 5), print 6)
)
;
}
tests {
result-term: null-value;
standard-out: [1, 2, 3, 4, 5, 6];
}

17
IBAF-cbs/Funcons-beta/Computations/Abnormal/Abrupting/tests/handle-abrupt.config Normal file
View File

@@ -0,0 +1,17 @@
general {
funcon-term:
finalise-abrupting
sequential(
print handle-abrupt(1, fail),
handle-abrupt(print 2, fail),
handle-abrupt(
sequential(print 3, abrupt(sequential(print 4, 5))),
print given)
)
;
}
tests {
result-term: null-value;
standard-out: [1, 2, 3, 4, 5];
}

59
IBAF-cbs/Funcons-beta/Computations/Abnormal/Breaking/Breaking.cbs Normal file
View File

@@ -0,0 +1,59 @@
### Breaking
[
Datatype breaking
Funcon broken
Funcon finalise-breaking
Funcon break
Funcon handle-break
]
Meta-variables
T <: values
Datatype
breaking ::= broken
/*
`broken` is a reason for abrupt termination.
*/
Funcon
finalise-breaking(X:=>T) : =>T|null-type
~> finalise-abrupting(X)
/*
`finalise-breaking(X)` handles abrupt termination of `X` due to executing
`break`.
*/
Funcon
break : =>empty-type
~> abrupt(broken)
/*
`break` abruptly terminates all enclosing computations until it is handled.
*/
Funcon
handle-break(_:=>null-type) : =>null-type
/*
`handle-break(X)` terminates normally when `X` terminates abruptly for the
reason `broken`.
*/
Rule
X --abrupted( )-> X'
------------------------------------------------
handle-break(X) --abrupted( )-> handle-break(X')
Rule
X --abrupted(broken)-> _
---------------------------------------
handle-break(X) --abrupted( )-> null-value
Rule
X --abrupted(V:~breaking)-> X'
------------------------------------------------
handle-break(X) --abrupted(V)-> handle-break(X')
Rule
handle-break(null-value) ~> null-value

98
IBAF-cbs/Funcons-beta/Computations/Abnormal/Breaking/index.md Normal file
View File

@@ -0,0 +1,98 @@
---
layout: default
title: "Breaking"
parent: Abnormal
ancestor: Funcons-beta
---
[Funcons-beta] : [Breaking.cbs]
-----------------------------
### Breaking
<div class="highlighter-rouge"><pre class="highlight"><code>[
<i class="keyword">Datatype</i> <span class="name"><a href="#Name_breaking">breaking</a></span>
<i class="keyword">Funcon</i> <span class="name"><a href="#Name_broken">broken</a></span>
<i class="keyword">Funcon</i> <span class="name"><a href="#Name_finalise-breaking">finalise-breaking</a></span>
<i class="keyword">Funcon</i> <span class="name"><a href="#Name_break">break</a></span>
<i class="keyword">Funcon</i> <span class="name"><a href="#Name_handle-break">handle-break</a></span>
]</code></pre></div>
<div class="highlighter-rouge"><pre class="highlight"><code><i class="keyword">Meta-variables</i>
<span id="PartVariable_T"><i class="var">T</i></span> <: <span class="name"><a href="../../../Values/Value-Types/index.html#Name_values">values</a></span></code></pre></div>
<div class="highlighter-rouge"><pre class="highlight"><code><i class="keyword">Datatype</i>
<span class="name"><span id="Name_breaking">breaking</span></span> ::= <span id="Name_broken">broken</span></code></pre></div>
<code><span class="name"><a href="#Name_broken">broken</a></span></code> is a reason for abrupt termination.
<div class="highlighter-rouge"><pre class="highlight"><code><i class="keyword">Funcon</i>
<span class="name"><span id="Name_finalise-breaking">finalise-breaking</span></span>(<span id="Variable76_X"><i class="var">X</i></span>:=><span id="Variable81_T"><i class="var">T</i></span>) : =><span id="Variable96_T"><i class="var">T</i></span>|<span class="name"><a href="../../../Values/Primitive/Null/index.html#Name_null-type">null-type</a></span>
~> <span class="name"><a href="../Abrupting/index.html#Name_finalise-abrupting">finalise-abrupting</a></span>(<a href="#Variable76_X"><i class="var">X</i></a>)</code></pre></div>
<code><span class="name"><a href="#Name_finalise-breaking">finalise-breaking</a></span>(<i class="var">X</i>)</code> handles abrupt termination of <code><i class="var">X</i></code> due to executing
<code><span class="name"><a href="#Name_break">break</a></span></code>.
<div class="highlighter-rouge"><pre class="highlight"><code><i class="keyword">Funcon</i>
<span class="name"><span id="Name_break">break</span></span> : =><span class="name"><a href="../../../Values/Value-Types/index.html#Name_empty-type">empty-type</a></span>
~> <span class="name"><a href="../Abrupting/index.html#Name_abrupt">abrupt</a></span>(<span class="name"><a href="#Name_broken">broken</a></span>)</code></pre></div>
<code><span class="name"><a href="#Name_break">break</a></span></code> abruptly terminates all enclosing computations until it is handled.
<div class="highlighter-rouge"><pre class="highlight"><code><i class="keyword">Funcon</i>
<span class="name"><span id="Name_handle-break">handle-break</span></span>(_:=><span class="name"><a href="../../../Values/Primitive/Null/index.html#Name_null-type">null-type</a></span>) : =><span class="name"><a href="../../../Values/Primitive/Null/index.html#Name_null-type">null-type</a></span></code></pre></div>
<code><span class="name"><a href="#Name_handle-break">handle-break</a></span>(<i class="var">X</i>)</code> terminates normally when <code><i class="var">X</i></code> terminates abruptly for the
reason <code><span class="name"><a href="#Name_broken">broken</a></span></code>.
<div class="highlighter-rouge"><pre class="highlight"><code><i class="keyword">Rule</i>
<a href="#Variable307_X"><i class="var">X</i></a> --<span class="ent-name"><a href="../Abrupting/index.html#Name_abrupted">abrupted</a></span>( )-> <span id="Variable294_X'"><i class="var">X&prime;</i></span>
------------------------------------------------
<span class="name"><a href="#Name_handle-break">handle-break</a></span>(<span id="Variable307_X"><i class="var">X</i></span>) --<span class="ent-name"><a href="../Abrupting/index.html#Name_abrupted">abrupted</a></span>( )-> <span class="name"><a href="#Name_handle-break">handle-break</a></span>(<a href="#Variable294_X'"><i class="var">X&prime;</i></a>)
<i class="keyword">Rule</i>
<a href="#Variable382_X"><i class="var">X</i></a> --<span class="ent-name"><a href="../Abrupting/index.html#Name_abrupted">abrupted</a></span>(<span class="name"><a href="#Name_broken">broken</a></span>)-> _
---------------------------------------
<span class="name"><a href="#Name_handle-break">handle-break</a></span>(<span id="Variable382_X"><i class="var">X</i></span>) --<span class="ent-name"><a href="../Abrupting/index.html#Name_abrupted">abrupted</a></span>( )-> <span class="name"><a href="../../../Values/Primitive/Null/index.html#Name_null-value">null-value</a></span>
<i class="keyword">Rule</i>
<a href="#Variable455_X"><i class="var">X</i></a> --<span class="ent-name"><a href="../Abrupting/index.html#Name_abrupted">abrupted</a></span>(<span id="Variable421_V"><i class="var">V</i></span>:~<span class="name"><a href="#Name_breaking">breaking</a></span>)-> <span id="Variable442_X'"><i class="var">X&prime;</i></span>
------------------------------------------------
<span class="name"><a href="#Name_handle-break">handle-break</a></span>(<span id="Variable455_X"><i class="var">X</i></span>) --<span class="ent-name"><a href="../Abrupting/index.html#Name_abrupted">abrupted</a></span>(<a href="#Variable421_V"><i class="var">V</i></a>)-> <span class="name"><a href="#Name_handle-break">handle-break</a></span>(<a href="#Variable442_X'"><i class="var">X&prime;</i></a>)
<i class="keyword">Rule</i>
<span class="name"><a href="#Name_handle-break">handle-break</a></span>(<span class="name"><a href="../../../Values/Primitive/Null/index.html#Name_null-value">null-value</a></span>) ~> <span class="name"><a href="../../../Values/Primitive/Null/index.html#Name_null-value">null-value</a></span></code></pre></div>
____
From the [PLanCompS Project] | [CBS-beta issues...] | [Suggest an improvement...]
[Breaking.cbs]: Breaking.cbs
"CBS SOURCE FILE"
[Funcons-beta]: /CBS-beta/docs/Funcons-beta
"FUNCONS-BETA"
[Unstable-Funcons-beta]: /CBS-beta/docs/Unstable-Funcons-beta
"UNSTABLE-FUNCONS-BETA"
[Languages-beta]: /CBS-beta/docs/Languages-beta
"LANGUAGES-BETA"
[Unstable-Languages-beta]: /CBS-beta/docs/Unstable-Languages-beta
"UNSTABLE-LANGUAGES-BETA"
[CBS-beta]: /CBS-beta "CBS-BETA"
[PLanCompS Project]: https://plancomps.github.io
"PROGRAMMING LANGUAGE COMPONENTS AND SPECIFICATIONS PROJECT HOME PAGE"
[CBS-beta issues...]: https://github.com/plancomps/CBS-beta/issues
"CBS-BETA ISSUE REPORTS ON GITHUB"
[Suggest an improvement...]: mailto:plancomps@gmail.com?Subject=CBS-beta%20-%20comment&Body=Re%3A%20CBS-beta%20specification%20at%20Computations/Abnormal/Breaking/Breaking.cbs%0A%0AComment/Query/Issue/Suggestion%3A%0A%0A%0ASignature%3A%0A
"GENERATE AN EMAIL TEMPLATE"

16
IBAF-cbs/Funcons-beta/Computations/Abnormal/Breaking/tests/handle-break.config Normal file
View File

@@ -0,0 +1,16 @@
general {
funcon-term:
finalise-breaking
sequential(
print sequential(handle-break(null-value),0),
handle-break(print 1),
print sequential(handle-break(
sequential(print 2, break, fail)),3)
)
;
}
tests {
result-term: null-value;
standard-out: [0, 1, 2, 3];
}

59
IBAF-cbs/Funcons-beta/Computations/Abnormal/Continuing/Continuing.cbs Normal file
View File

@@ -0,0 +1,59 @@
### Continuing
[
Datatype continuing
Funcon continued
Funcon finalise-continuing
Funcon continue
Funcon handle-continue
]
Meta-variables
T <: values
Datatype
continuing ::= continued
/*
`continued` is a reason for abrupt termination.
*/
Funcon
finalise-continuing(X:=>T) : =>T|null-type
~> finalise-abrupting(X)
/*
`finalise-continuing(X)` handles abrupt termination of `X` due to executing
`continue`.
*/
Funcon
continue : =>empty-type
~> abrupt(continued)
/*
`continue` abruptly terminates all enclosing computations until it is handled.
*/
Funcon
handle-continue(_:=>null-type) : =>null-type
/*
`handle-continue(X)` terminates normally when `X` terminates abruptly for the
reason `continued`.
*/
Rule
X --abrupted( )-> X'
------------------------------------------------------
handle-continue(X) --abrupted( )-> handle-continue(X')
Rule
X --abrupted(continued)-> _
--------------------------------------------
handle-continue(X) --abrupted( )-> null-value
Rule
X --abrupted(V:~continuing)-> X'
------------------------------------------------------
handle-continue(X) --abrupted(V)-> handle-continue(X')
Rule
handle-continue(null-value) ~> null-value

98
IBAF-cbs/Funcons-beta/Computations/Abnormal/Continuing/index.md Normal file
View File

@@ -0,0 +1,98 @@
---
layout: default
title: "Continuing"
parent: Abnormal
ancestor: Funcons-beta
---
[Funcons-beta] : [Continuing.cbs]
-----------------------------
### Continuing
<div class="highlighter-rouge"><pre class="highlight"><code>[
<i class="keyword">Datatype</i> <span class="name"><a href="#Name_continuing">continuing</a></span>
<i class="keyword">Funcon</i> <span class="name"><a href="#Name_continued">continued</a></span>
<i class="keyword">Funcon</i> <span class="name"><a href="#Name_finalise-continuing">finalise-continuing</a></span>
<i class="keyword">Funcon</i> <span class="name"><a href="#Name_continue">continue</a></span>
<i class="keyword">Funcon</i> <span class="name"><a href="#Name_handle-continue">handle-continue</a></span>
]</code></pre></div>
<div class="highlighter-rouge"><pre class="highlight"><code><i class="keyword">Meta-variables</i>
<span id="PartVariable_T"><i class="var">T</i></span> <: <span class="name"><a href="../../../Values/Value-Types/index.html#Name_values">values</a></span></code></pre></div>
<div class="highlighter-rouge"><pre class="highlight"><code><i class="keyword">Datatype</i>
<span class="name"><span id="Name_continuing">continuing</span></span> ::= <span id="Name_continued">continued</span></code></pre></div>
<code><span class="name"><a href="#Name_continued">continued</a></span></code> is a reason for abrupt termination.
<div class="highlighter-rouge"><pre class="highlight"><code><i class="keyword">Funcon</i>
<span class="name"><span id="Name_finalise-continuing">finalise-continuing</span></span>(<span id="Variable76_X"><i class="var">X</i></span>:=><span id="Variable81_T"><i class="var">T</i></span>) : =><span id="Variable96_T"><i class="var">T</i></span>|<span class="name"><a href="../../../Values/Primitive/Null/index.html#Name_null-type">null-type</a></span>
~> <span class="name"><a href="../Abrupting/index.html#Name_finalise-abrupting">finalise-abrupting</a></span>(<a href="#Variable76_X"><i class="var">X</i></a>)</code></pre></div>
<code><span class="name"><a href="#Name_finalise-continuing">finalise-continuing</a></span>(<i class="var">X</i>)</code> handles abrupt termination of <code><i class="var">X</i></code> due to executing
<code><span class="name"><a href="#Name_continue">continue</a></span></code>.
<div class="highlighter-rouge"><pre class="highlight"><code><i class="keyword">Funcon</i>
<span class="name"><span id="Name_continue">continue</span></span> : =><span class="name"><a href="../../../Values/Value-Types/index.html#Name_empty-type">empty-type</a></span>
~> <span class="name"><a href="../Abrupting/index.html#Name_abrupt">abrupt</a></span>(<span class="name"><a href="#Name_continued">continued</a></span>)</code></pre></div>
<code><span class="name"><a href="#Name_continue">continue</a></span></code> abruptly terminates all enclosing computations until it is handled.
<div class="highlighter-rouge"><pre class="highlight"><code><i class="keyword">Funcon</i>
<span class="name"><span id="Name_handle-continue">handle-continue</span></span>(_:=><span class="name"><a href="../../../Values/Primitive/Null/index.html#Name_null-type">null-type</a></span>) : =><span class="name"><a href="../../../Values/Primitive/Null/index.html#Name_null-type">null-type</a></span></code></pre></div>
<code><span class="name"><a href="#Name_handle-continue">handle-continue</a></span>(<i class="var">X</i>)</code> terminates normally when <code><i class="var">X</i></code> terminates abruptly for the
reason <code><span class="name"><a href="#Name_continued">continued</a></span></code>.
<div class="highlighter-rouge"><pre class="highlight"><code><i class="keyword">Rule</i>
<a href="#Variable307_X"><i class="var">X</i></a> --<span class="ent-name"><a href="../Abrupting/index.html#Name_abrupted">abrupted</a></span>( )-> <span id="Variable294_X'"><i class="var">X&prime;</i></span>
------------------------------------------------------
<span class="name"><a href="#Name_handle-continue">handle-continue</a></span>(<span id="Variable307_X"><i class="var">X</i></span>) --<span class="ent-name"><a href="../Abrupting/index.html#Name_abrupted">abrupted</a></span>( )-> <span class="name"><a href="#Name_handle-continue">handle-continue</a></span>(<a href="#Variable294_X'"><i class="var">X&prime;</i></a>)
<i class="keyword">Rule</i>
<a href="#Variable382_X"><i class="var">X</i></a> --<span class="ent-name"><a href="../Abrupting/index.html#Name_abrupted">abrupted</a></span>(<span class="name"><a href="#Name_continued">continued</a></span>)-> _
--------------------------------------------
<span class="name"><a href="#Name_handle-continue">handle-continue</a></span>(<span id="Variable382_X"><i class="var">X</i></span>) --<span class="ent-name"><a href="../Abrupting/index.html#Name_abrupted">abrupted</a></span>( )-> <span class="name"><a href="../../../Values/Primitive/Null/index.html#Name_null-value">null-value</a></span>
<i class="keyword">Rule</i>
<a href="#Variable455_X"><i class="var">X</i></a> --<span class="ent-name"><a href="../Abrupting/index.html#Name_abrupted">abrupted</a></span>(<span id="Variable421_V"><i class="var">V</i></span>:~<span class="name"><a href="#Name_continuing">continuing</a></span>)-> <span id="Variable442_X'"><i class="var">X&prime;</i></span>
------------------------------------------------------
<span class="name"><a href="#Name_handle-continue">handle-continue</a></span>(<span id="Variable455_X"><i class="var">X</i></span>) --<span class="ent-name"><a href="../Abrupting/index.html#Name_abrupted">abrupted</a></span>(<a href="#Variable421_V"><i class="var">V</i></a>)-> <span class="name"><a href="#Name_handle-continue">handle-continue</a></span>(<a href="#Variable442_X'"><i class="var">X&prime;</i></a>)
<i class="keyword">Rule</i>
<span class="name"><a href="#Name_handle-continue">handle-continue</a></span>(<span class="name"><a href="../../../Values/Primitive/Null/index.html#Name_null-value">null-value</a></span>) ~> <span class="name"><a href="../../../Values/Primitive/Null/index.html#Name_null-value">null-value</a></span></code></pre></div>
____
From the [PLanCompS Project] | [CBS-beta issues...] | [Suggest an improvement...]
[Continuing.cbs]: Continuing.cbs
"CBS SOURCE FILE"
[Funcons-beta]: /CBS-beta/docs/Funcons-beta
"FUNCONS-BETA"
[Unstable-Funcons-beta]: /CBS-beta/docs/Unstable-Funcons-beta
"UNSTABLE-FUNCONS-BETA"
[Languages-beta]: /CBS-beta/docs/Languages-beta
"LANGUAGES-BETA"
[Unstable-Languages-beta]: /CBS-beta/docs/Unstable-Languages-beta
"UNSTABLE-LANGUAGES-BETA"
[CBS-beta]: /CBS-beta "CBS-BETA"
[PLanCompS Project]: https://plancomps.github.io
"PROGRAMMING LANGUAGE COMPONENTS AND SPECIFICATIONS PROJECT HOME PAGE"
[CBS-beta issues...]: https://github.com/plancomps/CBS-beta/issues
"CBS-BETA ISSUE REPORTS ON GITHUB"
[Suggest an improvement...]: mailto:plancomps@gmail.com?Subject=CBS-beta%20-%20comment&Body=Re%3A%20CBS-beta%20specification%20at%20Computations/Abnormal/Continuing/Continuing.cbs%0A%0AComment/Query/Issue/Suggestion%3A%0A%0A%0ASignature%3A%0A
"GENERATE AN EMAIL TEMPLATE"

16
IBAF-cbs/Funcons-beta/Computations/Abnormal/Continuing/tests/handle-continue.config Normal file
View File

@@ -0,0 +1,16 @@
general {
funcon-term:
finalise-continuing
sequential(
print sequential(handle-continue(null-value),0),
handle-continue(print 1),
print sequential(handle-continue(
sequential(print 2, continue, fail)),3)
)
;
}
tests {
result-term: null-value;
standard-out: [0, 1, 2, 3];
}

89
IBAF-cbs/Funcons-beta/Computations/Abnormal/Controlling/Controlling.cbs Normal file
View File

@@ -0,0 +1,89 @@
### Controlling
[
Datatype continuations
Funcon continuation
Entity plug-signal
Funcon hole
Funcon resume-continuation
Entity control-signal
Funcon control
Funcon delimit-current-continuation Alias delimit-cc
]
Meta-variables
T, T1, T2 <: values
Datatype
continuations(T1,T2) ::= continuation(_:abstractions(()=>T2))
/*
`continuations(T1, T2)` consists of abstractions whose bodies contain a `hole`,
and which will normally compute a value of type `T2` when the `hole` is plugged
with a value of type `T1`.
*/
Entity
_ --plug-signal(V?:values?)-> _
/*
A plug-signal contains the value to be filled into a `hole` in a continuation,
thereby allowing a continuation to resume.
*/
Funcon
hole : =>values
/*
A `hole` in a term cannot proceed until it receives a plug-signal
containing a value to plug the hole.
*/
Rule
hole --plug-signal(V)-> V
Funcon
resume-continuation(K:continuations(T1, T2), V:T1) : =>T2
/*
`resume-continuation(K, V)` resumes a continuation `K` by plugging the value
`V` into the `hole` in the continuation.
*/
Rule
X --plug-signal(V)-> X'
---------------------------------------------------------------------------
resume-continuation(continuation(abstraction(X)), V:T) --plug-signal()-> X'
Entity
_ --control-signal(F?:(functions(continuations(T1, T2), T2))?)-> _
/*
A control-signal contains the function to which control is about to be passed
by the enclosing `delimit-current-continuation(X)`.
*/
Funcon
control(F:functions(continuations(T1, T2), T2)) : =>T1
/*
`control(F)` emits a control-signal that, when handled by an enclosing
`delimit-current-continuation(X)`, will apply `F` to the current continuation of
`control(F)`, (rather than proceeding with that current continuation).
*/
Rule
control(F:functions(_,_)) --control-signal(F)-> hole
Funcon
delimit-current-continuation(X:=>T) : =>T
Alias
delimit-cc = delimit-current-continuation
/*
`delimit-current-continuation(X)` delimits the scope of captured continuations.
*/
Rule
delimit-current-continuation(V:T) ~> V
Rule
X --control-signal( )-> X'
-----------------------------------------------------
delimit-current-continuation(X) --control-signal( )->
delimit-current-continuation(X')
Rule
X --control-signal(F)-> X'
------------------------------------------------------------------
delimit-current-continuation(X) --control-signal( )->
delimit-current-continuation(apply(F, continuation closure(X')))

131
IBAF-cbs/Funcons-beta/Computations/Abnormal/Controlling/index.md Normal file
View File

@@ -0,0 +1,131 @@
---
layout: default
title: "Controlling"
parent: Abnormal
ancestor: Funcons-beta
---
[Funcons-beta] : [Controlling.cbs]
-----------------------------
### Controlling
<div class="highlighter-rouge"><pre class="highlight"><code>[
<i class="keyword">Datatype</i> <span class="name"><a href="#Name_continuations">continuations</a></span>
<i class="keyword">Funcon</i> <span class="name"><a href="#Name_continuation">continuation</a></span>
<i class="keyword">Entity</i> <span class="name"><a href="#Name_plug-signal">plug-signal</a></span>
<i class="keyword">Funcon</i> <span class="name"><a href="#Name_hole">hole</a></span>
<i class="keyword">Funcon</i> <span class="name"><a href="#Name_resume-continuation">resume-continuation</a></span>
<i class="keyword">Entity</i> <span class="name"><a href="#Name_control-signal">control-signal</a></span>
<i class="keyword">Funcon</i> <span class="name"><a href="#Name_control">control</a></span>
<i class="keyword">Funcon</i> <span class="name"><a href="#Name_delimit-current-continuation">delimit-current-continuation</a></span> <i class="keyword">Alias</i> <span class="name"><a href="#Name_delimit-cc">delimit-cc</a></span>
]</code></pre></div>
<div class="highlighter-rouge"><pre class="highlight"><code><i class="keyword">Meta-variables</i>
<span id="PartVariable_T"><i class="var">T</i></span>, <span id="PartVariable_T1"><i class="var">T<sub class="sub">1</sub></i></span>, <span id="PartVariable_T2"><i class="var">T<sub class="sub">2</sub></i></span> <: <span class="name"><a href="../../../Values/Value-Types/index.html#Name_values">values</a></span></code></pre></div>
<div class="highlighter-rouge"><pre class="highlight"><code><i class="keyword">Datatype</i>
<span class="name"><span id="Name_continuations">continuations</span></span>(<span id="Variable77_T1"><i class="var">T<sub class="sub">1</sub></i></span>,<span id="Variable84_T2"><i class="var">T<sub class="sub">2</sub></i></span>) ::= <span id="Name_continuation">continuation</span>(_:<span class="name"><a href="../../../Values/Abstraction/Generic/index.html#Name_abstractions">abstractions</a></span>(()=><span id="Variable108_T2"><i class="var">T<sub class="sub">2</sub></i></span>))</code></pre></div>
<code><span class="name"><a href="#Name_continuations">continuations</a></span>(<i class="var">T<sub class="sub">1</sub></i>, <i class="var">T<sub class="sub">2</sub></i>)</code> consists of abstractions whose bodies contain a <code><span class="name"><a href="#Name_hole">hole</a></span></code>,
and which will normally compute a value of type <code><i class="var">T<sub class="sub">2</sub></i></code> when the <code><span class="name"><a href="#Name_hole">hole</a></span></code> is plugged
with a value of type <code><i class="var">T<sub class="sub">1</sub></i></code>.
<div class="highlighter-rouge"><pre class="highlight"><code><i class="keyword">Entity</i>
_ --<span class="ent-name"><span id="Name_plug-signal">plug-signal</span></span>(<i class="var">V<sup class="sup">?</sup></i>:<span class="name"><a href="../../../Values/Value-Types/index.html#Name_values">values</a></span><sup class="sup">?</sup>)-> _</code></pre></div>
A plug-signal contains the value to be filled into a <code><span class="name"><a href="#Name_hole">hole</a></span></code> in a continuation,
thereby allowing a continuation to resume.
<div class="highlighter-rouge"><pre class="highlight"><code><i class="keyword">Funcon</i>
<span class="name"><span id="Name_hole">hole</span></span> : =><span class="name"><a href="../../../Values/Value-Types/index.html#Name_values">values</a></span></code></pre></div>
A <code><span class="name"><a href="#Name_hole">hole</a></span></code> in a term cannot proceed until it receives a plug-signal
containing a value to plug the hole.
<div class="highlighter-rouge"><pre class="highlight"><code><i class="keyword">Rule</i>
<span class="name"><a href="#Name_hole">hole</a></span> --<span class="ent-name"><a href="#Name_plug-signal">plug-signal</a></span>(<i class="var">V</i>)-> <i class="var">V</i></code></pre></div>
<div class="highlighter-rouge"><pre class="highlight"><code><i class="keyword">Funcon</i>
<span class="name"><span id="Name_resume-continuation">resume-continuation</span></span>(<span id="Variable304_K"><i class="var">K</i></span>:<span class="name"><a href="#Name_continuations">continuations</a></span>(<span id="Variable310_T1"><i class="var">T<sub class="sub">1</sub></i></span>, <span id="Variable316_T2"><i class="var">T<sub class="sub">2</sub></i></span>), <span id="Variable331_V"><i class="var">V</i></span>:<span id="Variable336_T1"><i class="var">T<sub class="sub">1</sub></i></span>) : =><span id="Variable352_T2"><i class="var">T<sub class="sub">2</sub></i></span></code></pre></div>
<code><span class="name"><a href="#Name_resume-continuation">resume-continuation</a></span>(<i class="var">K</i>, <i class="var">V</i>)</code> resumes a continuation <code><i class="var">K</i></code> by plugging the value
<code><i class="var">V</i></code> into the <code><span class="name"><a href="#Name_hole">hole</a></span></code> in the continuation.
<div class="highlighter-rouge"><pre class="highlight"><code><i class="keyword">Rule</i>
<a href="#Variable469_X"><i class="var">X</i></a> --<span class="ent-name"><a href="#Name_plug-signal">plug-signal</a></span>(<span id="Variable437_V"><i class="var">V</i></span>)-> <span id="Variable454_X'"><i class="var">X&prime;</i></span>
---------------------------------------------------------------------------
<span class="name"><a href="#Name_resume-continuation">resume-continuation</a></span>(<span class="name"><a href="#Name_continuation">continuation</a></span>(<span class="name"><a href="../../../Values/Abstraction/Generic/index.html#Name_abstraction">abstraction</a></span>(<span id="Variable469_X"><i class="var">X</i></span>)), <span id="Variable486_V"><i class="var">V</i></span>:<i class="var">T</i>) --<span class="ent-name"><a href="#Name_plug-signal">plug-signal</a></span>()-> <a href="#Variable454_X'"><i class="var">X&prime;</i></a></code></pre></div>
<div class="highlighter-rouge"><pre class="highlight"><code><i class="keyword">Entity</i>
_ --<span class="ent-name"><span id="Name_control-signal">control-signal</span></span>(<i class="var">F<sup class="sup">?</sup></i>:(<span class="name"><a href="../../../Values/Abstraction/Functions/index.html#Name_functions">functions</a></span>(<span class="name"><a href="#Name_continuations">continuations</a></span>(<i class="var">T<sub class="sub">1</sub></i>, <i class="var">T<sub class="sub">2</sub></i>), <i class="var">T<sub class="sub">2</sub></i>))<sup class="sup">?</sup>)-> _</code></pre></div>
A control-signal contains the function to which control is about to be passed
by the enclosing <code><span class="name"><a href="#Name_delimit-current-continuation">delimit-current-continuation</a></span>(<i class="var">X</i>)</code>.
<div class="highlighter-rouge"><pre class="highlight"><code><i class="keyword">Funcon</i>
<span class="name"><span id="Name_control">control</span></span>(<span id="Variable606_F"><i class="var">F</i></span>:<span class="name"><a href="../../../Values/Abstraction/Functions/index.html#Name_functions">functions</a></span>(<span class="name"><a href="#Name_continuations">continuations</a></span>(<span id="Variable613_T1"><i class="var">T<sub class="sub">1</sub></i></span>, <span id="Variable619_T2"><i class="var">T<sub class="sub">2</sub></i></span>), <span id="Variable632_T2"><i class="var">T<sub class="sub">2</sub></i></span>)) : =><span id="Variable654_T1"><i class="var">T<sub class="sub">1</sub></i></span></code></pre></div>
<code><span class="name"><a href="#Name_control">control</a></span>(<i class="var">F</i>)</code> emits a control-signal that, when handled by an enclosing
<code><span class="name"><a href="#Name_delimit-current-continuation">delimit-current-continuation</a></span>(<i class="var">X</i>)</code>, will apply <code><i class="var">F</i></code> to the current continuation of
<code><span class="name"><a href="#Name_control">control</a></span>(<i class="var">F</i>)</code>, (rather than proceeding with that current continuation).
<div class="highlighter-rouge"><pre class="highlight"><code><i class="keyword">Rule</i>
<span class="name"><a href="#Name_control">control</a></span>(<span id="Variable743_F"><i class="var">F</i></span>:<span class="name"><a href="../../../Values/Abstraction/Functions/index.html#Name_functions">functions</a></span>(_,_)) --<span class="ent-name"><a href="#Name_control-signal">control-signal</a></span>(<a href="#Variable743_F"><i class="var">F</i></a>)-> <span class="name"><a href="#Name_hole">hole</a></span></code></pre></div>
<div class="highlighter-rouge"><pre class="highlight"><code><i class="keyword">Funcon</i>
<span class="name"><span id="Name_delimit-current-continuation">delimit-current-continuation</span></span>(<span id="Variable797_X"><i class="var">X</i></span>:=><span id="Variable802_T"><i class="var">T</i></span>) : =><span id="Variable817_T"><i class="var">T</i></span>
<i class="keyword">Alias</i>
<span class="name"><span id="Name_delimit-cc">delimit-cc</span></span> = <span class="name"><a href="#Name_delimit-current-continuation">delimit-current-continuation</a></span></code></pre></div>
<code><span class="name"><a href="#Name_delimit-current-continuation">delimit-current-continuation</a></span>(<i class="var">X</i>)</code> delimits the scope of captured continuations.
<div class="highlighter-rouge"><pre class="highlight"><code><i class="keyword">Rule</i>
<span class="name"><a href="#Name_delimit-current-continuation">delimit-current-continuation</a></span>(<span id="Variable855_V"><i class="var">V</i></span>:<i class="var">T</i>) ~> <a href="#Variable855_V"><i class="var">V</i></a>
<i class="keyword">Rule</i>
<a href="#Variable913_X"><i class="var">X</i></a> --<span class="ent-name"><a href="#Name_control-signal">control-signal</a></span>( )-> <span id="Variable900_X'"><i class="var">X&prime;</i></span>
-----------------------------------------------------
<span class="name"><a href="#Name_delimit-current-continuation">delimit-current-continuation</a></span>(<span id="Variable913_X"><i class="var">X</i></span>) --<span class="ent-name"><a href="#Name_control-signal">control-signal</a></span>( )->
<span class="name"><a href="#Name_delimit-current-continuation">delimit-current-continuation</a></span>(<a href="#Variable900_X'"><i class="var">X&prime;</i></a>)
<i class="keyword">Rule</i>
<a href="#Variable993_X"><i class="var">X</i></a> --<span class="ent-name"><a href="#Name_control-signal">control-signal</a></span>(<span id="Variable963_F"><i class="var">F</i></span>)-> <span id="Variable980_X'"><i class="var">X&prime;</i></span>
------------------------------------------------------------------
<span class="name"><a href="#Name_delimit-current-continuation">delimit-current-continuation</a></span>(<span id="Variable993_X"><i class="var">X</i></span>) --<span class="ent-name"><a href="#Name_control-signal">control-signal</a></span>( )->
<span class="name"><a href="#Name_delimit-current-continuation">delimit-current-continuation</a></span>(<span class="name"><a href="../../../Values/Abstraction/Functions/index.html#Name_apply">apply</a></span>(<a href="#Variable963_F"><i class="var">F</i></a>, <span class="name"><a href="#Name_continuation">continuation</a></span> <span class="name"><a href="../../../Values/Abstraction/Generic/index.html#Name_closure">closure</a></span>(<a href="#Variable980_X'"><i class="var">X&prime;</i></a>)))</code></pre></div>
____
From the [PLanCompS Project] | [CBS-beta issues...] | [Suggest an improvement...]
[Controlling.cbs]: Controlling.cbs
"CBS SOURCE FILE"
[Funcons-beta]: /CBS-beta/docs/Funcons-beta
"FUNCONS-BETA"
[Unstable-Funcons-beta]: /CBS-beta/docs/Unstable-Funcons-beta
"UNSTABLE-FUNCONS-BETA"
[Languages-beta]: /CBS-beta/docs/Languages-beta
"LANGUAGES-BETA"
[Unstable-Languages-beta]: /CBS-beta/docs/Unstable-Languages-beta
"UNSTABLE-LANGUAGES-BETA"
[CBS-beta]: /CBS-beta "CBS-BETA"
[PLanCompS Project]: https://plancomps.github.io
"PROGRAMMING LANGUAGE COMPONENTS AND SPECIFICATIONS PROJECT HOME PAGE"
[CBS-beta issues...]: https://github.com/plancomps/CBS-beta/issues
"CBS-BETA ISSUE REPORTS ON GITHUB"
[Suggest an improvement...]: mailto:plancomps@gmail.com?Subject=CBS-beta%20-%20comment&Body=Re%3A%20CBS-beta%20specification%20at%20Computations/Abnormal/Controlling/Controlling.cbs%0A%0AComment/Query/Issue/Suggestion%3A%0A%0A%0ASignature%3A%0A
"GENERATE AN EMAIL TEMPLATE"

108
IBAF-cbs/Funcons-beta/Computations/Abnormal/Failing/Failing.cbs Normal file
View File

@@ -0,0 +1,108 @@
### Failing
[
Datatype failing
Funcon failed
Funcon finalise-failing
Funcon fail
Funcon else
Funcon else-choice
Funcon checked
Funcon check-true
]
Meta-variables
T <: values
Datatype
failing ::= failed
/*
`failed` is a reason for abrupt termination.
*/
Funcon
finalise-failing(X:=>T) : =>T|null-type
~> finalise-abrupting(X)
/*
`finalise-failing(X)` handles abrupt termination of `X` due to executing `fail`.
*/
Funcon
fail : =>empty-type
~> abrupt(failed)
/*
`fail` abruptly terminates all enclosing computations until it is handled.
*/
Funcon
else(_:=>T, _:(=>T)+) : =>T
/*
`else(X1, X2, ...)` executes the arguments in turn until either some
`Xi` does *not* fail, or all arguments `Xi` have been executed.
The last argument executed determines the result.
`else(X, Y)` is associative, with unit `fail`.
*/
Rule
X --abrupted( )-> X'
--------------------------------------
else(X, Y) --abrupted( )-> else(X', Y)
Rule
X --abrupted(failed)-> _
---------------------------------
else(X, Y) --abrupted( )-> Y
Rule
X --abrupted(V:~failing)-> X'
--------------------------------------
else(X, Y) --abrupted(V)-> else(X', Y)
Rule
else(V:T, Y) ~> V
Rule
else(X, Y, Z+) ~> else(X, else(Y, Z+))
Funcon
else-choice(_:(=>T)+) : =>T
/*
`else-choice(X,...)` executes the arguments in any order until either some
`Xi` does *not* fail, or all arguments `Xi` have been executed.
The last argument executed determines the result.
`else(X, Y)` is associative and commutative, with unit `fail`.
*/
Rule
else-choice(W*, X, Y, Z*)
~> choice(else(X, else-choice(W*, Y, Z*),
else(Y, else-choice(W*, X, Z*))))
Rule
else-choice(X) ~> X
Funcon
check-true(_:booleans) : =>null-type
Alias
check = check-true
/*
`check-true(X)` terminates normally if the value computed by `X` is `true`,
and fails if it is `false`.
*/
Rule
check-true(true) ~> null-value
Rule
check-true(false) ~> fail
Funcon
checked(_:(T)?) : =>T
/*
`checked(X)` fails when `X` gives the empty sequence of values `( )`,
representing that an optional value has not been computed. It otherwise
computes the same as `X`.
*/
Rule
checked(V:T) ~> V
Rule
checked( ) ~> fail

149
IBAF-cbs/Funcons-beta/Computations/Abnormal/Failing/index.md Normal file
View File

@@ -0,0 +1,149 @@
---
layout: default
title: "Failing"
parent: Abnormal
ancestor: Funcons-beta
---
[Funcons-beta] : [Failing.cbs]
-----------------------------
### Failing
<div class="highlighter-rouge"><pre class="highlight"><code>[
<i class="keyword">Datatype</i> <span class="name"><a href="#Name_failing">failing</a></span>
<i class="keyword">Funcon</i> <span class="name"><a href="#Name_failed">failed</a></span>
<i class="keyword">Funcon</i> <span class="name"><a href="#Name_finalise-failing">finalise-failing</a></span>
<i class="keyword">Funcon</i> <span class="name"><a href="#Name_fail">fail</a></span>
<i class="keyword">Funcon</i> <span class="name"><a href="#Name_else">else</a></span>
<i class="keyword">Funcon</i> <span class="name"><a href="#Name_else-choice">else-choice</a></span>
<i class="keyword">Funcon</i> <span class="name"><a href="#Name_checked">checked</a></span>
<i class="keyword">Funcon</i> <span class="name"><a href="#Name_check-true">check-true</a></span>
]</code></pre></div>
<div class="highlighter-rouge"><pre class="highlight"><code><i class="keyword">Meta-variables</i>
<span id="PartVariable_T"><i class="var">T</i></span> <: <span class="name"><a href="../../../Values/Value-Types/index.html#Name_values">values</a></span></code></pre></div>
<div class="highlighter-rouge"><pre class="highlight"><code><i class="keyword">Datatype</i>
<span class="name"><span id="Name_failing">failing</span></span> ::= <span id="Name_failed">failed</span></code></pre></div>
<code><span class="name"><a href="#Name_failed">failed</a></span></code> is a reason for abrupt termination.
<div class="highlighter-rouge"><pre class="highlight"><code><i class="keyword">Funcon</i>
<span class="name"><span id="Name_finalise-failing">finalise-failing</span></span>(<span id="Variable88_X"><i class="var">X</i></span>:=><span id="Variable93_T"><i class="var">T</i></span>) : =><span id="Variable108_T"><i class="var">T</i></span>|<span class="name"><a href="../../../Values/Primitive/Null/index.html#Name_null-type">null-type</a></span>
~> <span class="name"><a href="../Abrupting/index.html#Name_finalise-abrupting">finalise-abrupting</a></span>(<a href="#Variable88_X"><i class="var">X</i></a>)</code></pre></div>
<code><span class="name"><a href="#Name_finalise-failing">finalise-failing</a></span>(<i class="var">X</i>)</code> handles abrupt termination of <code><i class="var">X</i></code> due to executing <code><span class="name"><a href="#Name_fail">fail</a></span></code>.
<div class="highlighter-rouge"><pre class="highlight"><code><i class="keyword">Funcon</i>
<span class="name"><span id="Name_fail">fail</span></span> : =><span class="name"><a href="../../../Values/Value-Types/index.html#Name_empty-type">empty-type</a></span>
~> <span class="name"><a href="../Abrupting/index.html#Name_abrupt">abrupt</a></span>(<span class="name"><a href="#Name_failed">failed</a></span>)</code></pre></div>
<code><span class="name"><a href="#Name_fail">fail</a></span></code> abruptly terminates all enclosing computations until it is handled.
<div class="highlighter-rouge"><pre class="highlight"><code><i class="keyword">Funcon</i>
<span class="name"><span id="Name_else">else</span></span>(_:=><span id="Variable220_T"><i class="var">T</i></span>, _:(=><span id="Variable233_T"><i class="var">T</i></span>)<sup class="sup">+</sup>) : =><span id="Variable256_T"><i class="var">T</i></span></code></pre></div>
<code><span class="name"><a href="#Name_else">else</a></span>(<i class="var">X<sub class="sub">1</sub></i>, <i class="var">X<sub class="sub">2</sub></i>, ...)</code> executes the arguments in turn until either some
<code><i class="var">Xi</i></code> does *not* fail, or all arguments <code><i class="var">Xi</i></code> have been executed.
The last argument executed determines the result.
<code><span class="name"><a href="#Name_else">else</a></span>(<i class="var">X</i>, <i class="var">Y</i>)</code> is associative, with unit <code><span class="name"><a href="#Name_fail">fail</a></span></code>.
<div class="highlighter-rouge"><pre class="highlight"><code><i class="keyword">Rule</i>
<a href="#Variable409_X"><i class="var">X</i></a> --<span class="ent-name"><a href="../Abrupting/index.html#Name_abrupted">abrupted</a></span>( )-> <span id="Variable396_X'"><i class="var">X&prime;</i></span>
--------------------------------------
<span class="name"><a href="#Name_else">else</a></span>(<span id="Variable409_X"><i class="var">X</i></span>, <span id="Variable414_Y"><i class="var">Y</i></span>) --<span class="ent-name"><a href="../Abrupting/index.html#Name_abrupted">abrupted</a></span>( )-> <span class="name"><a href="#Name_else">else</a></span>(<a href="#Variable396_X'"><i class="var">X&prime;</i></a>, <a href="#Variable414_Y"><i class="var">Y</i></a>)
<i class="keyword">Rule</i>
<a href="#Variable496_X"><i class="var">X</i></a> --<span class="ent-name"><a href="../Abrupting/index.html#Name_abrupted">abrupted</a></span>(<span class="name"><a href="#Name_failed">failed</a></span>)-> _
---------------------------------
<span class="name"><a href="#Name_else">else</a></span>(<span id="Variable496_X"><i class="var">X</i></span>, <span id="Variable501_Y"><i class="var">Y</i></span>) --<span class="ent-name"><a href="../Abrupting/index.html#Name_abrupted">abrupted</a></span>( )-> <a href="#Variable501_Y"><i class="var">Y</i></a>
<i class="keyword">Rule</i>
<a href="#Variable578_X"><i class="var">X</i></a> --<span class="ent-name"><a href="../Abrupting/index.html#Name_abrupted">abrupted</a></span>(<span id="Variable544_V"><i class="var">V</i></span>:~<span class="name"><a href="#Name_failing">failing</a></span>)-> <span id="Variable565_X'"><i class="var">X&prime;</i></span>
--------------------------------------
<span class="name"><a href="#Name_else">else</a></span>(<span id="Variable578_X"><i class="var">X</i></span>, <span id="Variable583_Y"><i class="var">Y</i></span>) --<span class="ent-name"><a href="../Abrupting/index.html#Name_abrupted">abrupted</a></span>(<a href="#Variable544_V"><i class="var">V</i></a>)-> <span class="name"><a href="#Name_else">else</a></span>(<a href="#Variable565_X'"><i class="var">X&prime;</i></a>, <a href="#Variable583_Y"><i class="var">Y</i></a>)
<i class="keyword">Rule</i>
<span class="name"><a href="#Name_else">else</a></span>(<span id="Variable638_V"><i class="var">V</i></span>:<i class="var">T</i>, <span id="Variable649_Y"><i class="var">Y</i></span>) ~> <a href="#Variable638_V"><i class="var">V</i></a>
<i class="keyword">Rule</i>
<span class="name"><a href="#Name_else">else</a></span>(<span id="Variable670_X"><i class="var">X</i></span>, <span id="Variable675_Y"><i class="var">Y</i></span>, <span id="Variable681_Z+"><i class="var">Z<sup class="sup">+</sup></i></span>) ~> <span class="name"><a href="#Name_else">else</a></span>(<a href="#Variable670_X"><i class="var">X</i></a>, <span class="name"><a href="#Name_else">else</a></span>(<a href="#Variable675_Y"><i class="var">Y</i></a>, <a href="#Variable681_Z+"><i class="var">Z<sup class="sup">+</sup></i></a>))</code></pre></div>
<div class="highlighter-rouge"><pre class="highlight"><code><i class="keyword">Funcon</i>
<span class="name"><span id="Name_else-choice">else-choice</span></span>(_:(=><span id="Variable734_T"><i class="var">T</i></span>)<sup class="sup">+</sup>) : =><span id="Variable756_T"><i class="var">T</i></span></code></pre></div>
<code><span class="name"><a href="#Name_else-choice">else-choice</a></span>(<i class="var">X</i>,...)</code> executes the arguments in any order until either some
<code><i class="var">Xi</i></code> does *not* fail, or all arguments <code><i class="var">Xi</i></code> have been executed.
The last argument executed determines the result.
<code><span class="name"><a href="#Name_else">else</a></span>(<i class="var">X</i>, <i class="var">Y</i>)</code> is associative and commutative, with unit <code><span class="name"><a href="#Name_fail">fail</a></span></code>.
<div class="highlighter-rouge"><pre class="highlight"><code><i class="keyword">Rule</i>
<span class="name"><a href="#Name_else-choice">else-choice</a></span>(<span id="Variable870_W*"><i class="var">W<sup class="sup">*</sup></i></span>, <span id="Variable875_X"><i class="var">X</i></span>, <span id="Variable880_Y"><i class="var">Y</i></span>, <span id="Variable886_Z*"><i class="var">Z<sup class="sup">*</sup></i></span>)
~> <span class="name"><a href="../../Normal/Flowing/index.html#Name_choice">choice</a></span>(<span class="name"><a href="#Name_else">else</a></span>(<a href="#Variable875_X"><i class="var">X</i></a>, <span class="name"><a href="#Name_else-choice">else-choice</a></span>(<a href="#Variable870_W*"><i class="var">W<sup class="sup">*</sup></i></a>, <a href="#Variable880_Y"><i class="var">Y</i></a>, <a href="#Variable886_Z*"><i class="var">Z<sup class="sup">*</sup></i></a>),
<span class="name"><a href="#Name_else">else</a></span>(<a href="#Variable880_Y"><i class="var">Y</i></a>, <span class="name"><a href="#Name_else-choice">else-choice</a></span>(<a href="#Variable870_W*"><i class="var">W<sup class="sup">*</sup></i></a>, <a href="#Variable875_X"><i class="var">X</i></a>, <a href="#Variable886_Z*"><i class="var">Z<sup class="sup">*</sup></i></a>))))
<i class="keyword">Rule</i>
<span class="name"><a href="#Name_else-choice">else-choice</a></span>(<span id="Variable990_X"><i class="var">X</i></span>) ~> <a href="#Variable990_X"><i class="var">X</i></a></code></pre></div>
<div class="highlighter-rouge"><pre class="highlight"><code><i class="keyword">Funcon</i>
<span class="name"><span id="Name_check-true">check-true</span></span>(_:<span class="name"><a href="../../../Values/Primitive/Booleans/index.html#Name_booleans">booleans</a></span>) : =><span class="name"><a href="../../../Values/Primitive/Null/index.html#Name_null-type">null-type</a></span>
<i class="keyword">Alias</i>
<span class="name"><span id="Name_check">check</span></span> = <span class="name"><a href="#Name_check-true">check-true</a></span></code></pre></div>
<code><span class="name"><a href="#Name_check-true">check-true</a></span>(<i class="var">X</i>)</code> terminates normally if the value computed by <code><i class="var">X</i></code> is <code><span class="name"><a href="../../../Values/Primitive/Booleans/index.html#Name_true">true</a></span></code>,
and fails if it is <code><span class="name"><a href="../../../Values/Primitive/Booleans/index.html#Name_false">false</a></span></code>.
<div class="highlighter-rouge"><pre class="highlight"><code><i class="keyword">Rule</i>
<span class="name"><a href="#Name_check-true">check-true</a></span>(<span class="name"><a href="../../../Values/Primitive/Booleans/index.html#Name_true">true</a></span>) ~> <span class="name"><a href="../../../Values/Primitive/Null/index.html#Name_null-value">null-value</a></span>
<i class="keyword">Rule</i>
<span class="name"><a href="#Name_check-true">check-true</a></span>(<span class="name"><a href="../../../Values/Primitive/Booleans/index.html#Name_false">false</a></span>) ~> <span class="name"><a href="#Name_fail">fail</a></span></code></pre></div>
<div class="highlighter-rouge"><pre class="highlight"><code><i class="keyword">Funcon</i>
<span class="name"><span id="Name_checked">checked</span></span>(_:(<span id="Variable1123_T"><i class="var">T</i></span>)<sup class="sup">?</sup>) : =><span id="Variable1144_T"><i class="var">T</i></span></code></pre></div>
<code><span class="name"><a href="#Name_checked">checked</a></span>(<i class="var">X</i>)</code> fails when <code><i class="var">X</i></code> gives the empty sequence of values <code>( )</code>,
representing that an optional value has not been computed. It otherwise
computes the same as <code><i class="var">X</i></code>.
<div class="highlighter-rouge"><pre class="highlight"><code><i class="keyword">Rule</i>
<span class="name"><a href="#Name_checked">checked</a></span>(<span id="Variable1217_V"><i class="var">V</i></span>:<i class="var">T</i>) ~> <a href="#Variable1217_V"><i class="var">V</i></a>
<i class="keyword">Rule</i>
<span class="name"><a href="#Name_checked">checked</a></span>( ) ~> <span class="name"><a href="#Name_fail">fail</a></span></code></pre></div>
____
From the [PLanCompS Project] | [CBS-beta issues...] | [Suggest an improvement...]
[Failing.cbs]: Failing.cbs
"CBS SOURCE FILE"
[Funcons-beta]: /CBS-beta/docs/Funcons-beta
"FUNCONS-BETA"
[Unstable-Funcons-beta]: /CBS-beta/docs/Unstable-Funcons-beta
"UNSTABLE-FUNCONS-BETA"
[Languages-beta]: /CBS-beta/docs/Languages-beta
"LANGUAGES-BETA"
[Unstable-Languages-beta]: /CBS-beta/docs/Unstable-Languages-beta
"UNSTABLE-LANGUAGES-BETA"
[CBS-beta]: /CBS-beta "CBS-BETA"
[PLanCompS Project]: https://plancomps.github.io
"PROGRAMMING LANGUAGE COMPONENTS AND SPECIFICATIONS PROJECT HOME PAGE"
[CBS-beta issues...]: https://github.com/plancomps/CBS-beta/issues
"CBS-BETA ISSUE REPORTS ON GITHUB"
[Suggest an improvement...]: mailto:plancomps@gmail.com?Subject=CBS-beta%20-%20comment&Body=Re%3A%20CBS-beta%20specification%20at%20Computations/Abnormal/Failing/Failing.cbs%0A%0AComment/Query/Issue/Suggestion%3A%0A%0A%0ASignature%3A%0A
"GENERATE AN EMAIL TEMPLATE"

16
IBAF-cbs/Funcons-beta/Computations/Abnormal/Failing/tests/check-true.config Normal file
View File

@@ -0,0 +1,16 @@
general {
funcon-term:
finalise-failing
sequential(
check-true(true), print 1,
else(check-true(false), print 2),
check-true(not false), print 3,
print sequential(check-true(true),4)
)
;
}
tests {
result-term: null-value;
standard-out: [1, 2, 3, 4];
}

16
IBAF-cbs/Funcons-beta/Computations/Abnormal/Failing/tests/checked.config Normal file
View File

@@ -0,0 +1,16 @@
general {
funcon-term:
finalise-failing
sequential(
effect(checked(true)), print 1,
else(effect(checked()), print 2),
else(effect(checked(map-lookup(map(),1))), print 3),
print(checked(map-lookup(map(tuple(0,1),tuple(1,4)),1)))
)
;
}
tests {
result-term: null-value;
standard-out: [1, 2, 3, 4];
}

14
IBAF-cbs/Funcons-beta/Computations/Abnormal/Failing/tests/defined.config Normal file
View File

@@ -0,0 +1,14 @@
general {
funcon-term:
finalise-failing
sequential(
effect(checked(42)), print 1,
else(checked(sequential(print(2),lookup(map-empty,"x"))), print 3)
)
;
}
tests {
result-term: null-value;
standard-out: [1, 2, 3];
}

16
IBAF-cbs/Funcons-beta/Computations/Abnormal/Failing/tests/else-choice.config Normal file
View File

@@ -0,0 +1,16 @@
general {
funcon-term:
finalise-failing finalise-abrupting
sequential(
else-choice(print 1),
else-choice(fail, fail, fail, print 2, fail, print 3)
)
;
}
tests {
result-term: null-value;
standard-out: [1, 2];
// Also possible:
// standard-out: [1, 3];
}

19
IBAF-cbs/Funcons-beta/Computations/Abnormal/Failing/tests/else.config Normal file
View File

@@ -0,0 +1,19 @@
general {
funcon-term:
finalise-failing finalise-abrupting
sequential(
else(fail, print 1),
print else(2, fail),
else(print 3, fail),
handle-abrupt(
else(abrupt(true), print 99),
print 4),
else(fail, fail, print 5)
)
;
}
tests {
result-term: null-value;
standard-out: [1, 2, 3, 4, 5];
}

60
IBAF-cbs/Funcons-beta/Computations/Abnormal/Returning/Returning.cbs Normal file
View File

@@ -0,0 +1,60 @@
### Returning
[
Datatype returning
Funcon returned
Funcon finalise-returning
Funcon return
Funcon handle-return
]
Meta-variables
T <: values
Datatype
returning ::= returned(_:values)
/*
`returned(V?)` is a reason for abrupt termination.
*/
Funcon
finalise-returning(X:=>T) : =>T|null-type
~> finalise-abrupting(X)
/*
`finalise-returning(X)` handles abrupt termination of `X` due to
executing `return(V)`.
*/
Funcon
return(V:T) : =>empty-type
~> abrupt(returned(V))
/*
`return(V)` abruptly terminates all enclosing computations until it is
handled, then giving `V`. Note that `V` may be `null-value`.
*/
Funcon
handle-return(_:=>T) : =>T
/*
`handle-return(X)` first evaluates `X`. If `X` either terminates abruptly for
reason `returned(V)`, or terminates normally with value `V`, it gives `V`.
*/
Rule
X --abrupted( )-> X'
--------------------------------------------------
handle-return(X) --abrupted( )-> handle-return(X')
Rule
X --abrupted(returned(V:values))-> X'
----------------------------------------------
handle-return(X) --abrupted( )-> V
Rule
X --abrupted(V':~returning)-> X'
---------------------------------------------------
handle-return(X) --abrupted(V')-> handle-return(X')
Rule
handle-return(V:T) ~> V

100
IBAF-cbs/Funcons-beta/Computations/Abnormal/Returning/index.md Normal file
View File

@@ -0,0 +1,100 @@
---
layout: default
title: "Returning"
parent: Abnormal
ancestor: Funcons-beta
---
[Funcons-beta] : [Returning.cbs]
-----------------------------
### Returning
<div class="highlighter-rouge"><pre class="highlight"><code>[
<i class="keyword">Datatype</i> <span class="name"><a href="#Name_returning">returning</a></span>
<i class="keyword">Funcon</i> <span class="name"><a href="#Name_returned">returned</a></span>
<i class="keyword">Funcon</i> <span class="name"><a href="#Name_finalise-returning">finalise-returning</a></span>
<i class="keyword">Funcon</i> <span class="name"><a href="#Name_return">return</a></span>
<i class="keyword">Funcon</i> <span class="name"><a href="#Name_handle-return">handle-return</a></span>
]</code></pre></div>
<div class="highlighter-rouge"><pre class="highlight"><code><i class="keyword">Meta-variables</i>
<span id="PartVariable_T"><i class="var">T</i></span> <: <span class="name"><a href="../../../Values/Value-Types/index.html#Name_values">values</a></span></code></pre></div>
<div class="highlighter-rouge"><pre class="highlight"><code><i class="keyword">Datatype</i>
<span class="name"><span id="Name_returning">returning</span></span> ::= <span id="Name_returned">returned</span>(_:<span class="name"><a href="../../../Values/Value-Types/index.html#Name_values">values</a></span>)</code></pre></div>
<code><span class="name"><a href="#Name_returned">returned</a></span>(<i class="var">V<sup class="sup">?</sup></i>)</code> is a reason for abrupt termination.
<div class="highlighter-rouge"><pre class="highlight"><code><i class="keyword">Funcon</i>
<span class="name"><span id="Name_finalise-returning">finalise-returning</span></span>(<span id="Variable99_X"><i class="var">X</i></span>:=><span id="Variable104_T"><i class="var">T</i></span>) : =><span id="Variable119_T"><i class="var">T</i></span>|<span class="name"><a href="../../../Values/Primitive/Null/index.html#Name_null-type">null-type</a></span>
~> <span class="name"><a href="../Abrupting/index.html#Name_finalise-abrupting">finalise-abrupting</a></span>(<a href="#Variable99_X"><i class="var">X</i></a>)</code></pre></div>
<code><span class="name"><a href="#Name_finalise-returning">finalise-returning</a></span>(<i class="var">X</i>)</code> handles abrupt termination of <code><i class="var">X</i></code> due to
executing <code><span class="name"><a href="#Name_return">return</a></span>(<i class="var">V</i>)</code>.
<div class="highlighter-rouge"><pre class="highlight"><code><i class="keyword">Funcon</i>
<span class="name"><span id="Name_return">return</span></span>(<span id="Variable203_V"><i class="var">V</i></span>:<span id="Variable207_T"><i class="var">T</i></span>) : =><span class="name"><a href="../../../Values/Value-Types/index.html#Name_empty-type">empty-type</a></span>
~> <span class="name"><a href="../Abrupting/index.html#Name_abrupt">abrupt</a></span>(<span class="name"><a href="#Name_returned">returned</a></span>(<a href="#Variable203_V"><i class="var">V</i></a>))</code></pre></div>
<code><span class="name"><a href="#Name_return">return</a></span>(<i class="var">V</i>)</code> abruptly terminates all enclosing computations until it is
handled, then giving <code><i class="var">V</i></code>. Note that <code><i class="var">V</i></code> may be <code><span class="name"><a href="../../../Values/Primitive/Null/index.html#Name_null-value">null-value</a></span></code>.
<div class="highlighter-rouge"><pre class="highlight"><code><i class="keyword">Funcon</i>
<span class="name"><span id="Name_handle-return">handle-return</span></span>(_:=><span id="Variable313_T"><i class="var">T</i></span>) : =><span id="Variable328_T"><i class="var">T</i></span></code></pre></div>
<code><span class="name"><a href="#Name_handle-return">handle-return</a></span>(<i class="var">X</i>)</code> first evaluates <code><i class="var">X</i></code>. If <code><i class="var">X</i></code> either terminates abruptly for
reason <code><span class="name"><a href="#Name_returned">returned</a></span>(<i class="var">V</i>)</code>, or terminates normally with value <code><i class="var">V</i></code>, it gives <code><i class="var">V</i></code>.
<div class="highlighter-rouge"><pre class="highlight"><code><i class="keyword">Rule</i>
<a href="#Variable467_X"><i class="var">X</i></a> --<span class="ent-name"><a href="../Abrupting/index.html#Name_abrupted">abrupted</a></span>( )-> <span id="Variable454_X'"><i class="var">X&prime;</i></span>
--------------------------------------------------
<span class="name"><a href="#Name_handle-return">handle-return</a></span>(<span id="Variable467_X"><i class="var">X</i></span>) --<span class="ent-name"><a href="../Abrupting/index.html#Name_abrupted">abrupted</a></span>( )-> <span class="name"><a href="#Name_handle-return">handle-return</a></span>(<a href="#Variable454_X'"><i class="var">X&prime;</i></a>)
<i class="keyword">Rule</i>
<a href="#Variable557_X"><i class="var">X</i></a> --<span class="ent-name"><a href="../Abrupting/index.html#Name_abrupted">abrupted</a></span>(<span class="name"><a href="#Name_returned">returned</a></span>(<span id="Variable518_V"><i class="var">V</i></span>:<span class="name"><a href="../../../Values/Value-Types/index.html#Name_values">values</a></span>))-> <span id="Variable544_X'"><i class="var">X&prime;</i></span>
----------------------------------------------
<span class="name"><a href="#Name_handle-return">handle-return</a></span>(<span id="Variable557_X"><i class="var">X</i></span>) --<span class="ent-name"><a href="../Abrupting/index.html#Name_abrupted">abrupted</a></span>( )-> <a href="#Variable518_V"><i class="var">V</i></a>
<i class="keyword">Rule</i>
<a href="#Variable634_X"><i class="var">X</i></a> --<span class="ent-name"><a href="../Abrupting/index.html#Name_abrupted">abrupted</a></span>(<span id="Variable600_V'"><i class="var">V&prime;</i></span>:~<span class="name"><a href="#Name_returning">returning</a></span>)-> <span id="Variable621_X'"><i class="var">X&prime;</i></span>
---------------------------------------------------
<span class="name"><a href="#Name_handle-return">handle-return</a></span>(<span id="Variable634_X"><i class="var">X</i></span>) --<span class="ent-name"><a href="../Abrupting/index.html#Name_abrupted">abrupted</a></span>(<a href="#Variable600_V'"><i class="var">V&prime;</i></a>)-> <span class="name"><a href="#Name_handle-return">handle-return</a></span>(<a href="#Variable621_X'"><i class="var">X&prime;</i></a>)
<i class="keyword">Rule</i>
<span class="name"><a href="#Name_handle-return">handle-return</a></span>(<span id="Variable683_V"><i class="var">V</i></span>:<i class="var">T</i>) ~> <a href="#Variable683_V"><i class="var">V</i></a></code></pre></div>
____
From the [PLanCompS Project] | [CBS-beta issues...] | [Suggest an improvement...]
[Returning.cbs]: Returning.cbs
"CBS SOURCE FILE"
[Funcons-beta]: /CBS-beta/docs/Funcons-beta
"FUNCONS-BETA"
[Unstable-Funcons-beta]: /CBS-beta/docs/Unstable-Funcons-beta
"UNSTABLE-FUNCONS-BETA"
[Languages-beta]: /CBS-beta/docs/Languages-beta
"LANGUAGES-BETA"
[Unstable-Languages-beta]: /CBS-beta/docs/Unstable-Languages-beta
"UNSTABLE-LANGUAGES-BETA"
[CBS-beta]: /CBS-beta "CBS-BETA"
[PLanCompS Project]: https://plancomps.github.io
"PROGRAMMING LANGUAGE COMPONENTS AND SPECIFICATIONS PROJECT HOME PAGE"
[CBS-beta issues...]: https://github.com/plancomps/CBS-beta/issues
"CBS-BETA ISSUE REPORTS ON GITHUB"
[Suggest an improvement...]: mailto:plancomps@gmail.com?Subject=CBS-beta%20-%20comment&Body=Re%3A%20CBS-beta%20specification%20at%20Computations/Abnormal/Returning/Returning.cbs%0A%0AComment/Query/Issue/Suggestion%3A%0A%0A%0ASignature%3A%0A
"GENERATE AN EMAIL TEMPLATE"

16
IBAF-cbs/Funcons-beta/Computations/Abnormal/Returning/tests/handle-return.config Normal file
View File

@@ -0,0 +1,16 @@
general {
funcon-term:
finalise-returning
sequential(
print handle-return(1),
handle-return(print 2),
print handle-return(
sequential(print 3, return(sequential(print 4, 5))))
)
;
}
tests {
result-term: null-value;
standard-out: [1, 2, 3, 4, 5];
}

86
IBAF-cbs/Funcons-beta/Computations/Abnormal/Throwing/Throwing.cbs Normal file
View File

@@ -0,0 +1,86 @@
### Throwing
[
Datatype throwing
Funcon thrown
Funcon finalise-throwing
Funcon throw
Funcon handle-thrown
Funcon handle-recursively
Funcon catch-else-throw
]
Meta-variables
R, S, T, T', T'' <: values
Datatype
throwing ::= thrown(_:values)
/*
`thrown(V)` is a reason for abrupt termination.
*/
Funcon
finalise-throwing(X:=>T) : =>T|null-type
~> finalise-abrupting(X)
/*
`finalise-throwing(X)` handles abrupt termination of `X` due to
executing `throw(V)`.
*/
Funcon
throw(V:T) : =>empty-type
~> abrupt(thrown(V))
/*
`throw(V)` abruptly terminates all enclosing computations uTil it is handled.
*/
Funcon
handle-thrown(_:T'=>T, _:T''=>T) : T'=>T
/*
`handle-thrown(X, Y)` first evaluates `X`. If `X` terminates normally with
value `V`, then `V` is returned and `Y` is ignored. If `X` terminates abruptly
with a thrown eTity having value `V`, then `Y` is executed with `V` as
`given` value.
`handle-thrown(X, Y)` is associative, with `throw(given)` as unit.
`handle-thrown(X, else(Y, throw(given)))` ensures that if `Y` fails, the
thrown value is re-thrown.
*/
Rule
X --abrupted( )-> X'
--------------------------------------------------------
handle-thrown(X, Y) --abrupted( )-> handle-thrown(X', Y)
Rule
X --abrupted(thrown(V'':values))-> X'
----------------------------------------------
handle-thrown(X, Y) --abrupted( )-> give(V'', Y)
Rule
X --abrupted(V':~throwing)-> X'
---------------------------------------------------------
handle-thrown(X, Y) --abrupted(V')-> handle-thrown(X', Y)
Rule
handle-thrown(V:T, Y) ~> V
Funcon
handle-recursively(X:S=>T, Y:R=>T) : S=>T
~> handle-thrown(X, else(handle-recursively(Y, Y), throw(given)))
/*
`handle-recursively(X, Y)` behaves similarly to `handle-thrown(X, Y)`, except
that another copy of the handler attempts to handle any values thrown by `Y`.
Thus, many thrown values may get handled by the same handler.
*/
Funcon
catch-else-throw(P:values, Y:=>T) : =>T
~> else(case-match(P, Y), throw(given))
/*
`handle-thrown(X, catch-else-throw(P, Y))` handles those values thrown by `X`
that match pattern `P`. Other thrown values are re-thrown.
*/

128
IBAF-cbs/Funcons-beta/Computations/Abnormal/Throwing/index.md Normal file
View File

@@ -0,0 +1,128 @@
---
layout: default
title: "Throwing"
parent: Abnormal
ancestor: Funcons-beta
---
[Funcons-beta] : [Throwing.cbs]
-----------------------------
### Throwing
<div class="highlighter-rouge"><pre class="highlight"><code>[
<i class="keyword">Datatype</i> <span class="name"><a href="#Name_throwing">throwing</a></span>
<i class="keyword">Funcon</i> <span class="name"><a href="#Name_thrown">thrown</a></span>
<i class="keyword">Funcon</i> <span class="name"><a href="#Name_finalise-throwing">finalise-throwing</a></span>
<i class="keyword">Funcon</i> <span class="name"><a href="#Name_throw">throw</a></span>
<i class="keyword">Funcon</i> <span class="name"><a href="#Name_handle-thrown">handle-thrown</a></span>
<i class="keyword">Funcon</i> <span class="name"><a href="#Name_handle-recursively">handle-recursively</a></span>
<i class="keyword">Funcon</i> <span class="name"><a href="#Name_catch-else-throw">catch-else-throw</a></span>
]</code></pre></div>
<div class="highlighter-rouge"><pre class="highlight"><code><i class="keyword">Meta-variables</i>
<span id="PartVariable_R"><i class="var">R</i></span>, <span id="PartVariable_S"><i class="var">S</i></span>, <span id="PartVariable_T"><i class="var">T</i></span>, <span id="PartVariable_T'"><i class="var">T&prime;</i></span>, <span id="PartVariable_T''"><i class="var">T&prime;&prime;</i></span> <: <span class="name"><a href="../../../Values/Value-Types/index.html#Name_values">values</a></span></code></pre></div>
<div class="highlighter-rouge"><pre class="highlight"><code><i class="keyword">Datatype</i>
<span class="name"><span id="Name_throwing">throwing</span></span> ::= <span id="Name_thrown">thrown</span>(_:<span class="name"><a href="../../../Values/Value-Types/index.html#Name_values">values</a></span>)</code></pre></div>
<code><span class="name"><a href="#Name_thrown">thrown</a></span>(<i class="var">V</i>)</code> is a reason for abrupt termination.
<div class="highlighter-rouge"><pre class="highlight"><code><i class="keyword">Funcon</i>
<span class="name"><span id="Name_finalise-throwing">finalise-throwing</span></span>(<span id="Variable128_X"><i class="var">X</i></span>:=><span id="Variable133_T"><i class="var">T</i></span>) : =><span id="Variable148_T"><i class="var">T</i></span>|<span class="name"><a href="../../../Values/Primitive/Null/index.html#Name_null-type">null-type</a></span>
~> <span class="name"><a href="../Abrupting/index.html#Name_finalise-abrupting">finalise-abrupting</a></span>(<a href="#Variable128_X"><i class="var">X</i></a>)</code></pre></div>
<code><span class="name"><a href="#Name_finalise-throwing">finalise-throwing</a></span>(<i class="var">X</i>)</code> handles abrupt termination of <code><i class="var">X</i></code> due to
executing <code><span class="name"><a href="#Name_throw">throw</a></span>(<i class="var">V</i>)</code>.
<div class="highlighter-rouge"><pre class="highlight"><code><i class="keyword">Funcon</i>
<span class="name"><span id="Name_throw">throw</span></span>(<span id="Variable232_V"><i class="var">V</i></span>:<span id="Variable236_T"><i class="var">T</i></span>) : =><span class="name"><a href="../../../Values/Value-Types/index.html#Name_empty-type">empty-type</a></span>
~> <span class="name"><a href="../Abrupting/index.html#Name_abrupt">abrupt</a></span>(<span class="name"><a href="#Name_thrown">thrown</a></span>(<a href="#Variable232_V"><i class="var">V</i></a>))</code></pre></div>
<code><span class="name"><a href="#Name_throw">throw</a></span>(<i class="var">V</i>)</code> abruptly terminates all enclosing computations uTil it is handled.
<div class="highlighter-rouge"><pre class="highlight"><code><i class="keyword">Funcon</i>
<span class="name"><span id="Name_handle-thrown">handle-thrown</span></span>(_:<span id="Variable306_T'"><i class="var">T&prime;</i></span>=><span id="Variable312_T"><i class="var">T</i></span>, _:<span id="Variable325_T''"><i class="var">T&prime;&prime;</i></span>=><span id="Variable331_T"><i class="var">T</i></span>) : <span id="Variable347_T'"><i class="var">T&prime;</i></span>=><span id="Variable353_T"><i class="var">T</i></span></code></pre></div>
<code><span class="name"><a href="#Name_handle-thrown">handle-thrown</a></span>(<i class="var">X</i>, <i class="var">Y</i>)</code> first evaluates <code><i class="var">X</i></code>. If <code><i class="var">X</i></code> terminates normally with
value <code><i class="var">V</i></code>, then <code><i class="var">V</i></code> is returned and <code><i class="var">Y</i></code> is ignored. If <code><i class="var">X</i></code> terminates abruptly
with a thrown eTity having value <code><i class="var">V</i></code>, then <code><i class="var">Y</i></code> is executed with <code><i class="var">V</i></code> as
<code><span class="name"><a href="../../Normal/Giving/index.html#Name_given">given</a></span></code> value.
<code><span class="name"><a href="#Name_handle-thrown">handle-thrown</a></span>(<i class="var">X</i>, <i class="var">Y</i>)</code> is associative, with <code><span class="name"><a href="#Name_throw">throw</a></span>(<span class="name"><a href="../../Normal/Giving/index.html#Name_given">given</a></span>)</code> as unit.
<code><span class="name"><a href="#Name_handle-thrown">handle-thrown</a></span>(<i class="var">X</i>, <span class="name"><a href="../Failing/index.html#Name_else">else</a></span>(<i class="var">Y</i>, <span class="name"><a href="#Name_throw">throw</a></span>(<span class="name"><a href="../../Normal/Giving/index.html#Name_given">given</a></span>)))</code> ensures that if <code><i class="var">Y</i></code> fails, the
thrown value is re-thrown.
<div class="highlighter-rouge"><pre class="highlight"><code><i class="keyword">Rule</i>
<a href="#Variable652_X"><i class="var">X</i></a> --<span class="ent-name"><a href="../Abrupting/index.html#Name_abrupted">abrupted</a></span>( )-> <span id="Variable639_X'"><i class="var">X&prime;</i></span>
--------------------------------------------------------
<span class="name"><a href="#Name_handle-thrown">handle-thrown</a></span>(<span id="Variable652_X"><i class="var">X</i></span>, <span id="Variable657_Y"><i class="var">Y</i></span>) --<span class="ent-name"><a href="../Abrupting/index.html#Name_abrupted">abrupted</a></span>( )-> <span class="name"><a href="#Name_handle-thrown">handle-thrown</a></span>(<a href="#Variable639_X'"><i class="var">X&prime;</i></a>, <a href="#Variable657_Y"><i class="var">Y</i></a>)
<i class="keyword">Rule</i>
<a href="#Variable755_X"><i class="var">X</i></a> --<span class="ent-name"><a href="../Abrupting/index.html#Name_abrupted">abrupted</a></span>(<span class="name"><a href="#Name_thrown">thrown</a></span>(<span id="Variable716_V''"><i class="var">V&prime;&prime;</i></span>:<span class="name"><a href="../../../Values/Value-Types/index.html#Name_values">values</a></span>))-> <span id="Variable742_X'"><i class="var">X&prime;</i></span>
----------------------------------------------
<span class="name"><a href="#Name_handle-thrown">handle-thrown</a></span>(<span id="Variable755_X"><i class="var">X</i></span>, <span id="Variable760_Y"><i class="var">Y</i></span>) --<span class="ent-name"><a href="../Abrupting/index.html#Name_abrupted">abrupted</a></span>( )-> <span class="name"><a href="../../Normal/Giving/index.html#Name_give">give</a></span>(<a href="#Variable716_V''"><i class="var">V&prime;&prime;</i></a>, <a href="#Variable760_Y"><i class="var">Y</i></a>)
<i class="keyword">Rule</i>
<a href="#Variable852_X"><i class="var">X</i></a> --<span class="ent-name"><a href="../Abrupting/index.html#Name_abrupted">abrupted</a></span>(<span id="Variable818_V'"><i class="var">V&prime;</i></span>:~<span class="name"><a href="#Name_throwing">throwing</a></span>)-> <span id="Variable839_X'"><i class="var">X&prime;</i></span>
---------------------------------------------------------
<span class="name"><a href="#Name_handle-thrown">handle-thrown</a></span>(<span id="Variable852_X"><i class="var">X</i></span>, <span id="Variable857_Y"><i class="var">Y</i></span>) --<span class="ent-name"><a href="../Abrupting/index.html#Name_abrupted">abrupted</a></span>(<a href="#Variable818_V'"><i class="var">V&prime;</i></a>)-> <span class="name"><a href="#Name_handle-thrown">handle-thrown</a></span>(<a href="#Variable839_X'"><i class="var">X&prime;</i></a>, <a href="#Variable857_Y"><i class="var">Y</i></a>)
<i class="keyword">Rule</i>
<span class="name"><a href="#Name_handle-thrown">handle-thrown</a></span>(<span id="Variable913_V"><i class="var">V</i></span>:<i class="var">T</i>, <span id="Variable924_Y"><i class="var">Y</i></span>) ~> <a href="#Variable913_V"><i class="var">V</i></a></code></pre></div>
<div class="highlighter-rouge"><pre class="highlight"><code><i class="keyword">Funcon</i>
<span class="name"><span id="Name_handle-recursively">handle-recursively</span></span>(<span id="Variable945_X"><i class="var">X</i></span>:<span id="Variable949_S"><i class="var">S</i></span>=><span id="Variable955_T"><i class="var">T</i></span>, <span id="Variable964_Y"><i class="var">Y</i></span>:<span id="Variable968_R"><i class="var">R</i></span>=><span id="Variable974_T"><i class="var">T</i></span>) : <span id="Variable989_S"><i class="var">S</i></span>=><span id="Variable995_T"><i class="var">T</i></span>
~> <span class="name"><a href="#Name_handle-thrown">handle-thrown</a></span>(<a href="#Variable945_X"><i class="var">X</i></a>, <span class="name"><a href="../Failing/index.html#Name_else">else</a></span>(<span class="name"><a href="#Name_handle-recursively">handle-recursively</a></span>(<a href="#Variable964_Y"><i class="var">Y</i></a>, <a href="#Variable964_Y"><i class="var">Y</i></a>), <span class="name"><a href="#Name_throw">throw</a></span>(<span class="name"><a href="../../Normal/Giving/index.html#Name_given">given</a></span>)))</code></pre></div>
<code><span class="name"><a href="#Name_handle-recursively">handle-recursively</a></span>(<i class="var">X</i>, <i class="var">Y</i>)</code> behaves similarly to <code><span class="name"><a href="#Name_handle-thrown">handle-thrown</a></span>(<i class="var">X</i>, <i class="var">Y</i>)</code>, except
that another copy of the handler attempts to handle any values thrown by <code><i class="var">Y</i></code>.
Thus, many thrown values may get handled by the same handler.
<div class="highlighter-rouge"><pre class="highlight"><code><i class="keyword">Funcon</i>
<span class="name"><span id="Name_catch-else-throw">catch-else-throw</span></span>(<span id="Variable1124_P"><i class="var">P</i></span>:<span class="name"><a href="../../../Values/Value-Types/index.html#Name_values">values</a></span>, <span id="Variable1133_Y"><i class="var">Y</i></span>:=><span id="Variable1138_T"><i class="var">T</i></span>) : =><span id="Variable1154_T"><i class="var">T</i></span>
~> <span class="name"><a href="../Failing/index.html#Name_else">else</a></span>(<span class="name"><a href="../../../Values/Abstraction/Patterns/index.html#Name_case-match">case-match</a></span>(<a href="#Variable1124_P"><i class="var">P</i></a>, <a href="#Variable1133_Y"><i class="var">Y</i></a>), <span class="name"><a href="#Name_throw">throw</a></span>(<span class="name"><a href="../../Normal/Giving/index.html#Name_given">given</a></span>))</code></pre></div>
<code><span class="name"><a href="#Name_handle-thrown">handle-thrown</a></span>(<i class="var">X</i>, <span class="name"><a href="#Name_catch-else-throw">catch-else-throw</a></span>(<i class="var">P</i>, <i class="var">Y</i>))</code> handles those values thrown by <code><i class="var">X</i></code>
that match pattern <code><i class="var">P</i></code>. Other thrown values are re-thrown.
____
From the [PLanCompS Project] | [CBS-beta issues...] | [Suggest an improvement...]
[Throwing.cbs]: Throwing.cbs
"CBS SOURCE FILE"
[Funcons-beta]: /CBS-beta/docs/Funcons-beta
"FUNCONS-BETA"
[Unstable-Funcons-beta]: /CBS-beta/docs/Unstable-Funcons-beta
"UNSTABLE-FUNCONS-BETA"
[Languages-beta]: /CBS-beta/docs/Languages-beta
"LANGUAGES-BETA"
[Unstable-Languages-beta]: /CBS-beta/docs/Unstable-Languages-beta
"UNSTABLE-LANGUAGES-BETA"
[CBS-beta]: /CBS-beta "CBS-BETA"
[PLanCompS Project]: https://plancomps.github.io
"PROGRAMMING LANGUAGE COMPONENTS AND SPECIFICATIONS PROJECT HOME PAGE"
[CBS-beta issues...]: https://github.com/plancomps/CBS-beta/issues
"CBS-BETA ISSUE REPORTS ON GITHUB"
[Suggest an improvement...]: mailto:plancomps@gmail.com?Subject=CBS-beta%20-%20comment&Body=Re%3A%20CBS-beta%20specification%20at%20Computations/Abnormal/Throwing/Throwing.cbs%0A%0AComment/Query/Issue/Suggestion%3A%0A%0A%0ASignature%3A%0A
"GENERATE AN EMAIL TEMPLATE"

19
IBAF-cbs/Funcons-beta/Computations/Abnormal/Throwing/tests/catch-else-throw.config Normal file
View File

@@ -0,0 +1,19 @@
general {
funcon-term:
initialise-binding
finalise-throwing
sequential(
handle-thrown(
throw 1,
catch-else-throw(1, print 1)),
handle-thrown(
handle-thrown(throw 2,
catch-else-throw(1, fail)),
catch-else-throw(2, print 2)))
;
}
tests {
result-term: null-value;
standard-out: [1, 2];
}

17
IBAF-cbs/Funcons-beta/Computations/Abnormal/Throwing/tests/handle-recursively.config Normal file
View File

@@ -0,0 +1,17 @@
general {
funcon-term:
finalise-throwing
handle-recursively(
throw 1,
if-true-else(
is-less(given,4),
sequential(print given, throw integer-add(1,given)),
print"OK")
)
;
}
tests {
result-term: null-value;
standard-out: [1, 2, 3, "OK"];
}

17
IBAF-cbs/Funcons-beta/Computations/Abnormal/Throwing/tests/handle-thrown.config Normal file
View File

@@ -0,0 +1,17 @@
general {
funcon-term:
finalise-throwing
sequential(
print handle-thrown(1, fail),
handle-thrown(print 2, fail),
handle-thrown(
sequential(print 3, throw(sequential(print 4, 5))),
print given)
)
;
}
tests {
result-term: null-value;
standard-out: [1, 2, 3, 4, 5];
}

13
IBAF-cbs/Funcons-beta/Computations/Computation-Types/Computation-Types.cbs Normal file
View File

@@ -0,0 +1,13 @@
## Computation Types
Built-in Funcon
computation-types : types
/*
For any value type `T`, the term `=>T` is the type of computations that
compute values of type `T` whenever they terminate normally.
For any subtypes `S`, `T` of `values`, `S=>T` is the type of computations
that compute values of type `T` whenever they terminate normally, and
either do not refer at all to the `given` entity, or require the `given`
entity to have type `S`.
*/

47
IBAF-cbs/Funcons-beta/Computations/Computation-Types/index.md Normal file
View File

@@ -0,0 +1,47 @@
---
layout: default
title: "Computation-Types"
parent: Computations
ancestor: Funcons-beta
---
[Funcons-beta] : [Computation-Types.cbs]
-----------------------------
## Computation Types
<div class="highlighter-rouge"><pre class="highlight"><code><i class="keyword">Built-in</i> <i class="keyword">Funcon</i>
<span class="name"><span id="Name_computation-types">computation-types</span></span> : <span class="name"><a href="../../Values/Value-Types/index.html#Name_types">types</a></span></code></pre></div>
For any value type <code><i class="var">T</i></code>, the term <code>=><i class="var">T</i></code> is the type of computations that
compute values of type <code><i class="var">T</i></code> whenever they terminate normally.
For any subtypes <code><i class="var">S</i></code>, <code><i class="var">T</i></code> of <code><span class="name"><a href="../../Values/Value-Types/index.html#Name_values">values</a></span></code>, <code><i class="var">S</i>=><i class="var">T</i></code> is the type of computations
that compute values of type <code><i class="var">T</i></code> whenever they terminate normally, and
either do not refer at all to the <code><span class="name"><a href="../Normal/Giving/index.html#Name_given">given</a></span></code> entity, or require the <code><span class="name"><a href="../Normal/Giving/index.html#Name_given">given</a></span></code>
entity to have type <code><i class="var">S</i></code>.
____
From the [PLanCompS Project] | [CBS-beta issues...] | [Suggest an improvement...]
[Computation-Types.cbs]: Computation-Types.cbs
"CBS SOURCE FILE"
[Funcons-beta]: /CBS-beta/docs/Funcons-beta
"FUNCONS-BETA"
[Unstable-Funcons-beta]: /CBS-beta/docs/Unstable-Funcons-beta
"UNSTABLE-FUNCONS-BETA"
[Languages-beta]: /CBS-beta/docs/Languages-beta
"LANGUAGES-BETA"
[Unstable-Languages-beta]: /CBS-beta/docs/Unstable-Languages-beta
"UNSTABLE-LANGUAGES-BETA"
[CBS-beta]: /CBS-beta "CBS-BETA"
[PLanCompS Project]: https://plancomps.github.io
"PROGRAMMING LANGUAGE COMPONENTS AND SPECIFICATIONS PROJECT HOME PAGE"
[CBS-beta issues...]: https://github.com/plancomps/CBS-beta/issues
"CBS-BETA ISSUE REPORTS ON GITHUB"
[Suggest an improvement...]: mailto:plancomps@gmail.com?Subject=CBS-beta%20-%20comment&Body=Re%3A%20CBS-beta%20specification%20at%20Computations/Computation-Types/Computation-Types.cbs%0A%0AComment/Query/Issue/Suggestion%3A%0A%0A%0ASignature%3A%0A
"GENERATE AN EMAIL TEMPLATE"

269
IBAF-cbs/Funcons-beta/Computations/Normal/Binding/Binding.cbs Normal file
View File

@@ -0,0 +1,269 @@
### Binding
[
Type environments Alias envs
Datatype identifiers Alias ids
Funcon identifier-tagged Alias id-tagged
Funcon fresh-identifier
Entity environment Alias env
Funcon initialise-binding
Funcon bind-value Alias bind
Funcon unbind
Funcon bound-directly
Funcon bound-value Alias bound
Funcon closed
Funcon scope
Funcon accumulate
Funcon collateral
Funcon bind-recursively
Funcon recursive
]
Meta-variables
T <: values
#### Environments
Type
environments ~> maps(identifiers, values?)
Alias
envs = environments
/*
An environment represents bindings of identifiers to values.
Mapping an identifier to `( )` represents that its binding is hidden.
Circularity in environments (due to recursive bindings) is represented using
bindings to cut-points called `links`. Funcons are provided for making
declarations recursive and for referring to bound values without explicit
mention of links, so their existence can generally be ignored.
*/
Datatype
identifiers ::= {_:strings} | identifier-tagged(_:identifiers, _:values)
Alias
ids = identifiers
Alias
id-tagged = identifier-tagged
/*
An identifier is either a string of characters, or an identifier tagged with
some value (e.g., with the identifier of a namespace).
*/
Funcon
fresh-identifier : =>identifiers
/*
`fresh-identifier` computes an identifier distinct from all previously
computed identifiers.
*/
Rule
fresh-identifier ~> identifier-tagged("generated", fresh-atom)
#### Current bindings
Entity
environment(_:environments) |- _ ---> _
Alias
env = environment
/*
The environment entity allows a computation to refer to the current bindings
of identifiers to values.
*/
Funcon
initialise-binding(X:=>T) : =>T
~> initialise-linking(initialise-generating(closed(X)))
/*
`initialise-binding(X)` ensures that `X` does not depend on non-local bindings.
It also ensures that the linking entity (used to represent potentially cyclic
bindings) and the generating entity (for creating fresh identifiers) are
initialised.
*/
Funcon
bind-value(I:identifiers, V:values) : =>environments
~> { I |-> V }
Alias
bind = bind-value
/*
`bind-value(I, X)` computes the environment that binds only `I` to the value
computed by `X`.
*/
Funcon
unbind(I:identifiers) : =>environments
~> { I |-> ( ) }
/*
`unbind(I)` computes the environment that hides the binding of `I`.
*/
Funcon
bound-directly(_:identifiers) : =>values
/*
`bound-directly(I)` returns the value to which `I` is currently bound, if any,
and otherwise fails.
`bound-directly(I)` does *not* follow links. It is used only in connection with
recursively-bound values when references are not encapsulated in abstractions.
*/
Rule
lookup(Rho, I) ~> (V:values)
--------------------------------------------------------
environment(Rho) |- bound-directly(I:identifiers) ---> V
Rule
lookup(Rho, I) ~> ( )
-----------------------------------------------------------
environment(Rho) |- bound-directly(I:identifiers) ---> fail
Funcon
bound-value(I:identifiers) : =>values
~> follow-if-link(bound-directly(I))
Alias
bound = bound-value
/*
`bound-value(I)` inspects the value to which `I` is currently bound, if any,
and otherwise fails. If the value is a link, `bound-value(I)` returns the
value obtained by following the link, if any, and otherwise fails. If the
inspected value is not a link, `bound-value(I)` returns it.
`bound-value(I)` is used for references to non-recursive bindings and to
recursively-bound values when references are encapsulated in abstractions.
*/
#### Scope
Funcon
closed(X:=>T) : =>T
/*
`closed(X)` ensures that `X` does not depend on non-local bindings.
*/
Rule
environment(map( )) |- X ---> X'
-------------------------------------------
environment(_) |- closed(X) ---> closed(X')
Rule
closed(V:T) ~> V
Funcon
scope(_:environments, _:=>T) : =>T
/*
`scope(D,X)` executes `D` with the current bindings, to compute an environment
`Rho` representing local bindings. It then executes `X` to compute the result,
with the current bindings extended by `Rho`, which may shadow or hide previous
bindings.
`closed(scope(Rho, X))` ensures that `X` can reference only the bindings
provided by `Rho`.
*/
Rule
environment(map-override(Rho1, Rho0)) |- X ---> X'
---------------------------------------------------------------------
environment(Rho0) |- scope(Rho1:environments, X) ---> scope(Rho1, X')
Rule
scope(_:environments, V:T) ~> V
Funcon
accumulate(_:(=>environments)*) : =>environments
/*
`accumulate(D1, D2)` executes `D1` with the current bindings, to compute an
environment `Rho1` representing some local bindings. It then executes `D2` to
compute an environment `Rho2` representing further local bindings, with the
current bindings extended by `Rho1`, which may shadow or hide previous
current bindings. The result is `Rho1` extended by `Rho2`, which may shadow
or hide the bindings of `Rho1`.
`accumulate(_, _)` is associative, with `map( )` as unit, and extends to any
number of arguments.
*/
Rule
D1 ---> D1'
-------------------------------------------
accumulate(D1, D2) ---> accumulate(D1', D2)
Rule
accumulate(Rho1:environments, D2) ~> scope(Rho1, map-override(D2, Rho1))
Rule
accumulate( ) ~> map( )
Rule
accumulate(D1) ~> D1
Rule
accumulate(D1, D2, D+) ~> accumulate(D1, accumulate(D2, D+))
Funcon
collateral(Rho*:environments*) : =>environments
~> checked map-unite(Rho*)
/*
`collateral(D1, ...)` pre-evaluates its arguments with the current bindings,
and unites the resulting maps, which fails if the domains are not pairwise
disjoint.
`collateral(D1, D2)` is associative and commutative with `map( )` as unit,
and extends to any number of arguments.
*/
#### Recurse
Funcon
bind-recursively(I:identifiers, E:=>values) : =>environments
~> recursive({I}, bind-value(I, E))
/*
`bind-recursively(I, E)` binds `I` to a link that refers to the value of `E`,
representing a recursive binding of `I` to the value of `E`.
Since `bound-value(I)` follows links, it should not be executed during the
evaluation of `E`.
*/
Funcon
recursive(SI:sets(identifiers), D:=>environments) : =>environments
~> re-close(bind-to-forward-links(SI), D)
/*
`recursive(SI, D)` executes `D` with potential recursion on the bindings of
the identifiers in the set `SI` (which need not be the same as the set of
identifiers bound by `D`).
*/
Auxiliary Funcon
re-close(M:maps(identifiers, links), D:=>environments) : =>environments
~> accumulate(scope(M, D), sequential(set-forward-links(M), map( )))
/*
`re-close(M, D)` first executes `D` in the scope `M`, which maps identifiers
to freshly allocated links. This computes an environment `Rho` where the bound
values may contain links, or implicit references to links in abstraction
values. It then sets the link for each identifier in the domain of `M` to
refer to its bound value in `Rho`, and returns `Rho` as the result.
*/
Auxiliary Funcon
bind-to-forward-links(SI:sets(identifiers)) : =>maps(identifiers, links)
~> map-unite(interleave-map(bind-value(given, fresh-link(values)),
set-elements(SI)))
/*
`bind-to-forward-links(SI)` binds each identifier in the set `SI` to a
freshly allocated link.
*/
Auxiliary Funcon
set-forward-links(M:maps(identifiers, links)) : =>null-type
~> effect(interleave-map(set-link(map-lookup(M, given), bound-value(given)),
set-elements(map-domain(M))))
/*
For each identifier `I` in the domain of `M`, `set-forward-links(M)` sets the
link to which `I` is mapped by `M` to the current bound value of `I`.
*/

320
IBAF-cbs/Funcons-beta/Computations/Normal/Binding/index.md Normal file
View File

@@ -0,0 +1,320 @@
---
layout: default
title: "Binding"
parent: Normal
ancestor: Funcons-beta
---
[Funcons-beta] : [Binding.cbs]
-----------------------------
### Binding
<div class="highlighter-rouge"><pre class="highlight"><code>[
<i class="keyword">Type</i> <span class="name"><a href="#Name_environments">environments</a></span> <i class="keyword">Alias</i> <span class="name"><a href="#Name_envs">envs</a></span>
<i class="keyword">Datatype</i> <span class="name"><a href="#Name_identifiers">identifiers</a></span> <i class="keyword">Alias</i> <span class="name"><a href="#Name_ids">ids</a></span>
<i class="keyword">Funcon</i> <span class="name"><a href="#Name_identifier-tagged">identifier-tagged</a></span> <i class="keyword">Alias</i> <span class="name"><a href="#Name_id-tagged">id-tagged</a></span>
<i class="keyword">Funcon</i> <span class="name"><a href="#Name_fresh-identifier">fresh-identifier</a></span>
<i class="keyword">Entity</i> <span class="name"><a href="#Name_environment">environment</a></span> <i class="keyword">Alias</i> <span class="name"><a href="#Name_env">env</a></span>
<i class="keyword">Funcon</i> <span class="name"><a href="#Name_initialise-binding">initialise-binding</a></span>
<i class="keyword">Funcon</i> <span class="name"><a href="#Name_bind-value">bind-value</a></span> <i class="keyword">Alias</i> <span class="name"><a href="#Name_bind">bind</a></span>
<i class="keyword">Funcon</i> <span class="name"><a href="#Name_unbind">unbind</a></span>
<i class="keyword">Funcon</i> <span class="name"><a href="#Name_bound-directly">bound-directly</a></span>
<i class="keyword">Funcon</i> <span class="name"><a href="#Name_bound-value">bound-value</a></span> <i class="keyword">Alias</i> <span class="name"><a href="#Name_bound">bound</a></span>
<i class="keyword">Funcon</i> <span class="name"><a href="#Name_closed">closed</a></span>
<i class="keyword">Funcon</i> <span class="name"><a href="#Name_scope">scope</a></span>
<i class="keyword">Funcon</i> <span class="name"><a href="#Name_accumulate">accumulate</a></span>
<i class="keyword">Funcon</i> <span class="name"><a href="#Name_collateral">collateral</a></span>
<i class="keyword">Funcon</i> <span class="name"><a href="#Name_bind-recursively">bind-recursively</a></span>
<i class="keyword">Funcon</i> <span class="name"><a href="#Name_recursive">recursive</a></span>
]</code></pre></div>
<div class="highlighter-rouge"><pre class="highlight"><code><i class="keyword">Meta-variables</i>
<span id="PartVariable_T"><i class="var">T</i></span> <: <span class="name"><a href="../../../Values/Value-Types/index.html#Name_values">values</a></span></code></pre></div>
#### Environments
<div class="highlighter-rouge"><pre class="highlight"><code><i class="keyword">Type</i>
<span class="name"><span id="Name_environments">environments</span></span> ~> <span class="name"><a href="../../../Values/Composite/Maps/index.html#Name_maps">maps</a></span>(<span class="name"><a href="#Name_identifiers">identifiers</a></span>, <span class="name"><a href="../../../Values/Value-Types/index.html#Name_values">values</a></span><sup class="sup">?</sup>)
<i class="keyword">Alias</i>
<span class="name"><span id="Name_envs">envs</span></span> = <span class="name"><a href="#Name_environments">environments</a></span></code></pre></div>
An environment represents bindings of identifiers to values.
Mapping an identifier to <code>( )</code> represents that its binding is hidden.
Circularity in environments (due to recursive bindings) is represented using
bindings to cut-points called <code><span class="name"><a href="../Linking/index.html#Name_links">links</a></span></code>. Funcons are provided for making
declarations recursive and for referring to bound values without explicit
mention of links, so their existence can generally be ignored.
<div class="highlighter-rouge"><pre class="highlight"><code><i class="keyword">Datatype</i>
<span class="name"><span id="Name_identifiers">identifiers</span></span> ::= {_:<span class="name"><a href="../../../Values/Composite/Strings/index.html#Name_strings">strings</a></span>} | <span id="Name_identifier-tagged">identifier-tagged</span>(_:<span class="name"><a href="#Name_identifiers">identifiers</a></span>, _:<span class="name"><a href="../../../Values/Value-Types/index.html#Name_values">values</a></span>)
<i class="keyword">Alias</i>
<span class="name"><span id="Name_ids">ids</span></span> = <span class="name"><a href="#Name_identifiers">identifiers</a></span></code></pre></div>
<div class="highlighter-rouge"><pre class="highlight"><code><i class="keyword">Alias</i>
<span class="name"><span id="Name_id-tagged">id-tagged</span></span> = <span class="name"><a href="#Name_identifier-tagged">identifier-tagged</a></span></code></pre></div>
An identifier is either a string of characters, or an identifier tagged with
some value (e.g., with the identifier of a namespace).
<div class="highlighter-rouge"><pre class="highlight"><code><i class="keyword">Funcon</i>
<span class="name"><span id="Name_fresh-identifier">fresh-identifier</span></span> : =><span class="name"><a href="#Name_identifiers">identifiers</a></span></code></pre></div>
<code><span class="name"><a href="#Name_fresh-identifier">fresh-identifier</a></span></code> computes an identifier distinct from all previously
computed identifiers.
<div class="highlighter-rouge"><pre class="highlight"><code><i class="keyword">Rule</i>
<span class="name"><a href="#Name_fresh-identifier">fresh-identifier</a></span> ~> <span class="name"><a href="#Name_identifier-tagged">identifier-tagged</a></span>("generated", <span class="name"><a href="../Generating/index.html#Name_fresh-atom">fresh-atom</a></span>)</code></pre></div>
#### Current bindings
<div class="highlighter-rouge"><pre class="highlight"><code><i class="keyword">Entity</i>
<span class="ent-name"><span id="Name_environment">environment</span></span>(_:<span class="name"><a href="#Name_environments">environments</a></span>) |- _ ---> _</code></pre></div>
<div class="highlighter-rouge"><pre class="highlight"><code><i class="keyword">Alias</i>
<span class="name"><span id="Name_env">env</span></span> = <span class="name"><a href="#Name_environment">environment</a></span></code></pre></div>
The environment entity allows a computation to refer to the current bindings
of identifiers to values.
<div class="highlighter-rouge"><pre class="highlight"><code><i class="keyword">Funcon</i>
<span class="name"><span id="Name_initialise-binding">initialise-binding</span></span>(<span id="Variable306_X"><i class="var">X</i></span>:=><span id="Variable311_T"><i class="var">T</i></span>) : =><span id="Variable326_T"><i class="var">T</i></span>
~> <span class="name"><a href="../Linking/index.html#Name_initialise-linking">initialise-linking</a></span>(<span class="name"><a href="../Generating/index.html#Name_initialise-generating">initialise-generating</a></span>(<span class="name"><a href="#Name_closed">closed</a></span>(<a href="#Variable306_X"><i class="var">X</i></a>)))</code></pre></div>
<code><span class="name"><a href="#Name_initialise-binding">initialise-binding</a></span>(<i class="var">X</i>)</code> ensures that <code><i class="var">X</i></code> does not depend on non-local bindings.
It also ensures that the linking entity (used to represent potentially cyclic
bindings) and the generating entity (for creating fresh identifiers) are
initialised.
<div class="highlighter-rouge"><pre class="highlight"><code><i class="keyword">Funcon</i>
<span class="name"><span id="Name_bind-value">bind-value</span></span>(<span id="Variable401_I"><i class="var">I</i></span>:<span class="name"><a href="#Name_identifiers">identifiers</a></span>, <span id="Variable410_V"><i class="var">V</i></span>:<span class="name"><a href="../../../Values/Value-Types/index.html#Name_values">values</a></span>) : =><span class="name"><a href="#Name_environments">environments</a></span>
~> { <a href="#Variable401_I"><i class="var">I</i></a> |-> <a href="#Variable410_V"><i class="var">V</i></a> }
<i class="keyword">Alias</i>
<span class="name"><span id="Name_bind">bind</span></span> = <span class="name"><a href="#Name_bind-value">bind-value</a></span></code></pre></div>
<code><span class="name"><a href="#Name_bind-value">bind-value</a></span>(<i class="var">I</i>, <i class="var">X</i>)</code> computes the environment that binds only <code><i class="var">I</i></code> to the value
computed by <code><i class="var">X</i></code>.
<div class="highlighter-rouge"><pre class="highlight"><code><i class="keyword">Funcon</i>
<span class="name"><span id="Name_unbind">unbind</span></span>(<span id="Variable509_I"><i class="var">I</i></span>:<span class="name"><a href="#Name_identifiers">identifiers</a></span>) : =><span class="name"><a href="#Name_environments">environments</a></span>
~> { <a href="#Variable509_I"><i class="var">I</i></a> |-> ( ) }</code></pre></div>
<code><span class="name"><a href="#Name_unbind">unbind</a></span>(<i class="var">I</i>)</code> computes the environment that hides the binding of <code><i class="var">I</i></code>.
<div class="highlighter-rouge"><pre class="highlight"><code><i class="keyword">Funcon</i>
<span class="name"><span id="Name_bound-directly">bound-directly</span></span>(_:<span class="name"><a href="#Name_identifiers">identifiers</a></span>) : =><span class="name"><a href="../../../Values/Value-Types/index.html#Name_values">values</a></span></code></pre></div>
<code><span class="name"><a href="#Name_bound-directly">bound-directly</a></span>(<i class="var">I</i>)</code> returns the value to which <code><i class="var">I</i></code> is currently bound, if any,
and otherwise fails.
<code><span class="name"><a href="#Name_bound-directly">bound-directly</a></span>(<i class="var">I</i>)</code> does *not* follow links. It is used only in connection with
recursively-bound values when references are not encapsulated in abstractions.
<div class="highlighter-rouge"><pre class="highlight"><code><i class="keyword">Rule</i>
<span class="name"><a href="../../../Values/Composite/Maps/index.html#Name_lookup">lookup</a></span>(<a href="#Variable711_Rho"><i class="var">Rho</i></a>, <a href="#Variable728_I"><i class="var">I</i></a>) ~> (<span id="Variable692_V"><i class="var">V</i></span>:<span class="name"><a href="../../../Values/Value-Types/index.html#Name_values">values</a></span>)
--------------------------------------------------------
<span class="ent-name"><a href="#Name_environment">environment</a></span>(<span id="Variable711_Rho"><i class="var">Rho</i></span>) |- <span class="name"><a href="#Name_bound-directly">bound-directly</a></span>(<span id="Variable728_I"><i class="var">I</i></span>:<span class="name"><a href="#Name_identifiers">identifiers</a></span>) ---> <a href="#Variable692_V"><i class="var">V</i></a>
<i class="keyword">Rule</i>
<span class="name"><a href="../../../Values/Composite/Maps/index.html#Name_lookup">lookup</a></span>(<a href="#Variable782_Rho"><i class="var">Rho</i></a>, <a href="#Variable799_I"><i class="var">I</i></a>) ~> ( )
-----------------------------------------------------------
<span class="ent-name"><a href="#Name_environment">environment</a></span>(<span id="Variable782_Rho"><i class="var">Rho</i></span>) |- <span class="name"><a href="#Name_bound-directly">bound-directly</a></span>(<span id="Variable799_I"><i class="var">I</i></span>:<span class="name"><a href="#Name_identifiers">identifiers</a></span>) ---> <span class="name"><a href="../../Abnormal/Failing/index.html#Name_fail">fail</a></span></code></pre></div>
<div class="highlighter-rouge"><pre class="highlight"><code><i class="keyword">Funcon</i>
<span class="name"><span id="Name_bound-value">bound-value</span></span>(<span id="Variable823_I"><i class="var">I</i></span>:<span class="name"><a href="#Name_identifiers">identifiers</a></span>) : =><span class="name"><a href="../../../Values/Value-Types/index.html#Name_values">values</a></span>
~> <span class="name"><a href="../Linking/index.html#Name_follow-if-link">follow-if-link</a></span>(<span class="name"><a href="#Name_bound-directly">bound-directly</a></span>(<a href="#Variable823_I"><i class="var">I</i></a>))
<i class="keyword">Alias</i>
<span class="name"><span id="Name_bound">bound</span></span> = <span class="name"><a href="#Name_bound-value">bound-value</a></span></code></pre></div>
<code><span class="name"><a href="#Name_bound-value">bound-value</a></span>(<i class="var">I</i>)</code> inspects the value to which <code><i class="var">I</i></code> is currently bound, if any,
and otherwise fails. If the value is a link, <code><span class="name"><a href="#Name_bound-value">bound-value</a></span>(<i class="var">I</i>)</code> returns the
value obtained by following the link, if any, and otherwise fails. If the
inspected value is not a link, <code><span class="name"><a href="#Name_bound-value">bound-value</a></span>(<i class="var">I</i>)</code> returns it.
<code><span class="name"><a href="#Name_bound-value">bound-value</a></span>(<i class="var">I</i>)</code> is used for references to non-recursive bindings and to
recursively-bound values when references are encapsulated in abstractions.
#### Scope
<div class="highlighter-rouge"><pre class="highlight"><code><i class="keyword">Funcon</i>
<span class="name"><span id="Name_closed">closed</span></span>(<span id="Variable991_X"><i class="var">X</i></span>:=><span id="Variable996_T"><i class="var">T</i></span>) : =><span id="Variable1011_T"><i class="var">T</i></span></code></pre></div>
<code><span class="name"><a href="#Name_closed">closed</a></span>(<i class="var">X</i>)</code> ensures that <code><i class="var">X</i></code> does not depend on non-local bindings.
<div class="highlighter-rouge"><pre class="highlight"><code><i class="keyword">Rule</i>
<span class="ent-name"><a href="#Name_environment">environment</a></span>(<span class="name"><a href="../../../Values/Composite/Maps/index.html#Name_map">map</a></span>( )) |- <a href="#Variable1113_X"><i class="var">X</i></a> ---> <span id="Variable1085_X'"><i class="var">X&prime;</i></span>
-------------------------------------------
<span class="ent-name"><a href="#Name_environment">environment</a></span>(_) |- <span class="name"><a href="#Name_closed">closed</a></span>(<span id="Variable1113_X"><i class="var">X</i></span>) ---> <span class="name"><a href="#Name_closed">closed</a></span>(<a href="#Variable1085_X'"><i class="var">X&prime;</i></a>)
<i class="keyword">Rule</i>
<span class="name"><a href="#Name_closed">closed</a></span>(<span id="Variable1145_V"><i class="var">V</i></span>:<i class="var">T</i>) ~> <a href="#Variable1145_V"><i class="var">V</i></a></code></pre></div>
<div class="highlighter-rouge"><pre class="highlight"><code><i class="keyword">Funcon</i>
<span class="name"><span id="Name_scope">scope</span></span>(_:<span class="name"><a href="#Name_environments">environments</a></span>, _:=><span id="Variable1183_T"><i class="var">T</i></span>) : =><span id="Variable1199_T"><i class="var">T</i></span></code></pre></div>
<code><span class="name"><a href="#Name_scope">scope</a></span>(<i class="var">D</i>,<i class="var">X</i>)</code> executes <code><i class="var">D</i></code> with the current bindings, to compute an environment
<code><i class="var">Rho</i></code> representing local bindings. It then executes <code><i class="var">X</i></code> to compute the result,
with the current bindings extended by <code><i class="var">Rho</i></code>, which may shadow or hide previous
bindings.
<code><span class="name"><a href="#Name_closed">closed</a></span>(<span class="name"><a href="#Name_scope">scope</a></span>(<i class="var">Rho</i>, <i class="var">X</i>))</code> ensures that <code><i class="var">X</i></code> can reference only the bindings
provided by <code><i class="var">Rho</i></code>.
<div class="highlighter-rouge"><pre class="highlight"><code><i class="keyword">Rule</i>
<span class="ent-name"><a href="#Name_environment">environment</a></span>(<span class="name"><a href="../../../Values/Composite/Maps/index.html#Name_map-override">map-override</a></span>(<a href="#Variable1422_Rho1"><i class="var">Rho<sub class="sub">1</sub></i></a>, <a href="#Variable1404_Rho0"><i class="var">Rho<sub class="sub">0</sub></i></a>)) |- <a href="#Variable1430_X"><i class="var">X</i></a> ---> <span id="Variable1391_X'"><i class="var">X&prime;</i></span>
---------------------------------------------------------------------
<span class="ent-name"><a href="#Name_environment">environment</a></span>(<span id="Variable1404_Rho0"><i class="var">Rho<sub class="sub">0</sub></i></span>) |- <span class="name"><a href="#Name_scope">scope</a></span>(<span id="Variable1422_Rho1"><i class="var">Rho<sub class="sub">1</sub></i></span>:<span class="name"><a href="#Name_environments">environments</a></span>, <span id="Variable1430_X"><i class="var">X</i></span>) ---> <span class="name"><a href="#Name_scope">scope</a></span>(<a href="#Variable1422_Rho1"><i class="var">Rho<sub class="sub">1</sub></i></a>, <a href="#Variable1391_X'"><i class="var">X&prime;</i></a>)
<i class="keyword">Rule</i>
<span class="name"><a href="#Name_scope">scope</a></span>(_:<span class="name"><a href="#Name_environments">environments</a></span>, <span id="Variable1477_V"><i class="var">V</i></span>:<i class="var">T</i>) ~> <a href="#Variable1477_V"><i class="var">V</i></a></code></pre></div>
<div class="highlighter-rouge"><pre class="highlight"><code><i class="keyword">Funcon</i>
<span class="name"><span id="Name_accumulate">accumulate</span></span>(_:(=><span class="name"><a href="#Name_environments">environments</a></span>)<sup class="sup">*</sup>) : =><span class="name"><a href="#Name_environments">environments</a></span></code></pre></div>
<code><span class="name"><a href="#Name_accumulate">accumulate</a></span>(<i class="var">D<sub class="sub">1</sub></i>, <i class="var">D<sub class="sub">2</sub></i>)</code> executes <code><i class="var">D<sub class="sub">1</sub></i></code> with the current bindings, to compute an
environment <code><i class="var">Rho<sub class="sub">1</sub></i></code> representing some local bindings. It then executes <code><i class="var">D<sub class="sub">2</sub></i></code> to
compute an environment <code><i class="var">Rho<sub class="sub">2</sub></i></code> representing further local bindings, with the
current bindings extended by <code><i class="var">Rho<sub class="sub">1</sub></i></code>, which may shadow or hide previous
current bindings. The result is <code><i class="var">Rho<sub class="sub">1</sub></i></code> extended by <code><i class="var">Rho<sub class="sub">2</sub></i></code>, which may shadow
or hide the bindings of <code><i class="var">Rho<sub class="sub">1</sub></i></code>.
<code><span class="name"><a href="#Name_accumulate">accumulate</a></span>(_, _)</code> is associative, with <code><span class="name"><a href="../../../Values/Composite/Maps/index.html#Name_map">map</a></span>( )</code> as unit, and extends to any
number of arguments.
<div class="highlighter-rouge"><pre class="highlight"><code><i class="keyword">Rule</i>
<a href="#Variable1741_D1"><i class="var">D<sub class="sub">1</sub></i></a> ---> <span id="Variable1727_D1'"><i class="var">D<sub class="sub">1</sub>&prime;</i></span>
-------------------------------------------
<span class="name"><a href="#Name_accumulate">accumulate</a></span>(<span id="Variable1741_D1"><i class="var">D<sub class="sub">1</sub></i></span>, <span id="Variable1747_D2"><i class="var">D<sub class="sub">2</sub></i></span>) ---> <span class="name"><a href="#Name_accumulate">accumulate</a></span>(<a href="#Variable1727_D1'"><i class="var">D<sub class="sub">1</sub>&prime;</i></a>, <a href="#Variable1747_D2"><i class="var">D<sub class="sub">2</sub></i></a>)
<i class="keyword">Rule</i>
<span class="name"><a href="#Name_accumulate">accumulate</a></span>(<span id="Variable1788_Rho1"><i class="var">Rho<sub class="sub">1</sub></i></span>:<span class="name"><a href="#Name_environments">environments</a></span>, <span id="Variable1797_D2"><i class="var">D<sub class="sub">2</sub></i></span>) ~> <span class="name"><a href="#Name_scope">scope</a></span>(<a href="#Variable1788_Rho1"><i class="var">Rho<sub class="sub">1</sub></i></a>, <span class="name"><a href="../../../Values/Composite/Maps/index.html#Name_map-override">map-override</a></span>(<a href="#Variable1797_D2"><i class="var">D<sub class="sub">2</sub></i></a>, <a href="#Variable1788_Rho1"><i class="var">Rho<sub class="sub">1</sub></i></a>))
<i class="keyword">Rule</i>
<span class="name"><a href="#Name_accumulate">accumulate</a></span>( ) ~> <span class="name"><a href="../../../Values/Composite/Maps/index.html#Name_map">map</a></span>( )
<i class="keyword">Rule</i>
<span class="name"><a href="#Name_accumulate">accumulate</a></span>(<span id="Variable1863_D1"><i class="var">D<sub class="sub">1</sub></i></span>) ~> <a href="#Variable1863_D1"><i class="var">D<sub class="sub">1</sub></i></a>
<i class="keyword">Rule</i>
<span class="name"><a href="#Name_accumulate">accumulate</a></span>(<span id="Variable1885_D1"><i class="var">D<sub class="sub">1</sub></i></span>, <span id="Variable1891_D2"><i class="var">D<sub class="sub">2</sub></i></span>, <span id="Variable1897_D+"><i class="var">D<sup class="sup">+</sup></i></span>) ~> <span class="name"><a href="#Name_accumulate">accumulate</a></span>(<a href="#Variable1885_D1"><i class="var">D<sub class="sub">1</sub></i></a>, <span class="name"><a href="#Name_accumulate">accumulate</a></span>(<a href="#Variable1891_D2"><i class="var">D<sub class="sub">2</sub></i></a>, <a href="#Variable1897_D+"><i class="var">D<sup class="sup">+</sup></i></a>))</code></pre></div>
<div class="highlighter-rouge"><pre class="highlight"><code><i class="keyword">Funcon</i>
<span class="name"><span id="Name_collateral">collateral</span></span>(<span id="Variable1949_Rho*"><i class="var">Rho<sup class="sup">*</sup></i></span>:<span class="name"><a href="#Name_environments">environments</a></span><sup class="sup">*</sup>) : =><span class="name"><a href="#Name_environments">environments</a></span>
~> <span class="name"><a href="../../Abnormal/Failing/index.html#Name_checked">checked</a></span> <span class="name"><a href="../../../Values/Composite/Maps/index.html#Name_map-unite">map-unite</a></span>(<a href="#Variable1949_Rho*"><i class="var">Rho<sup class="sup">*</sup></i></a>)</code></pre></div>
<code><span class="name"><a href="#Name_collateral">collateral</a></span>(<i class="var">D<sub class="sub">1</sub></i>, ...)</code> pre-evaluates its arguments with the current bindings,
and unites the resulting maps, which fails if the domains are not pairwise
disjoint.
<code><span class="name"><a href="#Name_collateral">collateral</a></span>(<i class="var">D<sub class="sub">1</sub></i>, <i class="var">D<sub class="sub">2</sub></i>)</code> is associative and commutative with <code><span class="name"><a href="../../../Values/Composite/Maps/index.html#Name_map">map</a></span>( )</code> as unit,
and extends to any number of arguments.
#### Recurse
<div class="highlighter-rouge"><pre class="highlight"><code><i class="keyword">Funcon</i>
<span class="name"><span id="Name_bind-recursively">bind-recursively</span></span>(<span id="Variable2086_I"><i class="var">I</i></span>:<span class="name"><a href="#Name_identifiers">identifiers</a></span>, <span id="Variable2095_E"><i class="var">E</i></span>:=><span class="name"><a href="../../../Values/Value-Types/index.html#Name_values">values</a></span>) : =><span class="name"><a href="#Name_environments">environments</a></span>
~> <span class="name"><a href="#Name_recursive">recursive</a></span>({<a href="#Variable2086_I"><i class="var">I</i></a>}, <span class="name"><a href="#Name_bind-value">bind-value</a></span>(<a href="#Variable2086_I"><i class="var">I</i></a>, <a href="#Variable2095_E"><i class="var">E</i></a>))</code></pre></div>
<code><span class="name"><a href="#Name_bind-recursively">bind-recursively</a></span>(<i class="var">I</i>, <i class="var">E</i>)</code> binds <code><i class="var">I</i></code> to a link that refers to the value of <code><i class="var">E</i></code>,
representing a recursive binding of <code><i class="var">I</i></code> to the value of <code><i class="var">E</i></code>.
Since <code><span class="name"><a href="#Name_bound-value">bound-value</a></span>(<i class="var">I</i>)</code> follows links, it should not be executed during the
evaluation of <code><i class="var">E</i></code>.
<div class="highlighter-rouge"><pre class="highlight"><code><i class="keyword">Funcon</i>
<span class="name"><span id="Name_recursive">recursive</span></span>(<span id="Variable2273_SI"><i class="var">SI</i></span>:<span class="name"><a href="../../../Values/Composite/Sets/index.html#Name_sets">sets</a></span>(<span class="name"><a href="#Name_identifiers">identifiers</a></span>), <span id="Variable2289_D"><i class="var">D</i></span>:=><span class="name"><a href="#Name_environments">environments</a></span>) : =><span class="name"><a href="#Name_environments">environments</a></span>
~> <span class="name"><a href="#Name_re-close">re-close</a></span>(<span class="name"><a href="#Name_bind-to-forward-links">bind-to-forward-links</a></span>(<a href="#Variable2273_SI"><i class="var">SI</i></a>), <a href="#Variable2289_D"><i class="var">D</i></a>)</code></pre></div>
<code><span class="name"><a href="#Name_recursive">recursive</a></span>(<i class="var">SI</i>, <i class="var">D</i>)</code> executes <code><i class="var">D</i></code> with potential recursion on the bindings of
the identifiers in the set <code><i class="var">SI</i></code> (which need not be the same as the set of
identifiers bound by <code><i class="var">D</i></code>).
<div class="highlighter-rouge"><pre class="highlight"><code><i class="keyword">Auxiliary</i> <i class="keyword">Funcon</i>
<span class="name"><span id="Name_re-close">re-close</span></span>(<span id="Variable2410_M"><i class="var">M</i></span>:<span class="name"><a href="../../../Values/Composite/Maps/index.html#Name_maps">maps</a></span>(<span class="name"><a href="#Name_identifiers">identifiers</a></span>, <span class="name"><a href="../Linking/index.html#Name_links">links</a></span>), <span id="Variable2429_D"><i class="var">D</i></span>:=><span class="name"><a href="#Name_environments">environments</a></span>) : =><span class="name"><a href="#Name_environments">environments</a></span>
~> <span class="name"><a href="#Name_accumulate">accumulate</a></span>(<span class="name"><a href="#Name_scope">scope</a></span>(<a href="#Variable2410_M"><i class="var">M</i></a>, <a href="#Variable2429_D"><i class="var">D</i></a>), <span class="name"><a href="../Flowing/index.html#Name_sequential">sequential</a></span>(<span class="name"><a href="#Name_set-forward-links">set-forward-links</a></span>(<a href="#Variable2410_M"><i class="var">M</i></a>), <span class="name"><a href="../../../Values/Composite/Maps/index.html#Name_map">map</a></span>( )))</code></pre></div>
<code><span class="name"><a href="#Name_re-close">re-close</a></span>(<i class="var">M</i>, <i class="var">D</i>)</code> first executes <code><i class="var">D</i></code> in the scope <code><i class="var">M</i></code>, which maps identifiers
to freshly allocated links. This computes an environment <code><i class="var">Rho</i></code> where the bound
values may contain links, or implicit references to links in abstraction
values. It then sets the link for each identifier in the domain of <code><i class="var">M</i></code> to
refer to its bound value in <code><i class="var">Rho</i></code>, and returns <code><i class="var">Rho</i></code> as the result.
<div class="highlighter-rouge"><pre class="highlight"><code><i class="keyword">Auxiliary</i> <i class="keyword">Funcon</i>
<span class="name"><span id="Name_bind-to-forward-links">bind-to-forward-links</span></span>(<span id="Variable2617_SI"><i class="var">SI</i></span>:<span class="name"><a href="../../../Values/Composite/Sets/index.html#Name_sets">sets</a></span>(<span class="name"><a href="#Name_identifiers">identifiers</a></span>)) : =><span class="name"><a href="../../../Values/Composite/Maps/index.html#Name_maps">maps</a></span>(<span class="name"><a href="#Name_identifiers">identifiers</a></span>, <span class="name"><a href="../Linking/index.html#Name_links">links</a></span>)
~> <span class="name"><a href="../../../Values/Composite/Maps/index.html#Name_map-unite">map-unite</a></span>(<span class="name"><a href="../Giving/index.html#Name_interleave-map">interleave-map</a></span>(<span class="name"><a href="#Name_bind-value">bind-value</a></span>(<span class="name"><a href="../Giving/index.html#Name_given">given</a></span>, <span class="name"><a href="../Linking/index.html#Name_fresh-link">fresh-link</a></span>(<span class="name"><a href="../../../Values/Value-Types/index.html#Name_values">values</a></span>)),
<span class="name"><a href="../../../Values/Composite/Sets/index.html#Name_set-elements">set-elements</a></span>(<a href="#Variable2617_SI"><i class="var">SI</i></a>)))</code></pre></div>
<code><span class="name"><a href="#Name_bind-to-forward-links">bind-to-forward-links</a></span>(<i class="var">SI</i>)</code> binds each identifier in the set <code><i class="var">SI</i></code> to a
freshly allocated link.
<div class="highlighter-rouge"><pre class="highlight"><code><i class="keyword">Auxiliary</i> <i class="keyword">Funcon</i>
<span class="name"><span id="Name_set-forward-links">set-forward-links</span></span>(<span id="Variable2742_M"><i class="var">M</i></span>:<span class="name"><a href="../../../Values/Composite/Maps/index.html#Name_maps">maps</a></span>(<span class="name"><a href="#Name_identifiers">identifiers</a></span>, <span class="name"><a href="../Linking/index.html#Name_links">links</a></span>)) : =><span class="name"><a href="../../../Values/Primitive/Null/index.html#Name_null-type">null-type</a></span>
~> <span class="name"><a href="../Flowing/index.html#Name_effect">effect</a></span>(<span class="name"><a href="../Giving/index.html#Name_interleave-map">interleave-map</a></span>(<span class="name"><a href="../Linking/index.html#Name_set-link">set-link</a></span>(<span class="name"><a href="../../../Values/Composite/Maps/index.html#Name_map-lookup">map-lookup</a></span>(<a href="#Variable2742_M"><i class="var">M</i></a>, <span class="name"><a href="../Giving/index.html#Name_given">given</a></span>), <span class="name"><a href="#Name_bound-value">bound-value</a></span>(<span class="name"><a href="../Giving/index.html#Name_given">given</a></span>)),
<span class="name"><a href="../../../Values/Composite/Sets/index.html#Name_set-elements">set-elements</a></span>(<span class="name"><a href="../../../Values/Composite/Maps/index.html#Name_map-domain">map-domain</a></span>(<a href="#Variable2742_M"><i class="var">M</i></a>))))</code></pre></div>
For each identifier <code><i class="var">I</i></code> in the domain of <code><i class="var">M</i></code>, <code><span class="name"><a href="#Name_set-forward-links">set-forward-links</a></span>(<i class="var">M</i>)</code> sets the
link to which <code><i class="var">I</i></code> is mapped by <code><i class="var">M</i></code> to the current bound value of <code><i class="var">I</i></code>.
____
From the [PLanCompS Project] | [CBS-beta issues...] | [Suggest an improvement...]
[Binding.cbs]: Binding.cbs
"CBS SOURCE FILE"
[Funcons-beta]: /CBS-beta/docs/Funcons-beta
"FUNCONS-BETA"
[Unstable-Funcons-beta]: /CBS-beta/docs/Unstable-Funcons-beta
"UNSTABLE-FUNCONS-BETA"
[Languages-beta]: /CBS-beta/docs/Languages-beta
"LANGUAGES-BETA"
[Unstable-Languages-beta]: /CBS-beta/docs/Unstable-Languages-beta
"UNSTABLE-LANGUAGES-BETA"
[CBS-beta]: /CBS-beta "CBS-BETA"
[PLanCompS Project]: https://plancomps.github.io
"PROGRAMMING LANGUAGE COMPONENTS AND SPECIFICATIONS PROJECT HOME PAGE"
[CBS-beta issues...]: https://github.com/plancomps/CBS-beta/issues
"CBS-BETA ISSUE REPORTS ON GITHUB"
[Suggest an improvement...]: mailto:plancomps@gmail.com?Subject=CBS-beta%20-%20comment&Body=Re%3A%20CBS-beta%20specification%20at%20Computations/Normal/Binding/Binding.cbs%0A%0AComment/Query/Issue/Suggestion%3A%0A%0A%0ASignature%3A%0A
"GENERATE AN EMAIL TEMPLATE"

27
IBAF-cbs/Funcons-beta/Computations/Normal/Binding/tests/accumulate.config Normal file
View File

@@ -0,0 +1,27 @@
general {
funcon-term:
initialise-binding
tuple(
accumulate( ),
accumulate(bind-value("x", true)),
accumulate(bind-value("x", true),
bind-value("y", bound-directly"x")),
accumulate(bind-value("x", true),
bind-value("y", bound-directly"x"),
bind-value("z", bound-directly"x")),
accumulate(bind-value("x", true),
bind-value("y", true),
bind-value("x", bound-directly"x")))
;
}
tests {
result-term:
tuple(
map( ),
{"x"|->true},
{"x"|->true, "y"|->true},
{"x"|->true, "y"|->true, "z"|->true},
{"y"|->true, "x"|->true})
;
}

16
IBAF-cbs/Funcons-beta/Computations/Normal/Binding/tests/bind-recursively.config Normal file
View File

@@ -0,0 +1,16 @@
general {
funcon-term:
initialise-binding
scope(
bind-recursively("x",
thunk closure
is-value bound-value"x"),
force bound-value"x")
;
}
tests {
result-term:
true
;
}

9
IBAF-cbs/Funcons-beta/Computations/Normal/Binding/tests/bind-value.config Normal file
View File

@@ -0,0 +1,9 @@
general {
funcon-term:
bind-value("x", 1)
;
}
tests {
result-term: {"x"|->1};
}

15
IBAF-cbs/Funcons-beta/Computations/Normal/Binding/tests/bound-directly.config Normal file
View File

@@ -0,0 +1,15 @@
general {
funcon-term:
initialise-binding
scope(
{"x"|->true, "y"|->fresh-link(booleans)},
and(
bound-directly"x",
is-in-type(bound-directly"y", links),
else(bound-directly"z", true)))
;
}
tests {
result-term: true;
}

15
IBAF-cbs/Funcons-beta/Computations/Normal/Binding/tests/bound-value.config Normal file
View File

@@ -0,0 +1,15 @@
general {
funcon-term:
initialise-binding
scope(
{"x"|->true, "y"|->fresh-initialised-link(booleans,true)},
and(
bound-value"x",
bound-value"y",
else(bound-value"z",true)))
;
}
tests {
result-term: true;
}

11
IBAF-cbs/Funcons-beta/Computations/Normal/Binding/tests/closed.config Normal file
View File

@@ -0,0 +1,11 @@
general {
funcon-term:
initialise-binding
scope({"x"|->1},
closed(else(bound-directly"x", true)))
;
}
tests {
result-term: true;
}

27
IBAF-cbs/Funcons-beta/Computations/Normal/Binding/tests/collateral.config Normal file
View File

@@ -0,0 +1,27 @@
general {
funcon-term:
initialise-binding tuple(
collateral( ),
collateral(bind-value("x", true)),
collateral(bind-value("x", true),
bind-value("y", false)),
collateral(bind-value("x", true),
bind-value("y", false),
unbind"z"),
scope(bind-value("x",true),
collateral(bind-value("x", false),
bind-value("y", true),
bind-value("z", bound-directly"x"))))
;
}
tests {
result-term:
tuple(
map( ),
{"x"|->true},
{"x"|->true, "y"|->false},
{"x"|->true, "y"|->false, "z"|->( )},
{"x"|->false,"y"|->true, "z"|->true})
;
}

12
IBAF-cbs/Funcons-beta/Computations/Normal/Binding/tests/environments.config Normal file
View File

@@ -0,0 +1,12 @@
general {
funcon-term:
and(
is-in-type(map(),environments),
is-in-type({"x"|->true},environments),
is-in-type({"x"|->true, "y"|->false},environments))
;
}
tests {
result-term: true;
}

10
IBAF-cbs/Funcons-beta/Computations/Normal/Binding/tests/fresh-identifier.config Normal file
View File

@@ -0,0 +1,10 @@
general {
funcon-term:
initialise-generating
not is-equal(fresh-identifier, fresh-identifier)
;
}
tests {
result-term: true;
}

14
IBAF-cbs/Funcons-beta/Computations/Normal/Binding/tests/identifiers.config Normal file
View File

@@ -0,0 +1,14 @@
general {
funcon-term:
and(
is-in-type("x", identifiers),
is-in-type(identifier-tagged("x",false), identifiers),
is-in-type(identifier-tagged(identifier-tagged("x",true),false), identifiers),
is-in-type(identifier-tagged("x",identifier-tagged("x",true)), identifiers)
)
;
}
tests {
result-term: true;
}

10
IBAF-cbs/Funcons-beta/Computations/Normal/Binding/tests/initialise-binding.config Normal file
View File

@@ -0,0 +1,10 @@
general {
funcon-term:
initialise-binding(print"OK")
;
}
tests {
result-term: null-value;
standard-out: ["OK"];
}

17
IBAF-cbs/Funcons-beta/Computations/Normal/Binding/tests/recursive.config Normal file
View File

@@ -0,0 +1,17 @@
general {
funcon-term:
initialise-binding
scope(
recursive(
{"x"},
bind-value("x", thunk closure
if-true-else(not is-equal(null-value, bound-value"x"), true, false))),
force bound-value"x")
;
}
tests {
result-term:
true
;
}

15
IBAF-cbs/Funcons-beta/Computations/Normal/Binding/tests/scope.config Normal file
View File

@@ -0,0 +1,15 @@
general {
funcon-term:
initialise-binding
and(
scope(bind-value("x", false),
scope(bind-value("x", true),
bound-directly"x")),
scope(bind-value("x", false),
true))
;
}
tests {
result-term: true;
}

9
IBAF-cbs/Funcons-beta/Computations/Normal/Binding/tests/unbind.config Normal file
View File

@@ -0,0 +1,9 @@
general {
funcon-term:
unbind("x")
;
}
tests {
result-term: {"x"|->( )};
}

242
IBAF-cbs/Funcons-beta/Computations/Normal/Flowing/Flowing.cbs Normal file
View File

@@ -0,0 +1,242 @@
### Flowing
[
Funcon left-to-right Alias l-to-r
Funcon right-to-left Alias r-to-l
Funcon sequential Alias seq
Funcon effect
Funcon choice
Funcon if-true-else Alias if-else
Funcon while-true Alias while
Funcon do-while-true Alias do-while
Funcon interleave
Datatype yielding
Funcon signal
Funcon yielded
Funcon yield
Funcon yield-on-value
Funcon yield-on-abrupt
Funcon atomic
]
Meta-variables
T <: values
T* <: values*
#### Sequencing
Funcon
left-to-right(_:(=>(T)*)*) : =>(T)*
Alias
l-to-r = left-to-right
/*
`left-to-right(...)` computes its arguments sequentially, from left to right,
and gives the resulting sequence of values, provided all terminate normally.
For example, `integer-add(X, Y)` may interleave the computations of `X` and
`Y`, whereas `integer-add left-to-right(X, Y)` always computes `X` before `Y`.
When each argument of `left-to-right(...)` computes a single value, the type
of the result is the same as that of the argument sequence. For instance,
when `X:T` and `Y:T'`, the result of `left-to-right(X, Y)` is of type `(T, T')`.
The only effect of wrapping an argument sequence in `left-to-right(...)` is to
ensure that when the arguments are to be evaluated, it is done in the
specified order.
*/
Rule
Y ---> Y'
------------------------------------------------------------
left-to-right(V*:(T)*, Y, Z*) ---> left-to-right(V*, Y', Z*)
Rule
left-to-right(V*:(T)*) ~> V*
Funcon
right-to-left(_:(=>(T)*)*) : =>(T)*
Alias
r-to-l = right-to-left
/*
`right-to-left(...)` computes its arguments sequentially, from right to left,
and gives the resulting sequence of values, provided all terminate normally.
Note that `right-to-left(X*)` and `reverse left-to-right reverse(X*)` are
not equivalent: `reverse(X*)` interleaves the evaluation of `X*`.
*/
Rule
Y ---> Y'
------------------------------------------------------------
right-to-left(X*, Y, V*:(T)*) ---> right-to-left(X*, Y', V*)
Rule
right-to-left(V*:(T)*) ~> V*
Funcon
sequential(_:(=>null-type)*, _:=>T) : =>T
Alias
seq = sequential
/*
`sequential(X, ...)` computes its arguments in the given order. On normal
termination, it returns the value of the last argument; the other arguments
all compute `null-value`.
Binary `sequential(X, Y)` is associative, with unit `null-value`.
*/
Rule
X ---> X'
-----------------------------------------
sequential(X, Y+) ---> sequential(X', Y+)
Rule
sequential(null-value, Y+) ~> sequential(Y+)
Rule
sequential(Y) ~> Y
Funcon
effect(V*:T*) : =>null-type
~> null-value
/*
`effect(...)` interleaves the computations of its arguments, then discards
all the computed values.
*/
#### Choosing
Funcon
choice(_:(=>T)+) : =>T
/*
`choice(Y, ...)` selects one of its arguments, then computes it.
It is associative and commutative.
*/
Rule
choice(X*, Y, Z*) ~> Y
Funcon
if-true-else(_:booleans, _:=>T, _:=>T) : =>T
Alias
if-else = if-true-else
/*
`if-true-else(B, X, Y)` evaluates `B` to a Boolean value, then reduces
to `X` or `Y`, depending on the value of `B`.
*/
Rule
if-true-else(true, X, Y) ~> X
Rule
if-true-else(false, X, Y) ~> Y
#### Iterating
Funcon
while-true(B:=>booleans, X:=>null-type) : =>null-type
~> if-true-else(B, sequential(X, while-true(B, X)), null-value)
Alias
while = while-true
/*
`while-true(B, X)` evaluates `B` to a Boolean value. Depending on the value
of `B`, it either executes `X` and iterates, or terminates normally.
The effect of abruptly breaking the iteration is obtained by the combination
`handle-break(while-true(B, X))`, and that of abruptly continuing the iteration by
`while-true(B, handle-continue(X))`.
*/
Funcon
do-while-true(X:=>null-type, B:=>booleans) : =>null-type
~> sequential(X, if-true-else(B, do-while-true(X, B), null-value))
Alias
do-while = do-while-true
/*
`do-while-true(X, B)` is equivalent to `sequential(X, while-true(B, X))`.
*/
#### Interleaving
Funcon
interleave(_:T*) : =>T*
/*
`interleave(...)` computes its arguments in any order, possibly interleaved,
and returns the resulting sequence of values, provided all terminate normally.
Fairness of interleaving is not required, so pure left-to-right computation
is allowed.
`atomic(X)` prevents interleaving in `X`, except after transitions that emit
a `yielded(signal)`.
*/
Rule
interleave(V*:T*) ~> V*
Datatype
yielding ::= signal
Entity
_ --yielded(_:yielding?)-> _
/*
`yielded(signal)` in a label on a transition allows interleaving at that point
in the enclosing atomic computation.
`yielded( )` indicates interleaving at that point in an atomic computation
is not allowed.
*/
Funcon
yield : =>null-type
~> yield-on-value(null-value)
Funcon
yield-on-value(_:T) : =>T
/*
`yield-on-value(X)` allows interleaving in an enclosing atomic computation
on normal termination of `X`.
*/
Rule
yield-on-value(V:T) --yielded(signal)-> V
Funcon
yield-on-abrupt(_:=>T) : =>T
/*
`yield-on-abrupt(X)` ensures that abrupt termination of `X` is propagated
through an enclosing atomic computation.
*/
Rule
X --abrupt(V:T),yielded(_?)-> X'
--------------------------------------------------------------------
yield-on-abrupt(X) --abrupt(V),yielded(signal)-> yield-on-abrupt(X')
Rule
X --abrupt( )-> X'
----------------------------------------------------
yield-on-abrupt(X) --abrupt( )-> yield-on-abrupt(X')
Rule
yield-on-abrupt(V:T) ~> V
Funcon
atomic(_:=>T) : =>T
/*
`atomic(X)` computes `X`, but controls its potential interleaving with other
computations: interleaving is only allowed following a transition of `X` that
emits `yielded(signal)`.
*/
Rule
X --yielded( )->1 X'
atomic(X') --yielded( )->2 X''
-----------------------------------------------
atomic(X) --yielded( )->1 ; --yielded( )->2 X''
Rule
X --yielded( )-> V
V : T
---------------------------
atomic(X) --yielded( )-> V
Rule
atomic(V:T) ~> V
Rule
X --yielded(signal)-> X'
-----------------------------------
atomic(X) --yielded( )-> atomic(X')

289
IBAF-cbs/Funcons-beta/Computations/Normal/Flowing/index.md Normal file
View File

@@ -0,0 +1,289 @@
---
layout: default
title: "Flowing"
parent: Normal
ancestor: Funcons-beta
---
[Funcons-beta] : [Flowing.cbs]
-----------------------------
### Flowing
<div class="highlighter-rouge"><pre class="highlight"><code>[
<i class="keyword">Funcon</i> <span class="name"><a href="#Name_left-to-right">left-to-right</a></span> <i class="keyword">Alias</i> <span class="name"><a href="#Name_l-to-r">l-to-r</a></span>
<i class="keyword">Funcon</i> <span class="name"><a href="#Name_right-to-left">right-to-left</a></span> <i class="keyword">Alias</i> <span class="name"><a href="#Name_r-to-l">r-to-l</a></span>
<i class="keyword">Funcon</i> <span class="name"><a href="#Name_sequential">sequential</a></span> <i class="keyword">Alias</i> <span class="name"><a href="#Name_seq">seq</a></span>
<i class="keyword">Funcon</i> <span class="name"><a href="#Name_effect">effect</a></span>
<i class="keyword">Funcon</i> <span class="name"><a href="#Name_choice">choice</a></span>
<i class="keyword">Funcon</i> <span class="name"><a href="#Name_if-true-else">if-true-else</a></span> <i class="keyword">Alias</i> <span class="name"><a href="#Name_if-else">if-else</a></span>
<i class="keyword">Funcon</i> <span class="name"><a href="#Name_while-true">while-true</a></span> <i class="keyword">Alias</i> <span class="name"><a href="#Name_while">while</a></span>
<i class="keyword">Funcon</i> <span class="name"><a href="#Name_do-while-true">do-while-true</a></span> <i class="keyword">Alias</i> <span class="name"><a href="#Name_do-while">do-while</a></span>
<i class="keyword">Funcon</i> <span class="name"><a href="#Name_interleave">interleave</a></span>
<i class="keyword">Datatype</i> <span class="name"><a href="#Name_yielding">yielding</a></span>
<i class="keyword">Funcon</i> <span class="name"><a href="#Name_signal">signal</a></span>
<i class="keyword">Funcon</i> <span class="name"><a href="#Name_yielded">yielded</a></span>
<i class="keyword">Funcon</i> <span class="name"><a href="#Name_yield">yield</a></span>
<i class="keyword">Funcon</i> <span class="name"><a href="#Name_yield-on-value">yield-on-value</a></span>
<i class="keyword">Funcon</i> <span class="name"><a href="#Name_yield-on-abrupt">yield-on-abrupt</a></span>
<i class="keyword">Funcon</i> <span class="name"><a href="#Name_atomic">atomic</a></span>
]</code></pre></div>
<div class="highlighter-rouge"><pre class="highlight"><code><i class="keyword">Meta-variables</i>
<span id="PartVariable_T"><i class="var">T</i></span> <: <span class="name"><a href="../../../Values/Value-Types/index.html#Name_values">values</a></span>
<span id="PartVariable_T*"><i class="var">T<sup class="sup">*</sup></i></span> <: <span class="name"><a href="../../../Values/Value-Types/index.html#Name_values">values</a></span><sup class="sup">*</sup></code></pre></div>
#### Sequencing
<div class="highlighter-rouge"><pre class="highlight"><code><i class="keyword">Funcon</i>
<span class="name"><span id="Name_left-to-right">left-to-right</span></span>(_:(=>(<span id="Variable139_T"><i class="var">T</i></span>)<sup class="sup">*</sup>)<sup class="sup">*</sup>) : =>(<span id="Variable168_T"><i class="var">T</i></span>)<sup class="sup">*</sup>
<i class="keyword">Alias</i>
<span class="name"><span id="Name_l-to-r">l-to-r</span></span> = <span class="name"><a href="#Name_left-to-right">left-to-right</a></span></code></pre></div>
<code><span class="name"><a href="#Name_left-to-right">left-to-right</a></span>(...)</code> computes its arguments sequentially, from left to right,
and gives the resulting sequence of values, provided all terminate normally.
For example, <code><span class="name"><a href="../../../Values/Primitive/Integers/index.html#Name_integer-add">integer-add</a></span>(<i class="var">X</i>, <i class="var">Y</i>)</code> may interleave the computations of <code><i class="var">X</i></code> and
<code><i class="var">Y</i></code>, whereas <code><span class="name"><a href="../../../Values/Primitive/Integers/index.html#Name_integer-add">integer-add</a></span> <span class="name"><a href="#Name_left-to-right">left-to-right</a></span>(<i class="var">X</i>, <i class="var">Y</i>)</code> always computes <code><i class="var">X</i></code> before <code><i class="var">Y</i></code>.
When each argument of <code><span class="name"><a href="#Name_left-to-right">left-to-right</a></span>(...)</code> computes a single value, the type
of the result is the same as that of the argument sequence. For instance,
when <code><i class="var">X</i>:<i class="var">T</i></code> and <code><i class="var">Y</i>:<i class="var">T&prime;</i></code>, the result of <code><span class="name"><a href="#Name_left-to-right">left-to-right</a></span>(<i class="var">X</i>, <i class="var">Y</i>)</code> is of type <code>(<i class="var">T</i>, <i class="var">T&prime;</i>)</code>.
The only effect of wrapping an argument sequence in <code><span class="name"><a href="#Name_left-to-right">left-to-right</a></span>(...)</code> is to
ensure that when the arguments are to be evaluated, it is done in the
specified order.
<div class="highlighter-rouge"><pre class="highlight"><code><i class="keyword">Rule</i>
<a href="#Variable484_Y"><i class="var">Y</i></a> ---> <span id="Variable452_Y'"><i class="var">Y&prime;</i></span>
------------------------------------------------------------
<span class="name"><a href="#Name_left-to-right">left-to-right</a></span>(<span id="Variable466_V*"><i class="var">V<sup class="sup">*</sup></i></span>:(<i class="var">T</i>)<sup class="sup">*</sup>, <span id="Variable484_Y"><i class="var">Y</i></span>, <span id="Variable490_Z*"><i class="var">Z<sup class="sup">*</sup></i></span>) ---> <span class="name"><a href="#Name_left-to-right">left-to-right</a></span>(<a href="#Variable466_V*"><i class="var">V<sup class="sup">*</sup></i></a>, <a href="#Variable452_Y'"><i class="var">Y&prime;</i></a>, <a href="#Variable490_Z*"><i class="var">Z<sup class="sup">*</sup></i></a>)
<i class="keyword">Rule</i>
<span class="name"><a href="#Name_left-to-right">left-to-right</a></span>(<span id="Variable539_V*"><i class="var">V<sup class="sup">*</sup></i></span>:(<i class="var">T</i>)<sup class="sup">*</sup>) ~> <a href="#Variable539_V*"><i class="var">V<sup class="sup">*</sup></i></a></code></pre></div>
<div class="highlighter-rouge"><pre class="highlight"><code><i class="keyword">Funcon</i>
<span class="name"><span id="Name_right-to-left">right-to-left</span></span>(_:(=>(<span id="Variable577_T"><i class="var">T</i></span>)<sup class="sup">*</sup>)<sup class="sup">*</sup>) : =>(<span id="Variable606_T"><i class="var">T</i></span>)<sup class="sup">*</sup>
<i class="keyword">Alias</i>
<span class="name"><span id="Name_r-to-l">r-to-l</span></span> = <span class="name"><a href="#Name_right-to-left">right-to-left</a></span></code></pre></div>
<code><span class="name"><a href="#Name_right-to-left">right-to-left</a></span>(...)</code> computes its arguments sequentially, from right to left,
and gives the resulting sequence of values, provided all terminate normally.
Note that <code><span class="name"><a href="#Name_right-to-left">right-to-left</a></span>(<i class="var">X<sup class="sup">*</sup></i>)</code> and <code><span class="name"><a href="../../../Values/Composite/Sequences/index.html#Name_reverse">reverse</a></span> <span class="name"><a href="#Name_left-to-right">left-to-right</a></span> <span class="name"><a href="../../../Values/Composite/Sequences/index.html#Name_reverse">reverse</a></span>(<i class="var">X<sup class="sup">*</sup></i>)</code> are
not equivalent: <code><span class="name"><a href="../../../Values/Composite/Sequences/index.html#Name_reverse">reverse</a></span>(<i class="var">X<sup class="sup">*</sup></i>)</code> interleaves the evaluation of <code><i class="var">X<sup class="sup">*</sup></i></code>.
<div class="highlighter-rouge"><pre class="highlight"><code><i class="keyword">Rule</i>
<a href="#Variable758_Y"><i class="var">Y</i></a> ---> <span id="Variable739_Y'"><i class="var">Y&prime;</i></span>
------------------------------------------------------------
<span class="name"><a href="#Name_right-to-left">right-to-left</a></span>(<span id="Variable753_X*"><i class="var">X<sup class="sup">*</sup></i></span>, <span id="Variable758_Y"><i class="var">Y</i></span>, <span id="Variable764_V*"><i class="var">V<sup class="sup">*</sup></i></span>:(<i class="var">T</i>)<sup class="sup">*</sup>) ---> <span class="name"><a href="#Name_right-to-left">right-to-left</a></span>(<a href="#Variable753_X*"><i class="var">X<sup class="sup">*</sup></i></a>, <a href="#Variable739_Y'"><i class="var">Y&prime;</i></a>, <a href="#Variable764_V*"><i class="var">V<sup class="sup">*</sup></i></a>)
<i class="keyword">Rule</i>
<span class="name"><a href="#Name_right-to-left">right-to-left</a></span>(<span id="Variable826_V*"><i class="var">V<sup class="sup">*</sup></i></span>:(<i class="var">T</i>)<sup class="sup">*</sup>) ~> <a href="#Variable826_V*"><i class="var">V<sup class="sup">*</sup></i></a></code></pre></div>
<div class="highlighter-rouge"><pre class="highlight"><code><i class="keyword">Funcon</i>
<span class="name"><span id="Name_sequential">sequential</span></span>(_:(=><span class="name"><a href="../../../Values/Primitive/Null/index.html#Name_null-type">null-type</a></span>)<sup class="sup">*</sup>, _:=><span id="Variable881_T"><i class="var">T</i></span>) : =><span id="Variable897_T"><i class="var">T</i></span>
<i class="keyword">Alias</i>
<span class="name"><span id="Name_seq">seq</span></span> = <span class="name"><a href="#Name_sequential">sequential</a></span></code></pre></div>
<code><span class="name"><a href="#Name_sequential">sequential</a></span>(<i class="var">X</i>, ...)</code> computes its arguments in the given order. On normal
termination, it returns the value of the last argument; the other arguments
all compute <code><span class="name"><a href="../../../Values/Primitive/Null/index.html#Name_null-value">null-value</a></span></code>.
Binary <code><span class="name"><a href="#Name_sequential">sequential</a></span>(<i class="var">X</i>, <i class="var">Y</i>)</code> is associative, with unit <code><span class="name"><a href="../../../Values/Primitive/Null/index.html#Name_null-value">null-value</a></span></code>.
<div class="highlighter-rouge"><pre class="highlight"><code><i class="keyword">Rule</i>
<a href="#Variable1007_X"><i class="var">X</i></a> ---> <span id="Variable994_X'"><i class="var">X&prime;</i></span>
-----------------------------------------
<span class="name"><a href="#Name_sequential">sequential</a></span>(<span id="Variable1007_X"><i class="var">X</i></span>, <span id="Variable1013_Y+"><i class="var">Y<sup class="sup">+</sup></i></span>) ---> <span class="name"><a href="#Name_sequential">sequential</a></span>(<a href="#Variable994_X'"><i class="var">X&prime;</i></a>, <a href="#Variable1013_Y+"><i class="var">Y<sup class="sup">+</sup></i></a>)
<i class="keyword">Rule</i>
<span class="name"><a href="#Name_sequential">sequential</a></span>(<span class="name"><a href="../../../Values/Primitive/Null/index.html#Name_null-value">null-value</a></span>, <span id="Variable1056_Y+"><i class="var">Y<sup class="sup">+</sup></i></span>) ~> <span class="name"><a href="#Name_sequential">sequential</a></span>(<a href="#Variable1056_Y+"><i class="var">Y<sup class="sup">+</sup></i></a>)
<i class="keyword">Rule</i>
<span class="name"><a href="#Name_sequential">sequential</a></span>(<span id="Variable1085_Y"><i class="var">Y</i></span>) ~> <a href="#Variable1085_Y"><i class="var">Y</i></a></code></pre></div>
<div class="highlighter-rouge"><pre class="highlight"><code><i class="keyword">Funcon</i>
<span class="name"><span id="Name_effect">effect</span></span>(<span id="Variable1106_V*"><i class="var">V<sup class="sup">*</sup></i></span>:<span id="Variable1111_T*"><i class="var">T<sup class="sup">*</sup></i></span>) : =><span class="name"><a href="../../../Values/Primitive/Null/index.html#Name_null-type">null-type</a></span>
~> <span class="name"><a href="../../../Values/Primitive/Null/index.html#Name_null-value">null-value</a></span></code></pre></div>
<code><span class="name"><a href="#Name_effect">effect</a></span>(...)</code> interleaves the computations of its arguments, then discards
all the computed values.
#### Choosing
<div class="highlighter-rouge"><pre class="highlight"><code><i class="keyword">Funcon</i>
<span class="name"><span id="Name_choice">choice</span></span>(_:(=><span id="Variable1188_T"><i class="var">T</i></span>)<sup class="sup">+</sup>) : =><span id="Variable1210_T"><i class="var">T</i></span></code></pre></div>
<code><span class="name"><a href="#Name_choice">choice</a></span>(<i class="var">Y</i>, ...)</code> selects one of its arguments, then computes it.
It is associative and commutative.
<div class="highlighter-rouge"><pre class="highlight"><code><i class="keyword">Rule</i>
<span class="name"><a href="#Name_choice">choice</a></span>(<span id="Variable1250_X*"><i class="var">X<sup class="sup">*</sup></i></span>, <span id="Variable1255_Y"><i class="var">Y</i></span>, <span id="Variable1261_Z*"><i class="var">Z<sup class="sup">*</sup></i></span>) ~> <a href="#Variable1255_Y"><i class="var">Y</i></a></code></pre></div>
<div class="highlighter-rouge"><pre class="highlight"><code><i class="keyword">Funcon</i>
<span class="name"><span id="Name_if-true-else">if-true-else</span></span>(_:<span class="name"><a href="../../../Values/Primitive/Booleans/index.html#Name_booleans">booleans</a></span>, _:=><span id="Variable1295_T"><i class="var">T</i></span>, _:=><span id="Variable1308_T"><i class="var">T</i></span>) : =><span id="Variable1325_T"><i class="var">T</i></span>
<i class="keyword">Alias</i>
<span class="name"><span id="Name_if-else">if-else</span></span> = <span class="name"><a href="#Name_if-true-else">if-true-else</a></span></code></pre></div>
<code><span class="name"><a href="#Name_if-true-else">if-true-else</a></span>(<i class="var">B</i>, <i class="var">X</i>, <i class="var">Y</i>)</code> evaluates <code><i class="var">B</i></code> to a Boolean value, then reduces
to <code><i class="var">X</i></code> or <code><i class="var">Y</i></code>, depending on the value of <code><i class="var">B</i></code>.
<div class="highlighter-rouge"><pre class="highlight"><code><i class="keyword">Rule</i>
<span class="name"><a href="#Name_if-true-else">if-true-else</a></span>(<span class="name"><a href="../../../Values/Primitive/Booleans/index.html#Name_true">true</a></span>, <span id="Variable1429_X"><i class="var">X</i></span>, <span id="Variable1434_Y"><i class="var">Y</i></span>) ~> <a href="#Variable1429_X"><i class="var">X</i></a>
<i class="keyword">Rule</i>
<span class="name"><a href="#Name_if-true-else">if-true-else</a></span>(<span class="name"><a href="../../../Values/Primitive/Booleans/index.html#Name_false">false</a></span>, <span id="Variable1458_X"><i class="var">X</i></span>, <span id="Variable1463_Y"><i class="var">Y</i></span>) ~> <a href="#Variable1463_Y"><i class="var">Y</i></a></code></pre></div>
#### Iterating
<div class="highlighter-rouge"><pre class="highlight"><code><i class="keyword">Funcon</i>
<span class="name"><span id="Name_while-true">while-true</span></span>(<span id="Variable1501_B"><i class="var">B</i></span>:=><span class="name"><a href="../../../Values/Primitive/Booleans/index.html#Name_booleans">booleans</a></span>, <span id="Variable1512_X"><i class="var">X</i></span>:=><span class="name"><a href="../../../Values/Primitive/Null/index.html#Name_null-type">null-type</a></span>) : =><span class="name"><a href="../../../Values/Primitive/Null/index.html#Name_null-type">null-type</a></span>
~> <span class="name"><a href="#Name_if-true-else">if-true-else</a></span>(<a href="#Variable1501_B"><i class="var">B</i></a>, <span class="name"><a href="#Name_sequential">sequential</a></span>(<a href="#Variable1512_X"><i class="var">X</i></a>, <span class="name"><a href="#Name_while-true">while-true</a></span>(<a href="#Variable1501_B"><i class="var">B</i></a>, <a href="#Variable1512_X"><i class="var">X</i></a>)), <span class="name"><a href="../../../Values/Primitive/Null/index.html#Name_null-value">null-value</a></span>)
<i class="keyword">Alias</i>
<span class="name"><span id="Name_while">while</span></span> = <span class="name"><a href="#Name_while-true">while-true</a></span></code></pre></div>
<code><span class="name"><a href="#Name_while-true">while-true</a></span>(<i class="var">B</i>, <i class="var">X</i>)</code> evaluates <code><i class="var">B</i></code> to a Boolean value. Depending on the value
of <code><i class="var">B</i></code>, it either executes <code><i class="var">X</i></code> and iterates, or terminates normally.
The effect of abruptly breaking the iteration is obtained by the combination
<code><span class="name"><a href="../../Abnormal/Breaking/index.html#Name_handle-break">handle-break</a></span>(<span class="name"><a href="#Name_while-true">while-true</a></span>(<i class="var">B</i>, <i class="var">X</i>))</code>, and that of abruptly continuing the iteration by
<code><span class="name"><a href="#Name_while-true">while-true</a></span>(<i class="var">B</i>, <span class="name"><a href="../../Abnormal/Continuing/index.html#Name_handle-continue">handle-continue</a></span>(<i class="var">X</i>))</code>.
<div class="highlighter-rouge"><pre class="highlight"><code><i class="keyword">Funcon</i>
<span class="name"><span id="Name_do-while-true">do-while-true</span></span>(<span id="Variable1724_X"><i class="var">X</i></span>:=><span class="name"><a href="../../../Values/Primitive/Null/index.html#Name_null-type">null-type</a></span>, <span id="Variable1735_B"><i class="var">B</i></span>:=><span class="name"><a href="../../../Values/Primitive/Booleans/index.html#Name_booleans">booleans</a></span>) : =><span class="name"><a href="../../../Values/Primitive/Null/index.html#Name_null-type">null-type</a></span>
~> <span class="name"><a href="#Name_sequential">sequential</a></span>(<a href="#Variable1724_X"><i class="var">X</i></a>, <span class="name"><a href="#Name_if-true-else">if-true-else</a></span>(<a href="#Variable1735_B"><i class="var">B</i></a>, <span class="name"><a href="#Name_do-while-true">do-while-true</a></span>(<a href="#Variable1724_X"><i class="var">X</i></a>, <a href="#Variable1735_B"><i class="var">B</i></a>), <span class="name"><a href="../../../Values/Primitive/Null/index.html#Name_null-value">null-value</a></span>))
<i class="keyword">Alias</i>
<span class="name"><span id="Name_do-while">do-while</span></span> = <span class="name"><a href="#Name_do-while-true">do-while-true</a></span></code></pre></div>
<code><span class="name"><a href="#Name_do-while-true">do-while-true</a></span>(<i class="var">X</i>, <i class="var">B</i>)</code> is equivalent to <code><span class="name"><a href="#Name_sequential">sequential</a></span>(<i class="var">X</i>, <span class="name"><a href="#Name_while-true">while-true</a></span>(<i class="var">B</i>, <i class="var">X</i>))</code>.
#### Interleaving
<div class="highlighter-rouge"><pre class="highlight"><code><i class="keyword">Funcon</i>
<span class="name"><span id="Name_interleave">interleave</span></span>(_:<span id="Variable1899_T*"><i class="var">T<sup class="sup">*</sup></i></span>) : =><span id="Variable1914_T*"><i class="var">T<sup class="sup">*</sup></i></span></code></pre></div>
<code><span class="name"><a href="#Name_interleave">interleave</a></span>(...)</code> computes its arguments in any order, possibly interleaved,
and returns the resulting sequence of values, provided all terminate normally.
Fairness of interleaving is not required, so pure left-to-right computation
is allowed.
<code><span class="name"><a href="#Name_atomic">atomic</a></span>(<i class="var">X</i>)</code> prevents interleaving in <code><i class="var">X</i></code>, except after transitions that emit
a <code><span class="name"><a href="#Name_yielded">yielded</a></span>(<span class="name"><a href="#Name_signal">signal</a></span>)</code>.
<div class="highlighter-rouge"><pre class="highlight"><code><i class="keyword">Rule</i>
<span class="name"><a href="#Name_interleave">interleave</a></span>(<span id="Variable1998_V*"><i class="var">V<sup class="sup">*</sup></i></span>:<i class="var">T<sup class="sup">*</sup></i>) ~> <a href="#Variable1998_V*"><i class="var">V<sup class="sup">*</sup></i></a></code></pre></div>
<div class="highlighter-rouge"><pre class="highlight"><code><i class="keyword">Datatype</i>
<span class="name"><span id="Name_yielding">yielding</span></span> ::= <span id="Name_signal">signal</span></code></pre></div>
<div class="highlighter-rouge"><pre class="highlight"><code><i class="keyword">Entity</i>
_ --<span class="ent-name"><span id="Name_yielded">yielded</span></span>(_:<span class="name"><a href="#Name_yielding">yielding</a></span><sup class="sup">?</sup>)-> _</code></pre></div>
<code><span class="name"><a href="#Name_yielded">yielded</a></span>(<span class="name"><a href="#Name_signal">signal</a></span>)</code> in a label on a transition allows interleaving at that point
in the enclosing atomic computation.
<code><span class="name"><a href="#Name_yielded">yielded</a></span>( )</code> indicates interleaving at that point in an atomic computation
is not allowed.
<div class="highlighter-rouge"><pre class="highlight"><code><i class="keyword">Funcon</i>
<span class="name"><span id="Name_yield">yield</span></span> : =><span class="name"><a href="../../../Values/Primitive/Null/index.html#Name_null-type">null-type</a></span>
~> <span class="name"><a href="#Name_yield-on-value">yield-on-value</a></span>(<span class="name"><a href="../../../Values/Primitive/Null/index.html#Name_null-value">null-value</a></span>)</code></pre></div>
<div class="highlighter-rouge"><pre class="highlight"><code><i class="keyword">Funcon</i>
<span class="name"><span id="Name_yield-on-value">yield-on-value</span></span>(_:<span id="Variable2110_T"><i class="var">T</i></span>) : =><span id="Variable2124_T"><i class="var">T</i></span></code></pre></div>
<code><span class="name"><a href="#Name_yield-on-value">yield-on-value</a></span>(<i class="var">X</i>)</code> allows interleaving in an enclosing atomic computation
on normal termination of <code><i class="var">X</i></code>.
<div class="highlighter-rouge"><pre class="highlight"><code><i class="keyword">Rule</i>
<span class="name"><a href="#Name_yield-on-value">yield-on-value</a></span>(<span id="Variable2173_V"><i class="var">V</i></span>:<i class="var">T</i>) --<span class="ent-name"><a href="#Name_yielded">yielded</a></span>(<span class="name"><a href="#Name_signal">signal</a></span>)-> <a href="#Variable2173_V"><i class="var">V</i></a></code></pre></div>
<div class="highlighter-rouge"><pre class="highlight"><code><i class="keyword">Funcon</i>
<span class="name"><span id="Name_yield-on-abrupt">yield-on-abrupt</span></span>(_:=><span id="Variable2220_T"><i class="var">T</i></span>) : =><span id="Variable2235_T"><i class="var">T</i></span></code></pre></div>
<code><span class="name"><a href="#Name_yield-on-abrupt">yield-on-abrupt</a></span>(<i class="var">X</i>)</code> ensures that abrupt termination of <code><i class="var">X</i></code> is propagated
through an enclosing atomic computation.
<div class="highlighter-rouge"><pre class="highlight"><code><i class="keyword">Rule</i>
<a href="#Variable2341_X"><i class="var">X</i></a> --<span class="ent-name"><a href="../../Abnormal/Abrupting/index.html#Name_abrupt">abrupt</a></span>(<span id="Variable2291_V"><i class="var">V</i></span>:<i class="var">T</i>),<span class="ent-name"><a href="#Name_yielded">yielded</a></span>(_?)-> <span id="Variable2328_X'"><i class="var">X&prime;</i></span>
--------------------------------------------------------------------
<span class="name"><a href="#Name_yield-on-abrupt">yield-on-abrupt</a></span>(<span id="Variable2341_X"><i class="var">X</i></span>) --<span class="ent-name"><a href="../../Abnormal/Abrupting/index.html#Name_abrupt">abrupt</a></span>(<a href="#Variable2291_V"><i class="var">V</i></a>),<span class="ent-name"><a href="#Name_yielded">yielded</a></span>(<span class="name"><a href="#Name_signal">signal</a></span>)-> <span class="name"><a href="#Name_yield-on-abrupt">yield-on-abrupt</a></span>(<a href="#Variable2328_X'"><i class="var">X&prime;</i></a>)
<i class="keyword">Rule</i>
<a href="#Variable2432_X"><i class="var">X</i></a> --<span class="ent-name"><a href="../../Abnormal/Abrupting/index.html#Name_abrupt">abrupt</a></span>( )-> <span id="Variable2419_X'"><i class="var">X&prime;</i></span>
----------------------------------------------------
<span class="name"><a href="#Name_yield-on-abrupt">yield-on-abrupt</a></span>(<span id="Variable2432_X"><i class="var">X</i></span>) --<span class="ent-name"><a href="../../Abnormal/Abrupting/index.html#Name_abrupt">abrupt</a></span>( )-> <span class="name"><a href="#Name_yield-on-abrupt">yield-on-abrupt</a></span>(<a href="#Variable2419_X'"><i class="var">X&prime;</i></a>)
<i class="keyword">Rule</i>
<span class="name"><a href="#Name_yield-on-abrupt">yield-on-abrupt</a></span>(<span id="Variable2474_V"><i class="var">V</i></span>:<i class="var">T</i>) ~> <a href="#Variable2474_V"><i class="var">V</i></a></code></pre></div>
<div class="highlighter-rouge"><pre class="highlight"><code><i class="keyword">Funcon</i>
<span class="name"><span id="Name_atomic">atomic</span></span>(_:=><span id="Variable2504_T"><i class="var">T</i></span>) : =><span id="Variable2519_T"><i class="var">T</i></span></code></pre></div>
<code><span class="name"><a href="#Name_atomic">atomic</a></span>(<i class="var">X</i>)</code> computes <code><i class="var">X</i></code>, but controls its potential interleaving with other
computations: interleaving is only allowed following a transition of <code><i class="var">X</i></code> that
emits <code><span class="name"><a href="#Name_yielded">yielded</a></span>(<span class="name"><a href="#Name_signal">signal</a></span>)</code>.
<div class="highlighter-rouge"><pre class="highlight"><code><i class="keyword">Rule</i>
<a href="#Variable2667_X"><i class="var">X</i></a> --<span class="ent-name"><a href="#Name_yielded">yielded</a></span>( )->1 <span id="Variable2617_X'"><i class="var">X&prime;</i></span>
<span class="name"><a href="#Name_atomic">atomic</a></span>(<a href="#Variable2617_X'"><i class="var">X&prime;</i></a>) --<span class="ent-name"><a href="#Name_yielded">yielded</a></span>( )->2 <span id="Variable2653_X''"><i class="var">X&prime;&prime;</i></span>
-----------------------------------------------
<span class="name"><a href="#Name_atomic">atomic</a></span>(<span id="Variable2667_X"><i class="var">X</i></span>) --<span class="ent-name"><a href="#Name_yielded">yielded</a></span>( )->1 ; --<span class="ent-name"><a href="#Name_yielded">yielded</a></span>( )->2 <a href="#Variable2653_X''"><i class="var">X&prime;&prime;</i></a>
<i class="keyword">Rule</i>
<a href="#Variable2762_X"><i class="var">X</i></a> --<span class="ent-name"><a href="#Name_yielded">yielded</a></span>( )-> <span id="Variable2735_V"><i class="var">V</i></span>
<a href="#Variable2735_V"><i class="var">V</i></a> : <i class="var">T</i>
---------------------------
<span class="name"><a href="#Name_atomic">atomic</a></span>(<span id="Variable2762_X"><i class="var">X</i></span>) --<span class="ent-name"><a href="#Name_yielded">yielded</a></span>( )-> <a href="#Variable2735_V"><i class="var">V</i></a>
<i class="keyword">Rule</i>
<span class="name"><a href="#Name_atomic">atomic</a></span>(<span id="Variable2796_V"><i class="var">V</i></span>:<i class="var">T</i>) ~> <a href="#Variable2796_V"><i class="var">V</i></a>
<i class="keyword">Rule</i>
<a href="#Variable2857_X"><i class="var">X</i></a> --<span class="ent-name"><a href="#Name_yielded">yielded</a></span>(<span class="name"><a href="#Name_signal">signal</a></span>)-> <span id="Variable2844_X'"><i class="var">X&prime;</i></span>
-----------------------------------
<span class="name"><a href="#Name_atomic">atomic</a></span>(<span id="Variable2857_X"><i class="var">X</i></span>) --<span class="ent-name"><a href="#Name_yielded">yielded</a></span>( )-> <span class="name"><a href="#Name_atomic">atomic</a></span>(<a href="#Variable2844_X'"><i class="var">X&prime;</i></a>)</code></pre></div>
____
From the [PLanCompS Project] | [CBS-beta issues...] | [Suggest an improvement...]
[Flowing.cbs]: Flowing.cbs
"CBS SOURCE FILE"
[Funcons-beta]: /CBS-beta/docs/Funcons-beta
"FUNCONS-BETA"
[Unstable-Funcons-beta]: /CBS-beta/docs/Unstable-Funcons-beta
"UNSTABLE-FUNCONS-BETA"
[Languages-beta]: /CBS-beta/docs/Languages-beta
"LANGUAGES-BETA"
[Unstable-Languages-beta]: /CBS-beta/docs/Unstable-Languages-beta
"UNSTABLE-LANGUAGES-BETA"
[CBS-beta]: /CBS-beta "CBS-BETA"
[PLanCompS Project]: https://plancomps.github.io
"PROGRAMMING LANGUAGE COMPONENTS AND SPECIFICATIONS PROJECT HOME PAGE"
[CBS-beta issues...]: https://github.com/plancomps/CBS-beta/issues
"CBS-BETA ISSUE REPORTS ON GITHUB"
[Suggest an improvement...]: mailto:plancomps@gmail.com?Subject=CBS-beta%20-%20comment&Body=Re%3A%20CBS-beta%20specification%20at%20Computations/Normal/Flowing/Flowing.cbs%0A%0AComment/Query/Issue/Suggestion%3A%0A%0A%0ASignature%3A%0A
"GENERATE AN EMAIL TEMPLATE"

27
IBAF-cbs/Funcons-beta/Computations/Normal/Flowing/tests/atomic.config Normal file
View File

@@ -0,0 +1,27 @@
general {
funcon-term:
finalise-failing
sequential(
atomic(tuple()),
atomic(print 1),
atomic sequential(print 2,print 3),
interleave(
atomic sequential(print 4,print 5),
print 6),
interleave(
atomic sequential(yield-on-value print 7,print 8),
print 9),
else(
atomic yield-on-abrupt sequential(print 10,fail),
print 11))
;
}
tests {
result-term: null-value;
standard-out: [tuple(), 1, 2, 3, 4, 5, 6, 7, 8, 9, 10, 11];
//Also possible:
// standard-out: [................, 6, 4, 5, ...............];
// standard-out: [........................., 7, 9, 8, ......];
// standard-out: [........................., 9, 7, 8, ......];
}

19
IBAF-cbs/Funcons-beta/Computations/Normal/Flowing/tests/choice.config Normal file
View File

@@ -0,0 +1,19 @@
general {
funcon-term:
sequential(
print choice(1),
choice(print 2, print 3),
choice(print 4, print 5, print 6)
)
;
}
tests {
result-term: null-value;
standard-out: [1, 2, 4];
//Also possible:
// standard-out: [1, 3, 6];
// standard-out: [., 3, .];
// standard-out: [...., 5];
// standard-out: [...., 6];
}

16
IBAF-cbs/Funcons-beta/Computations/Normal/Flowing/tests/do-while.config Normal file
View File

@@ -0,0 +1,16 @@
general {
funcon-term:
sequential(
do-while(print 1,false),
else(
do-while(
sequential(print 2, fail),
sequential(print"ERROR", true)),
print"OK"))
;
}
tests {
result-term: null-value;
standard-out: [1,2,"OK"];
}

10
IBAF-cbs/Funcons-beta/Computations/Normal/Flowing/tests/effect.config Normal file
View File

@@ -0,0 +1,10 @@
general {
funcon-term:
effect sequential(print 1, 2)
;
}
tests {
result-term: null-value;
standard-out: [1];
}

12
IBAF-cbs/Funcons-beta/Computations/Normal/Flowing/tests/if-true-else.config Normal file
View File

@@ -0,0 +1,12 @@
general {
funcon-term:
if-true-else(not false,
if-true-else(not true,fail,print"OK"),
fail)
;
}
tests {
result-term: null-value;
standard-out: ["OK"];
}

18
IBAF-cbs/Funcons-beta/Computations/Normal/Flowing/tests/interleave.config Normal file
View File

@@ -0,0 +1,18 @@
general {
funcon-term:
sequential(
print tuple interleave( ),
interleave(print 1),
effect tuple interleave(print 2,print 3),
effect tuple interleave(sequential(print 4,print 5),print 6))
;
}
tests {
result-term: null-value;
standard-out: [tuple(), 1, 2, 3, 4, 5, 6];
//Also possible:
// standard-out: [.........., 3, 2, .......];
// standard-out: [................, 4, 6, 5];
// standard-out: [................, 6, 4, 5];
}

18
IBAF-cbs/Funcons-beta/Computations/Normal/Flowing/tests/left-to-right.config Normal file
View File

@@ -0,0 +1,18 @@
general {
funcon-term:
sequential(
print tuple left-to-right ( ),
effect left-to-right(print 1),
effect tuple left-to-right(print 2, print 3),
effect tuple left-to-right(print 4, print 5, print 6),
effect integer-add left-to-right(
sequential(print 7, 7),
sequential(print 8, 8))
)
;
}
tests {
result-term: null-value;
standard-out: [tuple(), 1, 2, 3, 4, 5, 6, 7, 8];
}

18
IBAF-cbs/Funcons-beta/Computations/Normal/Flowing/tests/right-to-left.config Normal file
View File

@@ -0,0 +1,18 @@
general {
funcon-term:
sequential(
print tuple right-to-left ( ),
effect right-to-left(print 1),
effect right-to-left(print 3, print 2),
effect right-to-left(print 6, print 5, print 4),
effect integer-add right-to-left(
sequential(print 8, 8),
sequential(print 7, 7))
)
;
}
tests {
result-term: null-value;
standard-out: [tuple(), 1, 2, 3, 4, 5, 6, 7, 8];
}

13
IBAF-cbs/Funcons-beta/Computations/Normal/Flowing/tests/sequential.config Normal file
View File

@@ -0,0 +1,13 @@
general {
funcon-term:
sequential(
sequential(print 1, print 2),
print sequential(print 3, print 4, 5)
)
;
}
tests {
result-term: null-value;
standard-out: [1, 2, 3, 4, 5];
}

16
IBAF-cbs/Funcons-beta/Computations/Normal/Flowing/tests/while.config Normal file
View File

@@ -0,0 +1,16 @@
general {
funcon-term:
sequential(
while(false,sequential(print"ERROR",fail)),
else(
while(
sequential(print 1, true),
sequential(print 2, fail)),
print"OK"))
;
}
tests {
result-term: null-value;
standard-out: [1,2,"OK"];
}

58
IBAF-cbs/Funcons-beta/Computations/Normal/Generating/Generating.cbs Normal file
View File

@@ -0,0 +1,58 @@
### Generating
[
Type atoms
Entity used-atom-set
Funcon initialise-generating
Funcon fresh-atom
Funcon use-atom-not-in
]
Meta-variables
T <: values
Built-in Type
atoms
/*
`atoms` is the type of values used as distinguishable tags.
Notation for individual atoms is not provided.
*/
Entity
< _ , used-atom-set(_:sets(atoms)) > ---> < _ , used-atom-set(_:sets(atoms)) >
Built-in Funcon
initialise-generating(_:=>T) : =>T
/*
The initial value of the `used-atom-set(SA)` entity is unspecified. It could
contains atoms that are reserved for internal use.
*/
Funcon
fresh-atom : =>atoms
/*
`fresh-atom` computes an atom distinct from all previously computed atoms.
*/
Rule
element-not-in(atoms, SA) ~> A
-----------------------------------------------
< fresh-atom , used-atom-set(SA) >
---> < A , used-atom-set(set-insert(A, SA)) >
Funcon
use-atom-not-in(_:sets(atoms)) : =>atoms
/*
`use-atom-not-in(SA)` computes an atom not in the set `SA`, and inserts it
in the `used-atom-set(SA')` entity, in case it was not previously used.
*/
Rule
element-not-in(atoms, SA) ~> A
--------------------------------------------------------
< use-atom-not-in(SA:sets(atoms)) , used-atom-set(SA') >
---> < A , used-atom-set(set-insert(A, SA')) >

97
IBAF-cbs/Funcons-beta/Computations/Normal/Generating/index.md Normal file
View File

@@ -0,0 +1,97 @@
---
layout: default
title: "Generating"
parent: Normal
ancestor: Funcons-beta
---
[Funcons-beta] : [Generating.cbs]
-----------------------------
### Generating
<div class="highlighter-rouge"><pre class="highlight"><code>[
<i class="keyword">Type</i> <span class="name"><a href="#Name_atoms">atoms</a></span>
<i class="keyword">Entity</i> <span class="name"><a href="#Name_used-atom-set">used-atom-set</a></span>
<i class="keyword">Funcon</i> <span class="name"><a href="#Name_initialise-generating">initialise-generating</a></span>
<i class="keyword">Funcon</i> <span class="name"><a href="#Name_fresh-atom">fresh-atom</a></span>
<i class="keyword">Funcon</i> <span class="name"><a href="#Name_use-atom-not-in">use-atom-not-in</a></span>
]</code></pre></div>
<div class="highlighter-rouge"><pre class="highlight"><code><i class="keyword">Meta-variables</i>
<span id="PartVariable_T"><i class="var">T</i></span> <: <span class="name"><a href="../../../Values/Value-Types/index.html#Name_values">values</a></span></code></pre></div>
<div class="highlighter-rouge"><pre class="highlight"><code><i class="keyword">Built-in</i> <i class="keyword">Type</i>
<span class="name"><span id="Name_atoms">atoms</span></span></code></pre></div>
<code><span class="name"><a href="#Name_atoms">atoms</a></span></code> is the type of values used as distinguishable tags.
Notation for individual atoms is not provided.
<div class="highlighter-rouge"><pre class="highlight"><code><i class="keyword">Entity</i>
< _ , <span class="ent-name"><span id="Name_used-atom-set">used-atom-set</span></span>(_:<span class="name"><a href="../../../Values/Composite/Sets/index.html#Name_sets">sets</a></span>(<span class="name"><a href="#Name_atoms">atoms</a></span>)) > ---> < _ , <span class="ent-name">used-atom-set</span>(_:<span class="name">sets</span>(<span class="name">atoms</span>)) ></code></pre></div>
<div class="highlighter-rouge"><pre class="highlight"><code><i class="keyword">Built-in</i> <i class="keyword">Funcon</i>
<span class="name"><span id="Name_initialise-generating">initialise-generating</span></span>(_:=><span id="Variable108_T"><i class="var">T</i></span>) : =><span id="Variable123_T"><i class="var">T</i></span></code></pre></div>
The initial value of the <code><span class="name"><a href="#Name_used-atom-set">used-atom-set</a></span>(<i class="var">SA</i>)</code> entity is unspecified. It could
contains atoms that are reserved for internal use.
<div class="highlighter-rouge"><pre class="highlight"><code><i class="keyword">Funcon</i>
<span class="name"><span id="Name_fresh-atom">fresh-atom</span></span> : =><span class="name"><a href="#Name_atoms">atoms</a></span></code></pre></div>
<code><span class="name"><a href="#Name_fresh-atom">fresh-atom</a></span></code> computes an atom distinct from all previously computed atoms.
<div class="highlighter-rouge"><pre class="highlight"><code><i class="keyword">Rule</i>
<span class="name"><a href="../../../Values/Composite/Sets/index.html#Name_element-not-in">element-not-in</a></span>(<span class="name"><a href="#Name_atoms">atoms</a></span>, <a href="#Variable211_SA"><i class="var">SA</i></a>) ~> <span id="Variable197_A"><i class="var">A</i></span>
-----------------------------------------------
< <span class="name"><a href="#Name_fresh-atom">fresh-atom</a></span> , <span class="ent-name"><a href="#Name_used-atom-set">used-atom-set</a></span>(<span id="Variable211_SA"><i class="var">SA</i></span>) >
---> < <a href="#Variable197_A"><i class="var">A</i></a> , <span class="ent-name"><a href="#Name_used-atom-set">used-atom-set</a></span>(<span class="name"><a href="../../../Values/Composite/Sets/index.html#Name_set-insert">set-insert</a></span>(<a href="#Variable197_A"><i class="var">A</i></a>, <a href="#Variable211_SA"><i class="var">SA</i></a>)) ></code></pre></div>
<div class="highlighter-rouge"><pre class="highlight"><code><i class="keyword">Funcon</i>
<span class="name"><span id="Name_use-atom-not-in">use-atom-not-in</span></span>(_:<span class="name"><a href="../../../Values/Composite/Sets/index.html#Name_sets">sets</a></span>(<span class="name"><a href="#Name_atoms">atoms</a></span>)) : =><span class="name"><a href="#Name_atoms">atoms</a></span></code></pre></div>
<code><span class="name"><a href="#Name_use-atom-not-in">use-atom-not-in</a></span>(<i class="var">SA</i>)</code> computes an atom not in the set <code><i class="var">SA</i></code>, and inserts it
in the <code><span class="name"><a href="#Name_used-atom-set">used-atom-set</a></span>(<i class="var">SA&prime;</i>)</code> entity, in case it was not previously used.
<div class="highlighter-rouge"><pre class="highlight"><code><i class="keyword">Rule</i>
<span class="name"><a href="../../../Values/Composite/Sets/index.html#Name_element-not-in">element-not-in</a></span>(<span class="name"><a href="#Name_atoms">atoms</a></span>, <a href="#Variable379_SA"><i class="var">SA</i></a>) ~> <span id="Variable367_A"><i class="var">A</i></span>
--------------------------------------------------------
< <span class="name"><a href="#Name_use-atom-not-in">use-atom-not-in</a></span>(<span id="Variable379_SA"><i class="var">SA</i></span>:<span class="name"><a href="../../../Values/Composite/Sets/index.html#Name_sets">sets</a></span>(<span class="name"><a href="#Name_atoms">atoms</a></span>)) , <span class="ent-name"><a href="#Name_used-atom-set">used-atom-set</a></span>(<span id="Variable402_SA'"><i class="var">SA&prime;</i></span>) >
---> < <a href="#Variable367_A"><i class="var">A</i></a> , <span class="ent-name"><a href="#Name_used-atom-set">used-atom-set</a></span>(<span class="name"><a href="../../../Values/Composite/Sets/index.html#Name_set-insert">set-insert</a></span>(<a href="#Variable367_A"><i class="var">A</i></a>, <a href="#Variable402_SA'"><i class="var">SA&prime;</i></a>)) ></code></pre></div>
____
From the [PLanCompS Project] | [CBS-beta issues...] | [Suggest an improvement...]
[Generating.cbs]: Generating.cbs
"CBS SOURCE FILE"
[Funcons-beta]: /CBS-beta/docs/Funcons-beta
"FUNCONS-BETA"
[Unstable-Funcons-beta]: /CBS-beta/docs/Unstable-Funcons-beta
"UNSTABLE-FUNCONS-BETA"
[Languages-beta]: /CBS-beta/docs/Languages-beta
"LANGUAGES-BETA"
[Unstable-Languages-beta]: /CBS-beta/docs/Unstable-Languages-beta
"UNSTABLE-LANGUAGES-BETA"
[CBS-beta]: /CBS-beta "CBS-BETA"
[PLanCompS Project]: https://plancomps.github.io
"PROGRAMMING LANGUAGE COMPONENTS AND SPECIFICATIONS PROJECT HOME PAGE"
[CBS-beta issues...]: https://github.com/plancomps/CBS-beta/issues
"CBS-BETA ISSUE REPORTS ON GITHUB"
[Suggest an improvement...]: mailto:plancomps@gmail.com?Subject=CBS-beta%20-%20comment&Body=Re%3A%20CBS-beta%20specification%20at%20Computations/Normal/Generating/Generating.cbs%0A%0AComment/Query/Issue/Suggestion%3A%0A%0A%0ASignature%3A%0A
"GENERATE AN EMAIL TEMPLATE"

11
IBAF-cbs/Funcons-beta/Computations/Normal/Generating/tests/fresh-atom.config Normal file
View File

@@ -0,0 +1,11 @@
general {
funcon-term:
initialise-generating
give(fresh-atom,
check-true not is-equal(given, fresh-atom))
;
}
tests {
result-term: null-value;
}

14
IBAF-cbs/Funcons-beta/Computations/Normal/Generating/tests/use-atom-not-in.config Normal file
View File

@@ -0,0 +1,14 @@
general {
funcon-term:
initialise-generating
give(fresh-atom,
print is-equal(use-atom-not-in{given}, use-atom-not-in{given}))
;
}
tests {
result-term: null-value;
// standard-out: [ false ];
//Also possible:
standard-out: [ true ];
}

212
IBAF-cbs/Funcons-beta/Computations/Normal/Giving/Giving.cbs Normal file
View File

@@ -0,0 +1,212 @@
### Giving
[
Entity given-value
Funcon initialise-giving
Funcon give
Funcon given
Funcon no-given
Funcon left-to-right-map
Funcon interleave-map
Funcon left-to-right-repeat
Funcon interleave-repeat
Funcon left-to-right-filter
Funcon interleave-filter
Funcon fold-left
Funcon fold-right
]
Meta-variables
T, T' <: values
T? <: values?
Entity
given-value(_:values?) |- _ ---> _
/*
The given-value entity allows a computation to refer to a single
previously-computed `V:values`. The given value `( )` represents
the absence of a current given value.
*/
Funcon
initialise-giving(X:( )=>T') : ( )=>T'
~> no-given(X)
/*
`initialise-giving(X)` ensures that the entities used by the funcons for
giving are properly initialised.
*/
Funcon
give(_:T, _:T=>T') : =>T'
/*
`give(X, Y)` executes `X`, possibly referring to the current `given` value,
to compute a value `V`. It then executes `Y` with `V` as the `given` value,
to compute the result.
*/
Rule
given-value(V) |- Y ---> Y'
------------------------------------------------
given-value(_?) |- give(V:T, Y) ---> give(V, Y')
Rule
give(_:T, W:T') ~> W
Funcon
given : T=>T
/*
`given` refers to the current given value.
*/
Rule
given-value(V:values) |- given ---> V
Rule
given-value( ) |- given ---> fail
Funcon
no-given(_:( )=>T') : ( )=>T'
/*
`no-given(X)` computes `X` without references to the current given value.
*/
Rule
given-value( ) |- X ---> X'
------------------------------------------------
given-value(_?) |- no-given(X) ---> no-given(X')
Rule
no-given(U:T') ~> U
#### Mapping
/*
Maps on collection values can be expressed directly, e.g.,
`list(left-to-right-map(F, list-elements(L)))`.
*/
Funcon
left-to-right-map(_:T=>T', _:(T)*) : =>(T')*
/*
`left-to-right-map(F, V*)` computes `F` for each value in `V*` from left
to right, returning the sequence of resulting values.
*/
Rule
left-to-right-map(F, V:T, V*:(T)*)
~> left-to-right(give(V, F), left-to-right-map(F, V*))
Rule
left-to-right-map(_, ( )) ~> ( )
Funcon
interleave-map(_:T=>T', _:(T)*) : =>(T')*
/*
`interleave-map(F, V*)` computes `F` for each value in `V*` interleaved,
returning the sequence of resulting values.
*/
Rule
interleave-map(F, V:T, V*:(T)*)
~> interleave(give(V, F), interleave-map(F, V*))
Rule
interleave-map(_, ( )) ~> ( )
Funcon
left-to-right-repeat(_:integers=>T', _:integers, _:integers) : =>(T')*
/*
`left-to-right-repeat(F, M, N)` computes `F` for each value from `M` to `N`
sequentially, returning the sequence of resulting values.
*/
Rule
is-less-or-equal(M, N) == true
-------------------------------------------------------------------------
left-to-right-repeat(F, M:integers, N:integers)
~> left-to-right(give(M, F), left-to-right-repeat(F, int-add(M, 1), N))
Rule
is-less-or-equal(M, N) == false
----------------------------------------------
left-to-right-repeat(_, M:integers, N:integers) ~> ( )
Funcon
interleave-repeat(_:integers=>T', _:integers, _:integers) : =>(T')*
/*
`interleave-repeat(F, M, N)` computes `F` for each value from `M` to `N`
interleaved, returning the sequence of resulting values.
*/
Rule
is-less-or-equal(M, N) == true
-------------------------------------------------------------------
interleave-repeat(F, M:integers, N:integers)
~> interleave(give(M, F), interleave-repeat(F, int-add(M, 1), N))
Rule
is-less-or-equal(M, N) == false
-------------------------------------------
interleave-repeat(_, M:integers, N:integers) ~> ( )
#### Filtering
/*
Filters on collections of values can be expressed directly, e.g.,
`list(left-to-right-filter(P, list-elements(L)))` to filter a list `L`.
*/
Funcon
left-to-right-filter(_:T=>booleans, _:(T)*) : =>(T)*
/*
`left-to-right-filter(P, V*)` computes `P` for each value in `V*` from left
to right, returning the sequence of argument values for which the result is
`true`.
*/
Rule
left-to-right-filter(P, V:T, V*:(T)*)
~> left-to-right(when-true(give(V, P), V), left-to-right-filter(P, V*))
Rule
left-to-right-filter(_) ~> ( )
Funcon
interleave-filter(_:T=>booleans, _:(T)*) : =>(T)*
/*
`interleave-filter(P, V*)` computes `P` for each value in `V*` interleaved,
returning the sequence of argument values for which the result is `true`.
*/
Rule
interleave-filter(P, V:T, V*:(T)*)
~> interleave(when-true(give(V, P), V), interleave-filter(P, V*))
Rule
interleave-filter(_) ~> ( )
#### Folding
Funcon
fold-left(_:tuples(T,T')=>T, _:T, _:(T')*) : =>T
/*
`fold-left(F, A, V*)` reduces a sequence `V*` to a single value by folding it
from the left, using `A` as the initial accumulator value, and iteratively
updating the accumulator by giving `F` the pair of the accumulator value and
the first of the remaining arguments.
*/
Rule
fold-left(_, A:T, ( )) ~> A
Rule
fold-left(F, A:T, V:T', V*:(T')*) ~> fold-left(F, give(tuple(A, V), F), V*)
Funcon
fold-right(_:tuples(T,T')=>T', _:T', _:(T)*) : =>T'
/*
`fold-right(F, A, V*)` reduces a sequence `V*` to a single value by folding it
from the right, using `A` as the initial accumulator value, and iteratively
updating the accumulator by giving `F` the pair of the the last of the
remaining arguments and the accumulator value.
*/
Rule
fold-right(_, A:T', ( )) ~> A
Rule
fold-right(F, A:T', V*:(T)*, V:T) ~> give(tuple(V, fold-right(F, A, V*)), F)

260
IBAF-cbs/Funcons-beta/Computations/Normal/Giving/index.md Normal file
View File

@@ -0,0 +1,260 @@
---
layout: default
title: "Giving"
parent: Normal
ancestor: Funcons-beta
---
[Funcons-beta] : [Giving.cbs]
-----------------------------
### Giving
<div class="highlighter-rouge"><pre class="highlight"><code>[
<i class="keyword">Entity</i> <span class="name"><a href="#Name_given-value">given-value</a></span>
<i class="keyword">Funcon</i> <span class="name"><a href="#Name_initialise-giving">initialise-giving</a></span>
<i class="keyword">Funcon</i> <span class="name"><a href="#Name_give">give</a></span>
<i class="keyword">Funcon</i> <span class="name"><a href="#Name_given">given</a></span>
<i class="keyword">Funcon</i> <span class="name"><a href="#Name_no-given">no-given</a></span>
<i class="keyword">Funcon</i> <span class="name"><a href="#Name_left-to-right-map">left-to-right-map</a></span>
<i class="keyword">Funcon</i> <span class="name"><a href="#Name_interleave-map">interleave-map</a></span>
<i class="keyword">Funcon</i> <span class="name"><a href="#Name_left-to-right-repeat">left-to-right-repeat</a></span>
<i class="keyword">Funcon</i> <span class="name"><a href="#Name_interleave-repeat">interleave-repeat</a></span>
<i class="keyword">Funcon</i> <span class="name"><a href="#Name_left-to-right-filter">left-to-right-filter</a></span>
<i class="keyword">Funcon</i> <span class="name"><a href="#Name_interleave-filter">interleave-filter</a></span>
<i class="keyword">Funcon</i> <span class="name"><a href="#Name_fold-left">fold-left</a></span>
<i class="keyword">Funcon</i> <span class="name"><a href="#Name_fold-right">fold-right</a></span>
]</code></pre></div>
<div class="highlighter-rouge"><pre class="highlight"><code><i class="keyword">Meta-variables</i>
<span id="PartVariable_T"><i class="var">T</i></span>, <span id="PartVariable_T'"><i class="var">T&prime;</i></span> <: <span class="name"><a href="../../../Values/Value-Types/index.html#Name_values">values</a></span>
<span id="PartVariable_T?"><i class="var">T<sup class="sup">?</sup></i></span> <: <span class="name"><a href="../../../Values/Value-Types/index.html#Name_values">values</a></span><sup class="sup">?</sup></code></pre></div>
<div class="highlighter-rouge"><pre class="highlight"><code><i class="keyword">Entity</i>
<span class="ent-name"><span id="Name_given-value">given-value</span></span>(_:<span class="name"><a href="../../../Values/Value-Types/index.html#Name_values">values</a></span><sup class="sup">?</sup>) |- _ ---> _</code></pre></div>
The given-value entity allows a computation to refer to a single
previously-computed <code><i class="var">V</i>:<span class="name"><a href="../../../Values/Value-Types/index.html#Name_values">values</a></span></code>. The given value <code>( )</code> represents
the absence of a current given value.
<div class="highlighter-rouge"><pre class="highlight"><code><i class="keyword">Funcon</i>
<span class="name"><span id="Name_initialise-giving">initialise-giving</span></span>(<span id="Variable146_X"><i class="var">X</i></span>:( )=><span id="Variable156_T'"><i class="var">T&prime;</i></span>) : ( )=><span id="Variable176_T'"><i class="var">T&prime;</i></span>
~> <span class="name"><a href="#Name_no-given">no-given</a></span>(<a href="#Variable146_X"><i class="var">X</i></a>)</code></pre></div>
<code><span class="name"><a href="#Name_initialise-giving">initialise-giving</a></span>(<i class="var">X</i>)</code> ensures that the entities used by the funcons for
giving are properly initialised.
<div class="highlighter-rouge"><pre class="highlight"><code><i class="keyword">Funcon</i>
<span class="name"><span id="Name_give">give</span></span>(_:<span id="Variable227_T"><i class="var">T</i></span>, _:<span id="Variable238_T"><i class="var">T</i></span>=><span id="Variable245_T'"><i class="var">T&prime;</i></span>) : =><span id="Variable262_T'"><i class="var">T&prime;</i></span></code></pre></div>
<code><span class="name"><a href="#Name_give">give</a></span>(<i class="var">X</i>, <i class="var">Y</i>)</code> executes <code><i class="var">X</i></code>, possibly referring to the current <code><span class="name"><a href="#Name_given">given</a></span></code> value,
to compute a value <code><i class="var">V</i></code>. It then executes <code><i class="var">Y</i></code> with <code><i class="var">V</i></code> as the <code><span class="name"><a href="#Name_given">given</a></span></code> value,
to compute the result.
<div class="highlighter-rouge"><pre class="highlight"><code><i class="keyword">Rule</i>
<span class="ent-name"><a href="#Name_given-value">given-value</a></span>(<a href="#Variable429_V"><i class="var">V</i></a>) |- <a href="#Variable440_Y"><i class="var">Y</i></a> ---> <span id="Variable400_Y'"><i class="var">Y&prime;</i></span>
------------------------------------------------
<span class="ent-name"><a href="#Name_given-value">given-value</a></span>(_?) |- <span class="name"><a href="#Name_give">give</a></span>(<span id="Variable429_V"><i class="var">V</i></span>:<i class="var">T</i>, <span id="Variable440_Y"><i class="var">Y</i></span>) ---> <span class="name"><a href="#Name_give">give</a></span>(<a href="#Variable429_V"><i class="var">V</i></a>, <a href="#Variable400_Y'"><i class="var">Y&prime;</i></a>)
<i class="keyword">Rule</i>
<span class="name"><a href="#Name_give">give</a></span>(_:<i class="var">T</i>, <span id="Variable489_W"><i class="var">W</i></span>:<i class="var">T&prime;</i>) ~> <a href="#Variable489_W"><i class="var">W</i></a></code></pre></div>
<div class="highlighter-rouge"><pre class="highlight"><code><i class="keyword">Funcon</i>
<span class="name"><span id="Name_given">given</span></span> : <span id="Variable518_T"><i class="var">T</i></span>=><span id="Variable524_T"><i class="var">T</i></span></code></pre></div>
<code><span class="name"><a href="#Name_given">given</a></span></code> refers to the current given value.
<div class="highlighter-rouge"><pre class="highlight"><code><i class="keyword">Rule</i>
<span class="ent-name"><a href="#Name_given-value">given-value</a></span>(<span id="Variable549_V"><i class="var">V</i></span>:<span class="name"><a href="../../../Values/Value-Types/index.html#Name_values">values</a></span>) |- <span class="name"><a href="#Name_given">given</a></span> ---> <a href="#Variable549_V"><i class="var">V</i></a>
<i class="keyword">Rule</i>
<span class="ent-name"><a href="#Name_given-value">given-value</a></span>( ) |- <span class="name"><a href="#Name_given">given</a></span> ---> <span class="name"><a href="../../Abnormal/Failing/index.html#Name_fail">fail</a></span></code></pre></div>
<div class="highlighter-rouge"><pre class="highlight"><code><i class="keyword">Funcon</i>
<span class="name"><span id="Name_no-given">no-given</span></span>(_:( )=><span id="Variable614_T'"><i class="var">T&prime;</i></span>) : ( )=><span id="Variable634_T'"><i class="var">T&prime;</i></span></code></pre></div>
<code><span class="name"><a href="#Name_no-given">no-given</a></span>(<i class="var">X</i>)</code> computes <code><i class="var">X</i></code> without references to the current given value.
<div class="highlighter-rouge"><pre class="highlight"><code><i class="keyword">Rule</i>
<span class="ent-name"><a href="#Name_given-value">given-value</a></span>( ) |- <a href="#Variable730_X"><i class="var">X</i></a> ---> <span id="Variable701_X'"><i class="var">X&prime;</i></span>
------------------------------------------------
<span class="ent-name"><a href="#Name_given-value">given-value</a></span>(_?) |- <span class="name"><a href="#Name_no-given">no-given</a></span>(<span id="Variable730_X"><i class="var">X</i></span>) ---> <span class="name"><a href="#Name_no-given">no-given</a></span>(<a href="#Variable701_X'"><i class="var">X&prime;</i></a>)
<i class="keyword">Rule</i>
<span class="name"><a href="#Name_no-given">no-given</a></span>(<span id="Variable762_U"><i class="var">U</i></span>:<i class="var">T&prime;</i>) ~> <a href="#Variable762_U"><i class="var">U</i></a></code></pre></div>
#### Mapping
Maps on collection values can be expressed directly, e.g.,
<code><span class="name"><a href="../../../Values/Composite/Lists/index.html#Name_list">list</a></span>(<span class="name"><a href="#Name_left-to-right-map">left-to-right-map</a></span>(<i class="var">F</i>, <span class="name"><a href="../../../Values/Composite/Lists/index.html#Name_list-elements">list-elements</a></span>(<i class="var">L</i>)))</code>.
<div class="highlighter-rouge"><pre class="highlight"><code><i class="keyword">Funcon</i>
<span class="name"><span id="Name_left-to-right-map">left-to-right-map</span></span>(_:<span id="Variable860_T"><i class="var">T</i></span>=><span id="Variable867_T'"><i class="var">T&prime;</i></span>, _:(<span id="Variable879_T"><i class="var">T</i></span>)<sup class="sup">*</sup>) : =>(<span id="Variable902_T'"><i class="var">T&prime;</i></span>)<sup class="sup">*</sup></code></pre></div>
<code><span class="name"><a href="#Name_left-to-right-map">left-to-right-map</a></span>(<i class="var">F</i>, <i class="var">V<sup class="sup">*</sup></i>)</code> computes <code><i class="var">F</i></code> for each value in <code><i class="var">V<sup class="sup">*</sup></i></code> from left
to right, returning the sequence of resulting values.
<div class="highlighter-rouge"><pre class="highlight"><code><i class="keyword">Rule</i>
<span class="name"><a href="#Name_left-to-right-map">left-to-right-map</a></span>(<span id="Variable978_F"><i class="var">F</i></span>, <span id="Variable983_V"><i class="var">V</i></span>:<i class="var">T</i>, <span id="Variable995_V*"><i class="var">V<sup class="sup">*</sup></i></span>:(<i class="var">T</i>)<sup class="sup">*</sup>)
~> <span class="name"><a href="../Flowing/index.html#Name_left-to-right">left-to-right</a></span>(<span class="name"><a href="#Name_give">give</a></span>(<a href="#Variable983_V"><i class="var">V</i></a>, <a href="#Variable978_F"><i class="var">F</i></a>), <span class="name"><a href="#Name_left-to-right-map">left-to-right-map</a></span>(<a href="#Variable978_F"><i class="var">F</i></a>, <a href="#Variable995_V*"><i class="var">V<sup class="sup">*</sup></i></a>))
<i class="keyword">Rule</i>
<span class="name"><a href="#Name_left-to-right-map">left-to-right-map</a></span>(_, ( )) ~> ( )</code></pre></div>
<div class="highlighter-rouge"><pre class="highlight"><code><i class="keyword">Funcon</i>
<span class="name"><span id="Name_interleave-map">interleave-map</span></span>(_:<span id="Variable1096_T"><i class="var">T</i></span>=><span id="Variable1103_T'"><i class="var">T&prime;</i></span>, _:(<span id="Variable1115_T"><i class="var">T</i></span>)<sup class="sup">*</sup>) : =>(<span id="Variable1138_T'"><i class="var">T&prime;</i></span>)<sup class="sup">*</sup></code></pre></div>
<code><span class="name"><a href="#Name_interleave-map">interleave-map</a></span>(<i class="var">F</i>, <i class="var">V<sup class="sup">*</sup></i>)</code> computes <code><i class="var">F</i></code> for each value in <code><i class="var">V<sup class="sup">*</sup></i></code> interleaved,
returning the sequence of resulting values.
<div class="highlighter-rouge"><pre class="highlight"><code><i class="keyword">Rule</i>
<span class="name"><a href="#Name_interleave-map">interleave-map</a></span>(<span id="Variable1214_F"><i class="var">F</i></span>, <span id="Variable1219_V"><i class="var">V</i></span>:<i class="var">T</i>, <span id="Variable1231_V*"><i class="var">V<sup class="sup">*</sup></i></span>:(<i class="var">T</i>)<sup class="sup">*</sup>)
~> <span class="name"><a href="../Flowing/index.html#Name_interleave">interleave</a></span>(<span class="name"><a href="#Name_give">give</a></span>(<a href="#Variable1219_V"><i class="var">V</i></a>, <a href="#Variable1214_F"><i class="var">F</i></a>), <span class="name"><a href="#Name_interleave-map">interleave-map</a></span>(<a href="#Variable1214_F"><i class="var">F</i></a>, <a href="#Variable1231_V*"><i class="var">V<sup class="sup">*</sup></i></a>))
<i class="keyword">Rule</i>
<span class="name"><a href="#Name_interleave-map">interleave-map</a></span>(_, ( )) ~> ( )</code></pre></div>
<div class="highlighter-rouge"><pre class="highlight"><code><i class="keyword">Funcon</i>
<span class="name"><span id="Name_left-to-right-repeat">left-to-right-repeat</span></span>(_:<span class="name"><a href="../../../Values/Primitive/Integers/index.html#Name_integers">integers</a></span>=><span id="Variable1336_T'"><i class="var">T&prime;</i></span>, _:<span class="name"><a href="../../../Values/Primitive/Integers/index.html#Name_integers">integers</a></span>, _:<span class="name"><a href="../../../Values/Primitive/Integers/index.html#Name_integers">integers</a></span>) : =>(<span id="Variable1370_T'"><i class="var">T&prime;</i></span>)<sup class="sup">*</sup></code></pre></div>
<code><span class="name"><a href="#Name_left-to-right-repeat">left-to-right-repeat</a></span>(<i class="var">F</i>, <i class="var">M</i>, <i class="var">N</i>)</code> computes <code><i class="var">F</i></code> for each value from <code><i class="var">M</i></code> to <code><i class="var">N</i></code>
sequentially, returning the sequence of resulting values.
<div class="highlighter-rouge"><pre class="highlight"><code><i class="keyword">Rule</i>
<span class="name"><a href="../../../Values/Primitive/Integers/index.html#Name_is-less-or-equal">is-less-or-equal</a></span>(<a href="#Variable1493_M"><i class="var">M</i></a>, <a href="#Variable1501_N"><i class="var">N</i></a>) == <span class="name"><a href="../../../Values/Primitive/Booleans/index.html#Name_true">true</a></span>
-------------------------------------------------------------------------
<span class="name"><a href="#Name_left-to-right-repeat">left-to-right-repeat</a></span>(<span id="Variable1488_F"><i class="var">F</i></span>, <span id="Variable1493_M"><i class="var">M</i></span>:<span class="name"><a href="../../../Values/Primitive/Integers/index.html#Name_integers">integers</a></span>, <span id="Variable1501_N"><i class="var">N</i></span>:<span class="name"><a href="../../../Values/Primitive/Integers/index.html#Name_integers">integers</a></span>)
~> <span class="name"><a href="../Flowing/index.html#Name_left-to-right">left-to-right</a></span>(<span class="name"><a href="#Name_give">give</a></span>(<a href="#Variable1493_M"><i class="var">M</i></a>, <a href="#Variable1488_F"><i class="var">F</i></a>), <span class="name"><a href="#Name_left-to-right-repeat">left-to-right-repeat</a></span>(<a href="#Variable1488_F"><i class="var">F</i></a>, <span class="name"><a href="../../../Values/Primitive/Integers/index.html#Name_int-add">int-add</a></span>(<a href="#Variable1493_M"><i class="var">M</i></a>, 1), <a href="#Variable1501_N"><i class="var">N</i></a>))
<i class="keyword">Rule</i>
<span class="name"><a href="../../../Values/Primitive/Integers/index.html#Name_is-less-or-equal">is-less-or-equal</a></span>(<a href="#Variable1610_M"><i class="var">M</i></a>, <a href="#Variable1618_N"><i class="var">N</i></a>) == <span class="name"><a href="../../../Values/Primitive/Booleans/index.html#Name_false">false</a></span>
----------------------------------------------
<span class="name"><a href="#Name_left-to-right-repeat">left-to-right-repeat</a></span>(_, <span id="Variable1610_M"><i class="var">M</i></span>:<span class="name"><a href="../../../Values/Primitive/Integers/index.html#Name_integers">integers</a></span>, <span id="Variable1618_N"><i class="var">N</i></span>:<span class="name"><a href="../../../Values/Primitive/Integers/index.html#Name_integers">integers</a></span>) ~> ( )</code></pre></div>
<div class="highlighter-rouge"><pre class="highlight"><code><i class="keyword">Funcon</i>
<span class="name"><span id="Name_interleave-repeat">interleave-repeat</span></span>(_:<span class="name"><a href="../../../Values/Primitive/Integers/index.html#Name_integers">integers</a></span>=><span id="Variable1649_T'"><i class="var">T&prime;</i></span>, _:<span class="name"><a href="../../../Values/Primitive/Integers/index.html#Name_integers">integers</a></span>, _:<span class="name"><a href="../../../Values/Primitive/Integers/index.html#Name_integers">integers</a></span>) : =>(<span id="Variable1683_T'"><i class="var">T&prime;</i></span>)<sup class="sup">*</sup></code></pre></div>
<code><span class="name"><a href="#Name_interleave-repeat">interleave-repeat</a></span>(<i class="var">F</i>, <i class="var">M</i>, <i class="var">N</i>)</code> computes <code><i class="var">F</i></code> for each value from <code><i class="var">M</i></code> to <code><i class="var">N</i></code>
interleaved, returning the sequence of resulting values.
<div class="highlighter-rouge"><pre class="highlight"><code><i class="keyword">Rule</i>
<span class="name"><a href="../../../Values/Primitive/Integers/index.html#Name_is-less-or-equal">is-less-or-equal</a></span>(<a href="#Variable1806_M"><i class="var">M</i></a>, <a href="#Variable1814_N"><i class="var">N</i></a>) == <span class="name"><a href="../../../Values/Primitive/Booleans/index.html#Name_true">true</a></span>
-------------------------------------------------------------------
<span class="name"><a href="#Name_interleave-repeat">interleave-repeat</a></span>(<span id="Variable1801_F"><i class="var">F</i></span>, <span id="Variable1806_M"><i class="var">M</i></span>:<span class="name"><a href="../../../Values/Primitive/Integers/index.html#Name_integers">integers</a></span>, <span id="Variable1814_N"><i class="var">N</i></span>:<span class="name"><a href="../../../Values/Primitive/Integers/index.html#Name_integers">integers</a></span>)
~> <span class="name"><a href="../Flowing/index.html#Name_interleave">interleave</a></span>(<span class="name"><a href="#Name_give">give</a></span>(<a href="#Variable1806_M"><i class="var">M</i></a>, <a href="#Variable1801_F"><i class="var">F</i></a>), <span class="name"><a href="#Name_interleave-repeat">interleave-repeat</a></span>(<a href="#Variable1801_F"><i class="var">F</i></a>, <span class="name"><a href="../../../Values/Primitive/Integers/index.html#Name_int-add">int-add</a></span>(<a href="#Variable1806_M"><i class="var">M</i></a>, 1), <a href="#Variable1814_N"><i class="var">N</i></a>))
<i class="keyword">Rule</i>
<span class="name"><a href="../../../Values/Primitive/Integers/index.html#Name_is-less-or-equal">is-less-or-equal</a></span>(<a href="#Variable1923_M"><i class="var">M</i></a>, <a href="#Variable1931_N"><i class="var">N</i></a>) == <span class="name"><a href="../../../Values/Primitive/Booleans/index.html#Name_false">false</a></span>
-------------------------------------------
<span class="name"><a href="#Name_interleave-repeat">interleave-repeat</a></span>(_, <span id="Variable1923_M"><i class="var">M</i></span>:<span class="name"><a href="../../../Values/Primitive/Integers/index.html#Name_integers">integers</a></span>, <span id="Variable1931_N"><i class="var">N</i></span>:<span class="name"><a href="../../../Values/Primitive/Integers/index.html#Name_integers">integers</a></span>) ~> ( )</code></pre></div>
#### Filtering
Filters on collections of values can be expressed directly, e.g.,
<code><span class="name"><a href="../../../Values/Composite/Lists/index.html#Name_list">list</a></span>(<span class="name"><a href="#Name_left-to-right-filter">left-to-right-filter</a></span>(<i class="var">P</i>, <span class="name"><a href="../../../Values/Composite/Lists/index.html#Name_list-elements">list-elements</a></span>(<i class="var">L</i>)))</code> to filter a list <code><i class="var">L</i></code>.
<div class="highlighter-rouge"><pre class="highlight"><code><i class="keyword">Funcon</i>
<span class="name"><span id="Name_left-to-right-filter">left-to-right-filter</span></span>(_:<span id="Variable2042_T"><i class="var">T</i></span>=><span class="name"><a href="../../../Values/Primitive/Booleans/index.html#Name_booleans">booleans</a></span>, _:(<span id="Variable2057_T"><i class="var">T</i></span>)<sup class="sup">*</sup>) : =>(<span id="Variable2079_T"><i class="var">T</i></span>)<sup class="sup">*</sup></code></pre></div>
<code><span class="name"><a href="#Name_left-to-right-filter">left-to-right-filter</a></span>(<i class="var">P</i>, <i class="var">V<sup class="sup">*</sup></i>)</code> computes <code><i class="var">P</i></code> for each value in <code><i class="var">V<sup class="sup">*</sup></i></code> from left
to right, returning the sequence of argument values for which the result is
<code><span class="name"><a href="../../../Values/Primitive/Booleans/index.html#Name_true">true</a></span></code>.
<div class="highlighter-rouge"><pre class="highlight"><code><i class="keyword">Rule</i>
<span class="name"><a href="#Name_left-to-right-filter">left-to-right-filter</a></span>(<span id="Variable2165_P"><i class="var">P</i></span>, <span id="Variable2170_V"><i class="var">V</i></span>:<i class="var">T</i>, <span id="Variable2182_V*"><i class="var">V<sup class="sup">*</sup></i></span>:(<i class="var">T</i>)<sup class="sup">*</sup>)
~> <span class="name"><a href="../Flowing/index.html#Name_left-to-right">left-to-right</a></span>(<span class="name"><a href="../../../Values/Value-Types/index.html#Name_when-true">when-true</a></span>(<span class="name"><a href="#Name_give">give</a></span>(<a href="#Variable2170_V"><i class="var">V</i></a>, <a href="#Variable2165_P"><i class="var">P</i></a>), <a href="#Variable2170_V"><i class="var">V</i></a>), <span class="name"><a href="#Name_left-to-right-filter">left-to-right-filter</a></span>(<a href="#Variable2165_P"><i class="var">P</i></a>, <a href="#Variable2182_V*"><i class="var">V<sup class="sup">*</sup></i></a>))
<i class="keyword">Rule</i>
<span class="name"><a href="#Name_left-to-right-filter">left-to-right-filter</a></span>(_) ~> ( )</code></pre></div>
<div class="highlighter-rouge"><pre class="highlight"><code><i class="keyword">Funcon</i>
<span class="name"><span id="Name_interleave-filter">interleave-filter</span></span>(_:<span id="Variable2291_T"><i class="var">T</i></span>=><span class="name"><a href="../../../Values/Primitive/Booleans/index.html#Name_booleans">booleans</a></span>, _:(<span id="Variable2306_T"><i class="var">T</i></span>)<sup class="sup">*</sup>) : =>(<span id="Variable2328_T"><i class="var">T</i></span>)<sup class="sup">*</sup></code></pre></div>
<code><span class="name"><a href="#Name_interleave-filter">interleave-filter</a></span>(<i class="var">P</i>, <i class="var">V<sup class="sup">*</sup></i>)</code> computes <code><i class="var">P</i></code> for each value in <code><i class="var">V<sup class="sup">*</sup></i></code> interleaved,
returning the sequence of argument values for which the result is <code><span class="name"><a href="../../../Values/Primitive/Booleans/index.html#Name_true">true</a></span></code>.
<div class="highlighter-rouge"><pre class="highlight"><code><i class="keyword">Rule</i>
<span class="name"><a href="#Name_interleave-filter">interleave-filter</a></span>(<span id="Variable2414_P"><i class="var">P</i></span>, <span id="Variable2419_V"><i class="var">V</i></span>:<i class="var">T</i>, <span id="Variable2431_V*"><i class="var">V<sup class="sup">*</sup></i></span>:(<i class="var">T</i>)<sup class="sup">*</sup>)
~> <span class="name"><a href="../Flowing/index.html#Name_interleave">interleave</a></span>(<span class="name"><a href="../../../Values/Value-Types/index.html#Name_when-true">when-true</a></span>(<span class="name"><a href="#Name_give">give</a></span>(<a href="#Variable2419_V"><i class="var">V</i></a>, <a href="#Variable2414_P"><i class="var">P</i></a>), <a href="#Variable2419_V"><i class="var">V</i></a>), <span class="name"><a href="#Name_interleave-filter">interleave-filter</a></span>(<a href="#Variable2414_P"><i class="var">P</i></a>, <a href="#Variable2431_V*"><i class="var">V<sup class="sup">*</sup></i></a>))
<i class="keyword">Rule</i>
<span class="name"><a href="#Name_interleave-filter">interleave-filter</a></span>(_) ~> ( )</code></pre></div>
#### Folding
<div class="highlighter-rouge"><pre class="highlight"><code><i class="keyword">Funcon</i>
<span class="name"><span id="Name_fold-left">fold-left</span></span>(_:<span class="name"><a href="../../../Values/Composite/Tuples/index.html#Name_tuples">tuples</a></span>(<span id="Variable2558_T"><i class="var">T</i></span>,<span id="Variable2564_T'"><i class="var">T&prime;</i></span>)=><span id="Variable2577_T"><i class="var">T</i></span>, _:<span id="Variable2589_T"><i class="var">T</i></span>, _:(<span id="Variable2601_T'"><i class="var">T&prime;</i></span>)<sup class="sup">*</sup>) : =><span id="Variable2624_T"><i class="var">T</i></span></code></pre></div>
<code><span class="name"><a href="#Name_fold-left">fold-left</a></span>(<i class="var">F</i>, <i class="var">A</i>, <i class="var">V<sup class="sup">*</sup></i>)</code> reduces a sequence <code><i class="var">V<sup class="sup">*</sup></i></code> to a single value by folding it
from the left, using <code><i class="var">A</i></code> as the initial accumulator value, and iteratively
updating the accumulator by giving <code><i class="var">F</i></code> the pair of the accumulator value and
the first of the remaining arguments.
<div class="highlighter-rouge"><pre class="highlight"><code><i class="keyword">Rule</i>
<span class="name"><a href="#Name_fold-left">fold-left</a></span>(_, <span id="Variable2716_A"><i class="var">A</i></span>:<i class="var">T</i>, ( )) ~> <a href="#Variable2716_A"><i class="var">A</i></a>
<i class="keyword">Rule</i>
<span class="name"><a href="#Name_fold-left">fold-left</a></span>(<span id="Variable2748_F"><i class="var">F</i></span>, <span id="Variable2753_A"><i class="var">A</i></span>:<i class="var">T</i>, <span id="Variable2764_V"><i class="var">V</i></span>:<i class="var">T&prime;</i>, <span id="Variable2777_V*"><i class="var">V<sup class="sup">*</sup></i></span>:(<i class="var">T&prime;</i>)<sup class="sup">*</sup>) ~> <span class="name"><a href="#Name_fold-left">fold-left</a></span>(<a href="#Variable2748_F"><i class="var">F</i></a>, <span class="name"><a href="#Name_give">give</a></span>(<span class="name"><a href="../../../Values/Composite/Tuples/index.html#Name_tuple">tuple</a></span>(<a href="#Variable2753_A"><i class="var">A</i></a>, <a href="#Variable2764_V"><i class="var">V</i></a>), <a href="#Variable2748_F"><i class="var">F</i></a>), <a href="#Variable2777_V*"><i class="var">V<sup class="sup">*</sup></i></a>)</code></pre></div>
<div class="highlighter-rouge"><pre class="highlight"><code><i class="keyword">Funcon</i>
<span class="name"><span id="Name_fold-right">fold-right</span></span>(_:<span class="name"><a href="../../../Values/Composite/Tuples/index.html#Name_tuples">tuples</a></span>(<span id="Variable2864_T"><i class="var">T</i></span>,<span id="Variable2870_T'"><i class="var">T&prime;</i></span>)=><span id="Variable2884_T'"><i class="var">T&prime;</i></span>, _:<span id="Variable2897_T'"><i class="var">T&prime;</i></span>, _:(<span id="Variable2908_T"><i class="var">T</i></span>)<sup class="sup">*</sup>) : =><span id="Variable2932_T'"><i class="var">T&prime;</i></span></code></pre></div>
<code><span class="name"><a href="#Name_fold-right">fold-right</a></span>(<i class="var">F</i>, <i class="var">A</i>, <i class="var">V<sup class="sup">*</sup></i>)</code> reduces a sequence <code><i class="var">V<sup class="sup">*</sup></i></code> to a single value by folding it
from the right, using <code><i class="var">A</i></code> as the initial accumulator value, and iteratively
updating the accumulator by giving <code><i class="var">F</i></code> the pair of the the last of the
remaining arguments and the accumulator value.
<div class="highlighter-rouge"><pre class="highlight"><code><i class="keyword">Rule</i>
<span class="name"><a href="#Name_fold-right">fold-right</a></span>(_, <span id="Variable3024_A"><i class="var">A</i></span>:<i class="var">T&prime;</i>, ( )) ~> <a href="#Variable3024_A"><i class="var">A</i></a>
<i class="keyword">Rule</i>
<span class="name"><a href="#Name_fold-right">fold-right</a></span>(<span id="Variable3057_F"><i class="var">F</i></span>, <span id="Variable3062_A"><i class="var">A</i></span>:<i class="var">T&prime;</i>, <span id="Variable3075_V*"><i class="var">V<sup class="sup">*</sup></i></span>:(<i class="var">T</i>)<sup class="sup">*</sup>, <span id="Variable3093_V"><i class="var">V</i></span>:<i class="var">T</i>) ~> <span class="name"><a href="#Name_give">give</a></span>(<span class="name"><a href="../../../Values/Composite/Tuples/index.html#Name_tuple">tuple</a></span>(<a href="#Variable3093_V"><i class="var">V</i></a>, <span class="name"><a href="#Name_fold-right">fold-right</a></span>(<a href="#Variable3057_F"><i class="var">F</i></a>, <a href="#Variable3062_A"><i class="var">A</i></a>, <a href="#Variable3075_V*"><i class="var">V<sup class="sup">*</sup></i></a>)), <a href="#Variable3057_F"><i class="var">F</i></a>)</code></pre></div>
____
From the [PLanCompS Project] | [CBS-beta issues...] | [Suggest an improvement...]
[Giving.cbs]: Giving.cbs
"CBS SOURCE FILE"
[Funcons-beta]: /CBS-beta/docs/Funcons-beta
"FUNCONS-BETA"
[Unstable-Funcons-beta]: /CBS-beta/docs/Unstable-Funcons-beta
"UNSTABLE-FUNCONS-BETA"
[Languages-beta]: /CBS-beta/docs/Languages-beta
"LANGUAGES-BETA"
[Unstable-Languages-beta]: /CBS-beta/docs/Unstable-Languages-beta
"UNSTABLE-LANGUAGES-BETA"
[CBS-beta]: /CBS-beta "CBS-BETA"
[PLanCompS Project]: https://plancomps.github.io
"PROGRAMMING LANGUAGE COMPONENTS AND SPECIFICATIONS PROJECT HOME PAGE"
[CBS-beta issues...]: https://github.com/plancomps/CBS-beta/issues
"CBS-BETA ISSUE REPORTS ON GITHUB"
[Suggest an improvement...]: mailto:plancomps@gmail.com?Subject=CBS-beta%20-%20comment&Body=Re%3A%20CBS-beta%20specification%20at%20Computations/Normal/Giving/Giving.cbs%0A%0AComment/Query/Issue/Suggestion%3A%0A%0A%0ASignature%3A%0A
"GENERATE AN EMAIL TEMPLATE"

15
IBAF-cbs/Funcons-beta/Computations/Normal/Giving/tests/fold-left.config Normal file
View File

@@ -0,0 +1,15 @@
general {
funcon-term:
initialise-giving
sequential(
print [ fold-left(fail, 1, ( )) ],
fold-left(
sequential(print given, given),
1, 2, 3))
;
}
tests {
result-term: tuple(tuple(1,2),3);
standard-out: [ [ 1 ], tuple(1,2), tuple(tuple(1,2),3) ];
}

15
IBAF-cbs/Funcons-beta/Computations/Normal/Giving/tests/fold-right.config Normal file
View File

@@ -0,0 +1,15 @@
general {
funcon-term:
initialise-giving
sequential(
print [ fold-right(fail, 1, ( )) ],
fold-right(
sequential(print given, given),
1, 2, 3))
;
}
tests {
result-term: tuple(3,tuple(2,1));
standard-out: [ [ 1 ], tuple(2,1), tuple(3,tuple(2,1)) ];
}

18
IBAF-cbs/Funcons-beta/Computations/Normal/Giving/tests/give.config Normal file
View File

@@ -0,0 +1,18 @@
general {
funcon-term:
initialise-giving
give(
sequential(
print 1,
2),
sequential(
print given,
give(3, print given),
print integer-add(given,2)))
;
}
tests {
result-term: null-value;
standard-out: [1, 2, 3, 4];
}

21
IBAF-cbs/Funcons-beta/Computations/Normal/Giving/tests/interleave-filter.config Normal file
View File

@@ -0,0 +1,21 @@
general {
funcon-term:
initialise-giving
sequential(
print [ interleave-filter(true, ( )) ],
tuple interleave-filter(
sequential(print given, is-less(given,3)),
1, 2, 3))
;
}
tests {
result-term: tuple(1, 2);
standard-out: [ [ ], 1, 2, 3 ];
//Also:
// standard-out: [ [ ], 1, 3, 2 ];
// standard-out: [ [ ], 2, 1, 3 ];
// standard-out: [ [ ], 2, 3, 1 ];
// standard-out: [ [ ], 3, 1, 2 ];
// standard-out: [ [ ], 3, 2, 1 ];
}

20
IBAF-cbs/Funcons-beta/Computations/Normal/Giving/tests/interleave-map.config Normal file
View File

@@ -0,0 +1,20 @@
general {
funcon-term:
initialise-giving
sequential(
print [ interleave-map(fail, ( )) ],
tuple interleave-map(
sequential(print integer-add(given,2), given),
sequential(print 1, 1),
sequential(print 2, 2)))
;
}
tests {
result-term: tuple(1, 2);
standard-out: [ [ ], 1, 2, 3, 4];
//Also:
// standard-out: [ [ ], 2, 1, 3, 4];
// standard-out: [ [ ], 1, 2, 4, 3];
// standard-out: [ [ ], 2, 1, 4, 3];
}

23
IBAF-cbs/Funcons-beta/Computations/Normal/Giving/tests/interleave-repeat.config Normal file
View File

@@ -0,0 +1,23 @@
general {
funcon-term:
initialise-giving
sequential(
print [ interleave-repeat(fail, 2, 1) ],
tuple interleave-repeat(
sequential(print integer-add(given,2), given),
sequential(print 1, 1),
sequential(print 2, 3)))
;
}
tests {
result-term: tuple(1, 2, 3);
standard-out: [ [ ], 1, 2, 3, 4, 5];
//Also:
// standard-out: [ [ ], ...., 3, 5, 4];
// standard-out: [ [ ], ...., 4, 3, 5];
// standard-out: [ [ ], ...., 4, 5, 3];
// standard-out: [ [ ], ...., 5, 3, 4];
// standard-out: [ [ ], ...., 5, 4, 3];
// standard-out: [ [ ], 2, 1, .......];
}

15
IBAF-cbs/Funcons-beta/Computations/Normal/Giving/tests/left-to-right-filter.config Normal file
View File

@@ -0,0 +1,15 @@
general {
funcon-term:
initialise-giving
sequential(
print [ left-to-right-filter(true, ( )) ],
tuple left-to-right-filter(
sequential(print given, is-less(given,42)),
42, 1, 43, 44, 2, 3, 45))
;
}
tests {
result-term: tuple(1, 2, 3);
standard-out: [ [ ], 42, 1, 43, 44, 2, 3, 45 ];
}

18
IBAF-cbs/Funcons-beta/Computations/Normal/Giving/tests/left-to-right-map.config Normal file
View File

@@ -0,0 +1,18 @@
general {
funcon-term:
initialise-giving
sequential(
print [ left-to-right-map(fail, ( )) ],
tuple left-to-right-map(
sequential(print integer-add(given,2), given),
sequential(print 1, 1),
sequential(print 2, 2)))
;
}
tests {
result-term: tuple(1, 2);
standard-out: [ [ ], 1, 2, 3, 4];
//Also:
// standard-out: [ [ ], 2, 1, 3, 4];
}

18
IBAF-cbs/Funcons-beta/Computations/Normal/Giving/tests/left-to-right-repeat.config Normal file
View File

@@ -0,0 +1,18 @@
general {
funcon-term:
initialise-giving
sequential(
print [ left-to-right-repeat(fail, 2, 1) ],
tuple left-to-right-repeat(
sequential(print integer-add(given,2), given),
sequential(print 1, 1),
sequential(print 2, 3)))
;
}
tests {
result-term: tuple(1, 2, 3);
standard-out: [ [ ], 1, 2, 3, 4, 5];
//Also:
// standard-out: [ [ ], 2, 1, 3, 4, 5];
}

16
IBAF-cbs/Funcons-beta/Computations/Normal/Giving/tests/no-given.config Normal file
View File

@@ -0,0 +1,16 @@
general {
funcon-term:
initialise-giving
give(
1,
no-given
else(
print given,
print"OK"))
;
}
tests {
result-term: null-value;
standard-out: ["OK"];
}

59
IBAF-cbs/Funcons-beta/Computations/Normal/Interacting/Interacting.cbs Normal file
View File

@@ -0,0 +1,59 @@
### Interacting
#### Output
[
Entity standard-out
Funcon print
]
Entity
_ -- standard-out!(_:values*) -> _
/*
This entity represents the sequence of values output by a particular
transition, where the empty sequence `( )` represents the lack of output.
Composition of transitions concatenates their output sequences.
*/
Funcon
print(_:values*) : =>null-type
/*
`print(X*)` evaluates the arguments `X*` and emits the resulting sequence of
values on the standard-out channel. `print( )` has no effect.
*/
Rule
print(V*:values*) -- standard-out!(V*) -> null-value
#### Input
[
Entity standard-in
Funcon read
]
Entity
_ -- standard-in?(_:values*) -> _
/*
This entity represents the sequence of values input by a particular
transition, where the empty sequence `( )` represents that no values are
input. The value `null-value` represents the end of the input.
Composition of transitions concatenates their input sequences, except that
when the first sequence ends with `null-value`, the second seqeunce has to be
just `null-value`.
*/
Funcon
read : =>values
/*
`read` inputs a single value from the standard-in channel, and returns it.
If the end of the input has been reached, `read` fails.
*/
Rule
read -- standard-in?(V:~null-type) -> V
Rule
read -- standard-in?(null-value) -> fail

99
IBAF-cbs/Funcons-beta/Computations/Normal/Interacting/index.md Normal file
View File

@@ -0,0 +1,99 @@
---
layout: default
title: "Interacting"
parent: Normal
ancestor: Funcons-beta
---
[Funcons-beta] : [Interacting.cbs]
-----------------------------
### Interacting
#### Output
<div class="highlighter-rouge"><pre class="highlight"><code>[
<i class="keyword">Entity</i> <span class="name"><a href="#Name_standard-out">standard-out</a></span>
<i class="keyword">Funcon</i> <span class="name"><a href="#Name_print">print</a></span>
]</code></pre></div>
<div class="highlighter-rouge"><pre class="highlight"><code><i class="keyword">Entity</i>
_ -- <span class="ent-name"><span id="Name_standard-out">standard-out</span></span>!(_:<span class="name"><a href="../../../Values/Value-Types/index.html#Name_values">values</a></span><sup class="sup">*</sup>) -> _</code></pre></div>
This entity represents the sequence of values output by a particular
transition, where the empty sequence <code>( )</code> represents the lack of output.
Composition of transitions concatenates their output sequences.
<div class="highlighter-rouge"><pre class="highlight"><code><i class="keyword">Funcon</i>
<span class="name"><span id="Name_print">print</span></span>(_:<span class="name"><a href="../../../Values/Value-Types/index.html#Name_values">values</a></span><sup class="sup">*</sup>) : =><span class="name"><a href="../../../Values/Primitive/Null/index.html#Name_null-type">null-type</a></span></code></pre></div>
<code><span class="name"><a href="#Name_print">print</a></span>(<i class="var">X<sup class="sup">*</sup></i>)</code> evaluates the arguments <code><i class="var">X<sup class="sup">*</sup></i></code> and emits the resulting sequence of
values on the standard-out channel. <code><span class="name"><a href="#Name_print">print</a></span>( )</code> has no effect.
<div class="highlighter-rouge"><pre class="highlight"><code><i class="keyword">Rule</i>
<span class="name"><a href="#Name_print">print</a></span>(<span id="Variable137_V*"><i class="var">V<sup class="sup">*</sup></i></span>:<span class="name"><a href="../../../Values/Value-Types/index.html#Name_values">values</a></span><sup class="sup">*</sup>) -- <span class="ent-name"><a href="#Name_standard-out">standard-out</a></span>!(<a href="#Variable137_V*"><i class="var">V<sup class="sup">*</sup></i></a>) -> <span class="name"><a href="../../../Values/Primitive/Null/index.html#Name_null-value">null-value</a></span></code></pre></div>
#### Input
<div class="highlighter-rouge"><pre class="highlight"><code>[
<i class="keyword">Entity</i> <span class="name"><a href="#Name_standard-in">standard-in</a></span>
<i class="keyword">Funcon</i> <span class="name"><a href="#Name_read">read</a></span>
]</code></pre></div>
<div class="highlighter-rouge"><pre class="highlight"><code><i class="keyword">Entity</i>
_ -- <span class="ent-name"><span id="Name_standard-in">standard-in</span></span>?(_:<span class="name"><a href="../../../Values/Value-Types/index.html#Name_values">values</a></span><sup class="sup">*</sup>) -> _</code></pre></div>
This entity represents the sequence of values input by a particular
transition, where the empty sequence <code>( )</code> represents that no values are
input. The value <code><span class="name"><a href="../../../Values/Primitive/Null/index.html#Name_null-value">null-value</a></span></code> represents the end of the input.
Composition of transitions concatenates their input sequences, except that
when the first sequence ends with <code><span class="name"><a href="../../../Values/Primitive/Null/index.html#Name_null-value">null-value</a></span></code>, the second seqeunce has to be
just <code><span class="name"><a href="../../../Values/Primitive/Null/index.html#Name_null-value">null-value</a></span></code>.
<div class="highlighter-rouge"><pre class="highlight"><code><i class="keyword">Funcon</i>
<span class="name"><span id="Name_read">read</span></span> : =><span class="name"><a href="../../../Values/Value-Types/index.html#Name_values">values</a></span></code></pre></div>
<code><span class="name"><a href="#Name_read">read</a></span></code> inputs a single value from the standard-in channel, and returns it.
If the end of the input has been reached, <code><span class="name"><a href="#Name_read">read</a></span></code> fails.
<div class="highlighter-rouge"><pre class="highlight"><code><i class="keyword">Rule</i>
<span class="name"><a href="#Name_read">read</a></span> -- <span class="ent-name"><a href="#Name_standard-in">standard-in</a></span>?(<span id="Variable309_V"><i class="var">V</i></span>:~<span class="name"><a href="../../../Values/Primitive/Null/index.html#Name_null-type">null-type</a></span>) -> <a href="#Variable309_V"><i class="var">V</i></a>
<i class="keyword">Rule</i>
<span class="name"><a href="#Name_read">read</a></span> -- <span class="ent-name"><a href="#Name_standard-in">standard-in</a></span>?(<span class="name"><a href="../../../Values/Primitive/Null/index.html#Name_null-value">null-value</a></span>) -> <span class="name"><a href="../../Abnormal/Failing/index.html#Name_fail">fail</a></span></code></pre></div>
____
From the [PLanCompS Project] | [CBS-beta issues...] | [Suggest an improvement...]
[Interacting.cbs]: Interacting.cbs
"CBS SOURCE FILE"
[Funcons-beta]: /CBS-beta/docs/Funcons-beta
"FUNCONS-BETA"
[Unstable-Funcons-beta]: /CBS-beta/docs/Unstable-Funcons-beta
"UNSTABLE-FUNCONS-BETA"
[Languages-beta]: /CBS-beta/docs/Languages-beta
"LANGUAGES-BETA"
[Unstable-Languages-beta]: /CBS-beta/docs/Unstable-Languages-beta
"UNSTABLE-LANGUAGES-BETA"
[CBS-beta]: /CBS-beta "CBS-BETA"
[PLanCompS Project]: https://plancomps.github.io
"PROGRAMMING LANGUAGE COMPONENTS AND SPECIFICATIONS PROJECT HOME PAGE"
[CBS-beta issues...]: https://github.com/plancomps/CBS-beta/issues
"CBS-BETA ISSUE REPORTS ON GITHUB"
[Suggest an improvement...]: mailto:plancomps@gmail.com?Subject=CBS-beta%20-%20comment&Body=Re%3A%20CBS-beta%20specification%20at%20Computations/Normal/Interacting/Interacting.cbs%0A%0AComment/Query/Issue/Suggestion%3A%0A%0A%0ASignature%3A%0A
"GENERATE AN EMAIL TEMPLATE"

12
IBAF-cbs/Funcons-beta/Computations/Normal/Interacting/tests/print-1.config Normal file
View File

@@ -0,0 +1,12 @@
general {
funcon-term:
sequential(
print( ),
print( list-elements list-nil ))
;
}
tests {
result-term: null-value;
standard-out: [ ];
}

14
IBAF-cbs/Funcons-beta/Computations/Normal/Interacting/tests/print-2.config Normal file
View File

@@ -0,0 +1,14 @@
general {
funcon-term:
sequential(
print 1,
print(2,3),
print true,
print(sequential(print tuple null-value, "OK")))
;
}
tests {
result-term: null-value;
standard-out: [ 1, 2, 3, true, tuple(null-value), "OK" ];
}

12
IBAF-cbs/Funcons-beta/Computations/Normal/Interacting/tests/read-1.config Normal file
View File

@@ -0,0 +1,12 @@
general {
funcon-term: print(reverse(read, read, read));
}
inputs {
standard-in: (1,2,3);
}
tests {
result-term: null-value;
standard-out: [3,2,1];
}

12
IBAF-cbs/Funcons-beta/Computations/Normal/Interacting/tests/read-2.config Normal file
View File

@@ -0,0 +1,12 @@
general {
funcon-term: print(read, else(read, "OK"));
}
inputs {
standard-in: 1;
}
tests {
result-term: null-value;
standard-out: [1, "OK"];
}

12
IBAF-cbs/Funcons-beta/Computations/Normal/Interacting/tests/read-3.config Normal file
View File

@@ -0,0 +1,12 @@
general {
funcon-term: print(read, read, else(read, "OK"));
}
inputs {
standard-in: (1,2);
}
tests {
result-term: null-value;
standard-out: [1, 2, "OK"];
}

67
IBAF-cbs/Funcons-beta/Computations/Normal/Linking/Linking.cbs Normal file
View File

@@ -0,0 +1,67 @@
### Linking
[
Datatype links
Funcon initialise-linking
Funcon link
Funcon fresh-link
Funcon fresh-initialised-link Alias fresh-init-link
Funcon set-link
Funcon follow-if-link
]
Meta-variables
T <: values
Datatype
links ::= link(_:variables)
Funcon
initialise-linking(X:=>T) : =>T
~> initialise-storing(X)
/*
`initialise-linking(X)` ensures that the entities used by the funcons for
linking are properly initialised.
*/
Funcon
fresh-link(T) : =>links
~> link(allocate-variable(T))
Funcon
fresh-initialised-link(T, V:T) : =>links
~> link(allocate-initialised-variable(T, V))
Alias
fresh-init-link = fresh-initialised-link
Funcon
set-link(_:links, _:T) : =>null-type
/*
The value of a link can be set only once.
*/
Rule
set-link(link(Var:variables), V:T) ~> initialise-variable(Var, V)
Funcon
follow-link(_:links) : =>values
Rule
follow-link(link(Var:variables)) ~> assigned(Var)
Funcon
follow-if-link(_:values) : =>values
/*
If `V` is a link, `follow-if-link(V)` computes the set value, and
otherwise it evaluates to `V`.
*/
Rule
follow-if-link(link(Var:variables)) ~> assigned(Var)
Rule
follow-if-link(V:~links) ~> V

106
IBAF-cbs/Funcons-beta/Computations/Normal/Linking/index.md Normal file
View File

@@ -0,0 +1,106 @@
---
layout: default
title: "Linking"
parent: Normal
ancestor: Funcons-beta
---
[Funcons-beta] : [Linking.cbs]
-----------------------------
### Linking
<div class="highlighter-rouge"><pre class="highlight"><code>[
<i class="keyword">Datatype</i> <span class="name"><a href="#Name_links">links</a></span>
<i class="keyword">Funcon</i> <span class="name"><a href="#Name_initialise-linking">initialise-linking</a></span>
<i class="keyword">Funcon</i> <span class="name"><a href="#Name_link">link</a></span>
<i class="keyword">Funcon</i> <span class="name"><a href="#Name_fresh-link">fresh-link</a></span>
<i class="keyword">Funcon</i> <span class="name"><a href="#Name_fresh-initialised-link">fresh-initialised-link</a></span> <i class="keyword">Alias</i> <span class="name"><a href="#Name_fresh-init-link">fresh-init-link</a></span>
<i class="keyword">Funcon</i> <span class="name"><a href="#Name_set-link">set-link</a></span>
<i class="keyword">Funcon</i> <span class="name"><a href="#Name_follow-if-link">follow-if-link</a></span>
]</code></pre></div>
<div class="highlighter-rouge"><pre class="highlight"><code><i class="keyword">Meta-variables</i>
<span id="PartVariable_T"><i class="var">T</i></span> <: <span class="name"><a href="../../../Values/Value-Types/index.html#Name_values">values</a></span></code></pre></div>
<div class="highlighter-rouge"><pre class="highlight"><code><i class="keyword">Datatype</i>
<span class="name"><span id="Name_links">links</span></span> ::= <span id="Name_link">link</span>(_:<span class="name"><a href="../Storing/index.html#Name_variables">variables</a></span>)</code></pre></div>
<div class="highlighter-rouge"><pre class="highlight"><code><i class="keyword">Funcon</i>
<span class="name"><span id="Name_initialise-linking">initialise-linking</span></span>(<span id="Variable84_X"><i class="var">X</i></span>:=><span id="Variable89_T"><i class="var">T</i></span>) : =><span id="Variable104_T"><i class="var">T</i></span>
~> <span class="name"><a href="../Storing/index.html#Name_initialise-storing">initialise-storing</a></span>(<a href="#Variable84_X"><i class="var">X</i></a>)</code></pre></div>
<code><span class="name"><a href="#Name_initialise-linking">initialise-linking</a></span>(<i class="var">X</i>)</code> ensures that the entities used by the funcons for
linking are properly initialised.
<div class="highlighter-rouge"><pre class="highlight"><code><i class="keyword">Funcon</i>
<span class="name"><span id="Name_fresh-link">fresh-link</span></span>(<span id="Variable152_T"><i class="var">T</i></span>) : =><span class="name"><a href="#Name_links">links</a></span>
~> <span class="name"><a href="#Name_link">link</a></span>(<span class="name"><a href="../Storing/index.html#Name_allocate-variable">allocate-variable</a></span>(<a href="#Variable152_T"><i class="var">T</i></a>))</code></pre></div>
<div class="highlighter-rouge"><pre class="highlight"><code><i class="keyword">Funcon</i>
<span class="name"><span id="Name_fresh-initialised-link">fresh-initialised-link</span></span>(<span id="Variable190_T"><i class="var">T</i></span>, <span id="Variable196_V"><i class="var">V</i></span>:<span id="Variable200_T"><i class="var">T</i></span>) : =><span class="name"><a href="#Name_links">links</a></span>
~> <span class="name"><a href="#Name_link">link</a></span>(<span class="name"><a href="../Storing/index.html#Name_allocate-initialised-variable">allocate-initialised-variable</a></span>(<i class="var">T</i>, <a href="#Variable196_V"><i class="var">V</i></a>))
<i class="keyword">Alias</i>
<span class="name"><span id="Name_fresh-init-link">fresh-init-link</span></span> = <span class="name"><a href="#Name_fresh-initialised-link">fresh-initialised-link</a></span></code></pre></div>
<div class="highlighter-rouge"><pre class="highlight"><code><i class="keyword">Funcon</i>
<span class="name"><span id="Name_set-link">set-link</span></span>(_:<span class="name"><a href="#Name_links">links</a></span>, _:<span id="Variable261_T"><i class="var">T</i></span>) : =><span class="name"><a href="../../../Values/Primitive/Null/index.html#Name_null-type">null-type</a></span></code></pre></div>
The value of a link can be set only once.
<div class="highlighter-rouge"><pre class="highlight"><code><i class="keyword">Rule</i>
<span class="name"><a href="#Name_set-link">set-link</a></span>(<span class="name"><a href="#Name_link">link</a></span>(<span id="Variable289_Var"><i class="var">Var</i></span>:<span class="name"><a href="../Storing/index.html#Name_variables">variables</a></span>), <span id="Variable303_V"><i class="var">V</i></span>:<i class="var">T</i>) ~> <span class="name"><a href="../Storing/index.html#Name_initialise-variable">initialise-variable</a></span>(<a href="#Variable289_Var"><i class="var">Var</i></a>, <a href="#Variable303_V"><i class="var">V</i></a>)</code></pre></div>
<div class="highlighter-rouge"><pre class="highlight"><code><i class="keyword">Funcon</i>
<span class="name"><span id="Name_follow-link">follow-link</span></span>(_:<span class="name"><a href="#Name_links">links</a></span>) : =><span class="name"><a href="../../../Values/Value-Types/index.html#Name_values">values</a></span>
<i class="keyword">Rule</i>
<span class="name"><a href="#Name_follow-link">follow-link</a></span>(<span class="name"><a href="#Name_link">link</a></span>(<span id="Variable364_Var"><i class="var">Var</i></span>:<span class="name"><a href="../Storing/index.html#Name_variables">variables</a></span>)) ~> <span class="name"><a href="../Storing/index.html#Name_assigned">assigned</a></span>(<a href="#Variable364_Var"><i class="var">Var</i></a>)</code></pre></div>
<div class="highlighter-rouge"><pre class="highlight"><code><i class="keyword">Funcon</i>
<span class="name"><span id="Name_follow-if-link">follow-if-link</span></span>(_:<span class="name"><a href="../../../Values/Value-Types/index.html#Name_values">values</a></span>) : =><span class="name"><a href="../../../Values/Value-Types/index.html#Name_values">values</a></span></code></pre></div>
If <code><i class="var">V</i></code> is a link, <code><span class="name"><a href="#Name_follow-if-link">follow-if-link</a></span>(<i class="var">V</i>)</code> computes the set value, and
otherwise it evaluates to <code><i class="var">V</i></code>.
<div class="highlighter-rouge"><pre class="highlight"><code><i class="keyword">Rule</i>
<span class="name"><a href="#Name_follow-if-link">follow-if-link</a></span>(<span class="name"><a href="#Name_link">link</a></span>(<span id="Variable473_Var"><i class="var">Var</i></span>:<span class="name"><a href="../Storing/index.html#Name_variables">variables</a></span>)) ~> <span class="name"><a href="../Storing/index.html#Name_assigned">assigned</a></span>(<a href="#Variable473_Var"><i class="var">Var</i></a>)
<i class="keyword">Rule</i>
<span class="name"><a href="#Name_follow-if-link">follow-if-link</a></span>(<span id="Variable509_V"><i class="var">V</i></span>:~<span class="name"><a href="#Name_links">links</a></span>) ~> <a href="#Variable509_V"><i class="var">V</i></a></code></pre></div>
____
From the [PLanCompS Project] | [CBS-beta issues...] | [Suggest an improvement...]
[Linking.cbs]: Linking.cbs
"CBS SOURCE FILE"
[Funcons-beta]: /CBS-beta/docs/Funcons-beta
"FUNCONS-BETA"
[Unstable-Funcons-beta]: /CBS-beta/docs/Unstable-Funcons-beta
"UNSTABLE-FUNCONS-BETA"
[Languages-beta]: /CBS-beta/docs/Languages-beta
"LANGUAGES-BETA"
[Unstable-Languages-beta]: /CBS-beta/docs/Unstable-Languages-beta
"UNSTABLE-LANGUAGES-BETA"
[CBS-beta]: /CBS-beta "CBS-BETA"
[PLanCompS Project]: https://plancomps.github.io
"PROGRAMMING LANGUAGE COMPONENTS AND SPECIFICATIONS PROJECT HOME PAGE"
[CBS-beta issues...]: https://github.com/plancomps/CBS-beta/issues
"CBS-BETA ISSUE REPORTS ON GITHUB"
[Suggest an improvement...]: mailto:plancomps@gmail.com?Subject=CBS-beta%20-%20comment&Body=Re%3A%20CBS-beta%20specification%20at%20Computations/Normal/Linking/Linking.cbs%0A%0AComment/Query/Issue/Suggestion%3A%0A%0A%0ASignature%3A%0A
"GENERATE AN EMAIL TEMPLATE"

20
IBAF-cbs/Funcons-beta/Computations/Normal/Linking/tests/follow-if-link.config Normal file
View File

@@ -0,0 +1,20 @@
general {
funcon-term:
initialise-linking
give(fresh-link(booleans),
sequential(
set-link(given, true),
if-true-else(
follow-if-link(given),
if-true-else(
is-equal(follow-if-link(42),42),
print"OK",
fail),
fail)))
;
}
tests {
result-term: null-value;
standard-out: ["OK"];
}

18
IBAF-cbs/Funcons-beta/Computations/Normal/Linking/tests/follow-link.config Normal file
View File

@@ -0,0 +1,18 @@
general {
funcon-term:
initialise-linking
give(fresh-link(booleans),
sequential(
set-link(given, true),
print"OK",
if-true-else(
follow-link(given),
print"OK",
fail)))
;
}
tests {
result-term: null-value;
standard-out: ["OK", "OK"];
}

10
IBAF-cbs/Funcons-beta/Computations/Normal/Linking/tests/fresh-initialised-link.config Normal file
View File

@@ -0,0 +1,10 @@
general {
funcon-term:
initialise-linking
not is-equal(fresh-initialised-link(integers,42), fresh-initialised-link(integers,42))
;
}
tests {
result-term: true;
}

10
IBAF-cbs/Funcons-beta/Computations/Normal/Linking/tests/fresh-link.config Normal file
View File

@@ -0,0 +1,10 @@
general {
funcon-term:
initialise-linking
not is-equal(fresh-link(values), fresh-link(values))
;
}
tests {
result-term: true;
}

10
IBAF-cbs/Funcons-beta/Computations/Normal/Linking/tests/initialise-linking.config Normal file
View File

@@ -0,0 +1,10 @@
general {
funcon-term:
initialise-linking(print"OK")
;
}
tests {
result-term: null-value;
standard-out: ["OK"];
}

10
IBAF-cbs/Funcons-beta/Computations/Normal/Linking/tests/links.config Normal file
View File

@@ -0,0 +1,10 @@
general {
funcon-term:
initialise-linking
is-in-type(link(allocate-variable(values)), links)
;
}
tests {
result-term: true;
}

17
IBAF-cbs/Funcons-beta/Computations/Normal/Linking/tests/set-link.config Normal file
View File

@@ -0,0 +1,17 @@
general {
funcon-term:
initialise-linking
give(fresh-link(booleans),
sequential(
set-link(given, true),
print"OK",
else(
set-link(given,false),
print"OK")))
;
}
tests {
result-term: null-value;
standard-out: ["OK", "OK"];
}

346
IBAF-cbs/Funcons-beta/Computations/Normal/Storing/Storing.cbs Normal file
View File

@@ -0,0 +1,346 @@
### Storing
[
Datatype locations Alias locs
Type stores
Entity store
Funcon initialise-storing
Funcon store-clear
Datatype variables Alias vars
Funcon variable Alias var
Funcon allocate-variable Alias alloc
Funcon recycle-variables Alias recycle
Funcon initialise-variable Alias init
Funcon allocate-initialised-variable Alias alloc-init
Funcon assign
Funcon assigned
Funcon current-value
Funcon un-assign
Funcon structural-assign
Funcon structural-assigned
]
Meta-variables
T, T' <: values
#### Stores
Type
locations ~> atoms
Alias
locs = locations
/*
A storage location is represented by an atom.
*/
Type
stores ~> maps(locations, values?)
/*
The domain of a store is the set of currently allocated locations.
Mapping a location to `( )` models the absence of its stored value;
removing it from the store allows it to be re-allocated.
*/
Entity
< _ , store(_:stores) > ---> < _ , store(_:stores) >
/*
The current store is a mutable entity.
A transition ``< X , store(Sigma) > ---> < X' , store(Sigma') >`` models
a step from `X` to `X'` where the difference between `Sigma` and `Sigma'`
(if any) corresponds to storage effects.
*/
Funcon
store-clear : =>null-type
Rule
< store-clear , store(_) > ---> < null-value , store(map( )) >
/*
`store-clear` ensures the store is empty.
*/
Funcon
initialise-storing(X:=>T) : =>T
~> sequential(store-clear,
initialise-giving(initialise-generating(X)))
Alias
init-storing = initialise-storing
/*
`initialise-storing(X)` ensures that the entities used by the funcons for
storing are properly initialised.
*/
#### Simple variables
/*
Simple variables may store primitive or structured values. The type of
values stored by a variable is fixed when it is allocated. For instance,
`allocate-variable(integers)` allocates a simple integer variable, and
`allocate-variable(vectors(integers))` allocates a structured variable for
storing vectors of integers, which can be updated only monolithically.
*/
Datatype
variables ::= variable(_:locations, _:value-types)
Alias
vars = variables
Alias
var = variable
/*
`variables` is the type of simple variables that can store values of
a particular type.
`variable(L, T)` constructs a simple variable for storing values of
type `T` at location `L`. Variables at different locations are independent.
Note that `variables` is a subtype of `datatype-values`.
*/
Funcon
allocate-variable(T:types) : =>variables
Alias
alloc = allocate-variable
/*
`allocate-variable(T)` gives a simple variable whose location is not in the
current store. Subsequent uses of `allocate-variable(T')` give independent
variables, except after `recycle-variables(V,...)` or `store-clear`.
*/
Rule
< use-atom-not-in(dom(Sigma)) , store(Sigma) > ---> < L , store(Sigma') >
map-override({L |-> ( )}, Sigma') ~> Sigma''
-------------------------------------------------------------------------
< allocate-variable(T:types) , store(Sigma) >
---> < variable(L, T) , store(Sigma'') >
Funcon
recycle-variables(_:variables+) : =>null-type
Alias
recycle = recycle-variables
/*
`recycle-variables(Var,...)` removes the locations of `Var`, ..., from the
current store, so that they may subsequently be re-allocated.
*/
Rule
is-in-set(L, dom(Sigma)) == true
---------------------------------------------------------------------
< recycle-variables(variable(L:locations, T:types)) , store(Sigma) >
---> < null-value , store(map-delete(Sigma, {L})) >
Rule
is-in-set(L, dom(Sigma)) == false
---------------------------------------------------------------------
< recycle-variables(variable(L:locations, T:types)) , store(Sigma) >
---> < fail , store(Sigma) >
Rule
recycle-variables(Var:variables, Var+:variables+)
~> sequential(recycle-variables(Var), recycle-variables(Var+))
Funcon
initialise-variable(_:variables, _:values) : =>null-type
Alias
init = initialise-variable
/*
`initialise-variable(Var, Val)` assigns `Val` as the initial value of `Var`,
and gives `null-value`. If `Var` already has an assigned value, it fails.
*/
Rule
and(is-in-set(L, dom(Sigma)),
not is-value(map-lookup(Sigma, L)),
is-in-type(Val, T))
== true
----------------------------------------------------------------------------
< initialise-variable(variable(L:locations, T:types), Val:values) ,
store(Sigma) > ---> < null-value , store(map-override({L|->Val}, Sigma)) >
Rule
and(is-in-set(L, dom(Sigma)),
not is-value(map-lookup(Sigma, L)),
is-in-type(Val, T))
== false
----------------------------------------------------------------------------
< initialise-variable(variable(L:locations, T:types), Val:values) ,
store(Sigma) > ---> < fail , store(Sigma) >
Funcon
allocate-initialised-variable(T, Val:T) : =>variables
~> give(allocate-variable(T),
sequential(initialise-variable(given, Val), given))
Alias
alloc-init = allocate-initialised-variable
/*
`allocate-initialised-variable(T, Val)` allocates a simple variable for
storing values of type `T`, initialises its value to `Val`, and returns the
variable.
*/
Funcon
assign(_:variables, _:values) : =>null-type
/*
`assign(Var, Val)` assigns the value `Val` to the variable `Var`,
provided that `Var` was allocated with a type that contains `Val`.
*/
Rule
and(is-in-set(L, dom(Sigma)), is-in-type(Val, T)) == true
-----------------------------------------------------------------------
< assign(variable(L:locations, T:types), Val:values) ,
store(Sigma) > ---> < null-value , store(map-override({L|->Val}, Sigma)) >
Rule
and(is-in-set(L, dom(Sigma)), is-in-type(Val, T)) == false
--------------------------------------------------------------------------
< assign(variable(L:locations,T:types), Val:values) ,
store(Sigma) > ---> < fail , store(Sigma) >
Funcon
assigned(_:variables) : =>values
/*
`assigned(Var)` gives the value assigned to the variable `Var`,
failing if no value is currently assigned.
*/
Rule
map-lookup(Sigma, L) ~> (Val:values)
------------------------------------------------------------------
< assigned(variable(L:locations, T:types)) , store(Sigma) >
---> < Val , store(Sigma) >
Rule
map-lookup(Sigma, L) == ( )
------------------------------------------------------------------
< assigned(variable(L:locations, T:types)) , store(Sigma) >
---> < fail , store(Sigma) >
Funcon
current-value(_:values) : =>values
/*
`current-value(V)` gives the same result as `assigned(V)` when `V` is a
simple variable, and otherwise gives `V`.
It represents implicit dereferencing of a value that might be a variable.
*/
Rule
current-value(Var:variables) ~> assigned(Var)
Rule
current-value(U:~variables) ~> U
Funcon
un-assign(_:variables) : =>null-type
/*
`un-assign(Var)` remove the value assigned to the variable `Var`.
*/
Rule
is-in-set(L, dom(Sigma)) == true
--------------------------------------------------------------------------
< un-assign(variable(L:locations, T:types)) , store(Sigma) >
---> < null-value , store(map-override({L |-> ( )}, Sigma)) >
Rule
is-in-set(L, dom(Sigma)) == false
--------------------------------------------------------------------------
< un-assign(variable(L:locations, T:types)) , store(Sigma) >
---> < fail , store(Sigma) >
#### Structured variables
/*
Structured variables are structured values where some components are
simple variables. Such component variables can be selected using the
same funcons as for selecting components of structured values.
Structured variables containing both simple variables and values correspond
to hybrid structures where particular components are mutable.
All datatypes (except for abstractions) can be used to form structured
variables. So can maps, but not sets or multisets.
Structural generalisations of `assign(Var, Val)` and
`assigned(Var)` access all the simple variables contained in a
structured variable. Assignment requires each component value of a hybrid
structured variable to be equal to the corresponding component of the
structured value.
*/
Funcon
structural-assign(_:values, _:values) : =>null-type
/*
`structural-assign(V1, V2)` takes a (potentially) structured variable
`V1`and a (potentially) structured value `V2`. Provided that the structure
and all non-variable values in `V1` match the structure and corresponding
values of `V2`, all the simple variables in `V1` are assigned the
corresponding values of `V2`; otherwise the assignment fails.
*/
Rule
structural-assign(V1:variables, V2:values)
~> assign(V1, V2)
Rule
V1 : ~(variables)
V1 ~> datatype-value(I1:identifiers, V1*:values*)
V2 ~> datatype-value(I2:identifiers, V2*:values*)
-----------------------------------------------------------------------
structural-assign(V1:datatype-values, V2:datatype-values)
~> sequential(
check-true(is-equal(I1, I2)),
effect(tuple(interleave-map(
structural-assign(tuple-elements(given)),
tuple-zip(tuple(V1*), tuple(V2*))))),
null-value)
/*
Note that simple variables are datatype values.
*/
Rule
dom(M1) == {}
------------------------------------------------------
structural-assign(M1:maps(_,_), M2:maps(_,_))
~> check-true(is-equal(dom(M2), { }))
Rule
some-element(dom(M1)) ~> K
----------------------------------------------------------------------------
structural-assign(M1:maps(_, _), M2:maps(_, _))
~> sequential(check-true(is-in-set(K, dom(M2))),
structural-assign(map-lookup(M1, K), map-lookup(M2, K)),
structural-assign(map-delete(M1, {K}), map-delete(M2, {K})))
Rule
V1 : ~(datatype-values|maps(_, _))
---------------------------------------------------------------
structural-assign(V1:values,V2:values)
~> check-true(is-equal(V1, V2))
Funcon
structural-assigned(_:values) : =>values
/*
`structural-assigned(V)` takes a (potentially) structured variable `V`,
and computes the value of `V` with all simple variables in `V` replaced by
their assigned values, failing if any of them do not have assigned values.
When `V` is just a simple variable or a (possibly structured) value with no
component variables, `structural-assigned(V)` gives the same result as
`current-value(V)`.
*/
Rule
structural-assigned(Var:variables) ~> assigned(Var)
Rule
V : ~(variables)
V ~> datatype-value(I:identifiers, V*:values*)
----------------------------------------------------------------------------
structural-assigned(V:datatype-values)
~> datatype-value(I, interleave-map(structural-assigned(given), V*))
/*
Note that simple variables are datatype values.
*/
Rule
structural-assigned(M:maps(_, _))
~> map(interleave-map(structural-assigned(given), map-elements(M)))
Rule
U : ~(datatype-values|maps(_, _))
------------------------------------------
structural-assigned(U:values) ~> U

392
IBAF-cbs/Funcons-beta/Computations/Normal/Storing/index.md Normal file
View File

@@ -0,0 +1,392 @@
---
layout: default
title: "Storing"
parent: Normal
ancestor: Funcons-beta
---
[Funcons-beta] : [Storing.cbs]
-----------------------------
### Storing
<div class="highlighter-rouge"><pre class="highlight"><code>[
<i class="keyword">Datatype</i> <span class="name"><a href="#Name_locations">locations</a></span> <i class="keyword">Alias</i> <span class="name"><a href="#Name_locs">locs</a></span>
<i class="keyword">Type</i> <span class="name"><a href="#Name_stores">stores</a></span>
<i class="keyword">Entity</i> <span class="name"><a href="#Name_store">store</a></span>
<i class="keyword">Funcon</i> <span class="name"><a href="#Name_initialise-storing">initialise-storing</a></span>
<i class="keyword">Funcon</i> <span class="name"><a href="#Name_store-clear">store-clear</a></span>
<i class="keyword">Datatype</i> <span class="name"><a href="#Name_variables">variables</a></span> <i class="keyword">Alias</i> <span class="name"><a href="#Name_vars">vars</a></span>
<i class="keyword">Funcon</i> <span class="name"><a href="#Name_variable">variable</a></span> <i class="keyword">Alias</i> <span class="name"><a href="#Name_var">var</a></span>
<i class="keyword">Funcon</i> <span class="name"><a href="#Name_allocate-variable">allocate-variable</a></span> <i class="keyword">Alias</i> <span class="name"><a href="#Name_alloc">alloc</a></span>
<i class="keyword">Funcon</i> <span class="name"><a href="#Name_recycle-variables">recycle-variables</a></span> <i class="keyword">Alias</i> <span class="name"><a href="#Name_recycle">recycle</a></span>
<i class="keyword">Funcon</i> <span class="name"><a href="#Name_initialise-variable">initialise-variable</a></span> <i class="keyword">Alias</i> <span class="name"><a href="#Name_init">init</a></span>
<i class="keyword">Funcon</i> <span class="name"><a href="#Name_allocate-initialised-variable">allocate-initialised-variable</a></span> <i class="keyword">Alias</i> <span class="name"><a href="#Name_alloc-init">alloc-init</a></span>
<i class="keyword">Funcon</i> <span class="name"><a href="#Name_assign">assign</a></span>
<i class="keyword">Funcon</i> <span class="name"><a href="#Name_assigned">assigned</a></span>
<i class="keyword">Funcon</i> <span class="name"><a href="#Name_current-value">current-value</a></span>
<i class="keyword">Funcon</i> <span class="name"><a href="#Name_un-assign">un-assign</a></span>
<i class="keyword">Funcon</i> <span class="name"><a href="#Name_structural-assign">structural-assign</a></span>
<i class="keyword">Funcon</i> <span class="name"><a href="#Name_structural-assigned">structural-assigned</a></span>
]</code></pre></div>
<div class="highlighter-rouge"><pre class="highlight"><code><i class="keyword">Meta-variables</i>
<span id="PartVariable_T"><i class="var">T</i></span>, <span id="PartVariable_T'"><i class="var">T&prime;</i></span> <: <span class="name"><a href="../../../Values/Value-Types/index.html#Name_values">values</a></span></code></pre></div>
#### Stores
<div class="highlighter-rouge"><pre class="highlight"><code><i class="keyword">Type</i>
<span class="name"><span id="Name_locations">locations</span></span> ~> <span class="name"><a href="../Generating/index.html#Name_atoms">atoms</a></span>
<i class="keyword">Alias</i>
<span class="name"><span id="Name_locs">locs</span></span> = <span class="name"><a href="#Name_locations">locations</a></span></code></pre></div>
A storage location is represented by an atom.
<div class="highlighter-rouge"><pre class="highlight"><code><i class="keyword">Type</i>
<span class="name"><span id="Name_stores">stores</span></span> ~> <span class="name"><a href="../../../Values/Composite/Maps/index.html#Name_maps">maps</a></span>(<span class="name"><a href="#Name_locations">locations</a></span>, <span class="name"><a href="../../../Values/Value-Types/index.html#Name_values">values</a></span><sup class="sup">?</sup>)</code></pre></div>
The domain of a store is the set of currently allocated locations.
Mapping a location to <code>( )</code> models the absence of its stored value;
removing it from the store allows it to be re-allocated.
<div class="highlighter-rouge"><pre class="highlight"><code><i class="keyword">Entity</i>
< _ , <span class="ent-name"><span id="Name_store">store</span></span>(_:<span class="name"><a href="#Name_stores">stores</a></span>) > ---> < _ , <span class="ent-name">store</span>(_:<span class="name">stores</span>) ></code></pre></div>
The current store is a mutable entity.
A transition <code>< <i class="var">X</i> , <span class="ent-name"><a href="#Name_store">store</a></span>(<i class="var">Sigma</i>) > ---> < <span id="Variable239_X'"><i class="var">X&prime;</i></span> , <span class="ent-name"><a href="#Name_store">store</a></span>(<span id="Variable246_Sigma'"><i class="var">Sigma&prime;</i></span>) ></code> models
a step from <code><i class="var">X</i></code> to <code><i class="var">X&prime;</i></code> where the difference between <code><i class="var">Sigma</i></code> and <code><i class="var">Sigma&prime;</i></code>
(if any) corresponds to storage effects.
<div class="highlighter-rouge"><pre class="highlight"><code><i class="keyword">Funcon</i>
<span class="name"><span id="Name_store-clear">store-clear</span></span> : =><span class="name"><a href="../../../Values/Primitive/Null/index.html#Name_null-type">null-type</a></span>
<i class="keyword">Rule</i>
< <span class="name"><a href="#Name_store-clear">store-clear</a></span> , <span class="ent-name"><a href="#Name_store">store</a></span>(_) > ---> < <span class="name"><a href="../../../Values/Primitive/Null/index.html#Name_null-value">null-value</a></span> , <span class="ent-name"><a href="#Name_store">store</a></span>(<span class="name"><a href="../../../Values/Composite/Maps/index.html#Name_map">map</a></span>( )) ></code></pre></div>
<code><span class="name"><a href="#Name_store-clear">store-clear</a></span></code> ensures the store is empty.
<div class="highlighter-rouge"><pre class="highlight"><code><i class="keyword">Funcon</i>
<span class="name"><span id="Name_initialise-storing">initialise-storing</span></span>(<span id="Variable392_X"><i class="var">X</i></span>:=><span id="Variable397_T"><i class="var">T</i></span>) : =><span id="Variable412_T"><i class="var">T</i></span>
~> <span class="name"><a href="../Flowing/index.html#Name_sequential">sequential</a></span>(<span class="name"><a href="#Name_store-clear">store-clear</a></span>,
<span class="name"><a href="../Giving/index.html#Name_initialise-giving">initialise-giving</a></span>(<span class="name"><a href="../Generating/index.html#Name_initialise-generating">initialise-generating</a></span>(<a href="#Variable392_X"><i class="var">X</i></a>)))
<i class="keyword">Alias</i>
<span class="name"><span id="Name_init-storing">init-storing</span></span> = <span class="name"><a href="#Name_initialise-storing">initialise-storing</a></span></code></pre></div>
<code><span class="name"><a href="#Name_initialise-storing">initialise-storing</a></span>(<i class="var">X</i>)</code> ensures that the entities used by the funcons for
storing are properly initialised.
#### Simple variables
Simple variables may store primitive or structured values. The type of
values stored by a variable is fixed when it is allocated. For instance,
<code><span class="name"><a href="#Name_allocate-variable">allocate-variable</a></span>(<span class="name"><a href="../../../Values/Primitive/Integers/index.html#Name_integers">integers</a></span>)</code> allocates a simple integer variable, and
<code><span class="name"><a href="#Name_allocate-variable">allocate-variable</a></span>(<span class="name"><a href="../../../Values/Composite/Vectors/index.html#Name_vectors">vectors</a></span>(<span class="name"><a href="../../../Values/Primitive/Integers/index.html#Name_integers">integers</a></span>))</code> allocates a structured variable for
storing vectors of integers, which can be updated only monolithically.
<div class="highlighter-rouge"><pre class="highlight"><code><i class="keyword">Datatype</i>
<span class="name"><span id="Name_variables">variables</span></span> ::= <span id="Name_variable">variable</span>(_:<span class="name"><a href="#Name_locations">locations</a></span>, _:<span class="name"><a href="../../../Values/Value-Types/index.html#Name_value-types">value-types</a></span>)
<i class="keyword">Alias</i>
<span class="name"><span id="Name_vars">vars</span></span> = <span class="name"><a href="#Name_variables">variables</a></span></code></pre></div>
<div class="highlighter-rouge"><pre class="highlight"><code><i class="keyword">Alias</i>
<span class="name"><span id="Name_var">var</span></span> = <span class="name"><a href="#Name_variable">variable</a></span></code></pre></div>
<code><span class="name"><a href="#Name_variables">variables</a></span></code> is the type of simple variables that can store values of
a particular type.
<code><span class="name"><a href="#Name_variable">variable</a></span>(<i class="var">L</i>, <i class="var">T</i>)</code> constructs a simple variable for storing values of
type <code><i class="var">T</i></code> at location <code><i class="var">L</i></code>. Variables at different locations are independent.
Note that <code><span class="name"><a href="#Name_variables">variables</a></span></code> is a subtype of <code><span class="name"><a href="../../../Values/Composite/Datatypes/index.html#Name_datatype-values">datatype-values</a></span></code>.
<div class="highlighter-rouge"><pre class="highlight"><code><i class="keyword">Funcon</i>
<span class="name"><span id="Name_allocate-variable">allocate-variable</span></span>(<span id="Variable676_T"><i class="var">T</i></span>:<span class="name"><a href="../../../Values/Value-Types/index.html#Name_types">types</a></span>) : =><span class="name"><a href="#Name_variables">variables</a></span>
<i class="keyword">Alias</i>
<span class="name"><span id="Name_alloc">alloc</span></span> = <span class="name"><a href="#Name_allocate-variable">allocate-variable</a></span></code></pre></div>
<code><span class="name"><a href="#Name_allocate-variable">allocate-variable</a></span>(<i class="var">T</i>)</code> gives a simple variable whose location is not in the
current store. Subsequent uses of <code><span class="name"><a href="#Name_allocate-variable">allocate-variable</a></span>(<i class="var">T&prime;</i>)</code> give independent
variables, except after <code><span class="name"><a href="#Name_recycle-variables">recycle-variables</a></span>(<i class="var">V</i>,...)</code> or <code><span class="name"><a href="#Name_store-clear">store-clear</a></span></code>.
<div class="highlighter-rouge"><pre class="highlight"><code><i class="keyword">Rule</i>
< <span class="name"><a href="../Generating/index.html#Name_use-atom-not-in">use-atom-not-in</a></span>(<span class="name"><a href="../../../Values/Composite/Maps/index.html#Name_dom">dom</a></span>(<a href="#Variable898_Sigma"><i class="var">Sigma</i></a>)) , <span class="ent-name"><a href="#Name_store">store</a></span>(<a href="#Variable898_Sigma"><i class="var">Sigma</i></a>) > ---> < <span id="Variable818_L"><i class="var">L</i></span> , <span class="ent-name"><a href="#Name_store">store</a></span>(<span id="Variable825_Sigma'"><i class="var">Sigma&prime;</i></span>) >
<span class="name"><a href="../../../Values/Composite/Maps/index.html#Name_map-override">map-override</a></span>({<a href="#Variable818_L"><i class="var">L</i></a> |-> ( )}, <a href="#Variable825_Sigma'"><i class="var">Sigma&prime;</i></a>) ~> <span id="Variable870_Sigma''"><i class="var">Sigma&prime;&prime;</i></span>
-------------------------------------------------------------------------
< <span class="name"><a href="#Name_allocate-variable">allocate-variable</a></span>(<span id="Variable883_T"><i class="var">T</i></span>:<span class="name"><a href="../../../Values/Value-Types/index.html#Name_types">types</a></span>) , <span class="ent-name"><a href="#Name_store">store</a></span>(<span id="Variable898_Sigma"><i class="var">Sigma</i></span>) >
---> < <span class="name"><a href="#Name_variable">variable</a></span>(<a href="#Variable818_L"><i class="var">L</i></a>, <a href="#Variable883_T"><i class="var">T</i></a>) , <span class="ent-name"><a href="#Name_store">store</a></span>(<a href="#Variable870_Sigma''"><i class="var">Sigma&prime;&prime;</i></a>) ></code></pre></div>
<div class="highlighter-rouge"><pre class="highlight"><code><i class="keyword">Funcon</i>
<span class="name"><span id="Name_recycle-variables">recycle-variables</span></span>(_:<span class="name"><a href="#Name_variables">variables</a></span><sup class="sup">+</sup>) : =><span class="name"><a href="../../../Values/Primitive/Null/index.html#Name_null-type">null-type</a></span>
<i class="keyword">Alias</i>
<span class="name"><span id="Name_recycle">recycle</span></span> = <span class="name"><a href="#Name_recycle-variables">recycle-variables</a></span></code></pre></div>
<code><span class="name"><a href="#Name_recycle-variables">recycle-variables</a></span>(<i class="var">Var</i>,...)</code> removes the locations of <code><i class="var">Var</i></code>, ..., from the
current store, so that they may subsequently be re-allocated.
<div class="highlighter-rouge"><pre class="highlight"><code><i class="keyword">Rule</i>
<span class="name"><a href="../../../Values/Composite/Sets/index.html#Name_is-in-set">is-in-set</a></span>(<a href="#Variable1056_L"><i class="var">L</i></a>, <span class="name"><a href="../../../Values/Composite/Maps/index.html#Name_dom">dom</a></span>(<a href="#Variable1086_Sigma"><i class="var">Sigma</i></a>)) == <span class="name"><a href="../../../Values/Primitive/Booleans/index.html#Name_true">true</a></span>
---------------------------------------------------------------------
< <span class="name"><a href="#Name_recycle-variables">recycle-variables</a></span>(<span class="name"><a href="#Name_variable">variable</a></span>(<span id="Variable1056_L"><i class="var">L</i></span>:<span class="name"><a href="#Name_locations">locations</a></span>, <span id="Variable1064_T"><i class="var">T</i></span>:<span class="name"><a href="../../../Values/Value-Types/index.html#Name_types">types</a></span>)) , <span class="ent-name"><a href="#Name_store">store</a></span>(<span id="Variable1086_Sigma"><i class="var">Sigma</i></span>) >
---> < <span class="name"><a href="../../../Values/Primitive/Null/index.html#Name_null-value">null-value</a></span> , <span class="ent-name"><a href="#Name_store">store</a></span>(<span class="name"><a href="../../../Values/Composite/Maps/index.html#Name_map-delete">map-delete</a></span>(<a href="#Variable1086_Sigma"><i class="var">Sigma</i></a>, {<a href="#Variable1056_L"><i class="var">L</i></a>})) >
<i class="keyword">Rule</i>
<span class="name"><a href="../../../Values/Composite/Sets/index.html#Name_is-in-set">is-in-set</a></span>(<a href="#Variable1177_L"><i class="var">L</i></a>, <span class="name"><a href="../../../Values/Composite/Maps/index.html#Name_dom">dom</a></span>(<a href="#Variable1207_Sigma"><i class="var">Sigma</i></a>)) == <span class="name"><a href="../../../Values/Primitive/Booleans/index.html#Name_false">false</a></span>
---------------------------------------------------------------------
< <span class="name"><a href="#Name_recycle-variables">recycle-variables</a></span>(<span class="name"><a href="#Name_variable">variable</a></span>(<span id="Variable1177_L"><i class="var">L</i></span>:<span class="name"><a href="#Name_locations">locations</a></span>, <span id="Variable1185_T"><i class="var">T</i></span>:<span class="name"><a href="../../../Values/Value-Types/index.html#Name_types">types</a></span>)) , <span class="ent-name"><a href="#Name_store">store</a></span>(<span id="Variable1207_Sigma"><i class="var">Sigma</i></span>) >
---> < <span class="name"><a href="../../Abnormal/Failing/index.html#Name_fail">fail</a></span> , <span class="ent-name"><a href="#Name_store">store</a></span>(<a href="#Variable1207_Sigma"><i class="var">Sigma</i></a>) >
<i class="keyword">Rule</i>
<span class="name"><a href="#Name_recycle-variables">recycle-variables</a></span>(<span id="Variable1246_Var"><i class="var">Var</i></span>:<span class="name"><a href="#Name_variables">variables</a></span>, <span id="Variable1255_Var+"><i class="var">Var<sup class="sup">+</sup></i></span>:<span class="name"><a href="#Name_variables">variables</a></span><sup class="sup">+</sup>)
~> <span class="name"><a href="../Flowing/index.html#Name_sequential">sequential</a></span>(<span class="name"><a href="#Name_recycle-variables">recycle-variables</a></span>(<a href="#Variable1246_Var"><i class="var">Var</i></a>), <span class="name"><a href="#Name_recycle-variables">recycle-variables</a></span>(<a href="#Variable1255_Var+"><i class="var">Var<sup class="sup">+</sup></i></a>))</code></pre></div>
<div class="highlighter-rouge"><pre class="highlight"><code><i class="keyword">Funcon</i>
<span class="name"><span id="Name_initialise-variable">initialise-variable</span></span>(_:<span class="name"><a href="#Name_variables">variables</a></span>, _:<span class="name"><a href="../../../Values/Value-Types/index.html#Name_values">values</a></span>) : =><span class="name"><a href="../../../Values/Primitive/Null/index.html#Name_null-type">null-type</a></span>
<i class="keyword">Alias</i>
<span class="name"><span id="Name_init">init</span></span> = <span class="name"><a href="#Name_initialise-variable">initialise-variable</a></span></code></pre></div>
<code><span class="name"><a href="#Name_initialise-variable">initialise-variable</a></span>(<i class="var">Var</i>, <i class="var">Val</i>)</code> assigns <code><i class="var">Val</i></code> as the initial value of <code><i class="var">Var</i></code>,
and gives <code><span class="name"><a href="../../../Values/Primitive/Null/index.html#Name_null-value">null-value</a></span></code>. If <code><i class="var">Var</i></code> already has an assigned value, it fails.
<div class="highlighter-rouge"><pre class="highlight"><code><i class="keyword">Rule</i>
<span class="name"><a href="../../../Values/Primitive/Booleans/index.html#Name_and">and</a></span>(<span class="name"><a href="../../../Values/Composite/Sets/index.html#Name_is-in-set">is-in-set</a></span>(<a href="#Variable1510_L"><i class="var">L</i></a>, <span class="name"><a href="../../../Values/Composite/Maps/index.html#Name_dom">dom</a></span>(<a href="#Variable1549_Sigma"><i class="var">Sigma</i></a>)),
<span class="name"><a href="../../../Values/Primitive/Booleans/index.html#Name_not">not</a></span> <span class="name"><a href="../../../Values/Value-Types/index.html#Name_is-value">is-value</a></span>(<span class="name"><a href="../../../Values/Composite/Maps/index.html#Name_map-lookup">map-lookup</a></span>(<a href="#Variable1549_Sigma"><i class="var">Sigma</i></a>, <a href="#Variable1510_L"><i class="var">L</i></a>)),
<span class="name"><a href="../../../Values/Value-Types/index.html#Name_is-in-type">is-in-type</a></span>(<a href="#Variable1533_Val"><i class="var">Val</i></a>, <a href="#Variable1518_T"><i class="var">T</i></a>))
== <span class="name"><a href="../../../Values/Primitive/Booleans/index.html#Name_true">true</a></span>
----------------------------------------------------------------------------
< <span class="name"><a href="#Name_initialise-variable">initialise-variable</a></span>(<span class="name"><a href="#Name_variable">variable</a></span>(<span id="Variable1510_L"><i class="var">L</i></span>:<span class="name"><a href="#Name_locations">locations</a></span>, <span id="Variable1518_T"><i class="var">T</i></span>:<span class="name"><a href="../../../Values/Value-Types/index.html#Name_types">types</a></span>), <span id="Variable1533_Val"><i class="var">Val</i></span>:<span class="name"><a href="../../../Values/Value-Types/index.html#Name_values">values</a></span>) ,
<span class="ent-name"><a href="#Name_store">store</a></span>(<span id="Variable1549_Sigma"><i class="var">Sigma</i></span>) > ---> < <span class="name"><a href="../../../Values/Primitive/Null/index.html#Name_null-value">null-value</a></span> , <span class="ent-name"><a href="#Name_store">store</a></span>(<span class="name"><a href="../../../Values/Composite/Maps/index.html#Name_map-override">map-override</a></span>({<a href="#Variable1510_L"><i class="var">L</i></a>|-><a href="#Variable1533_Val"><i class="var">Val</i></a>}, <a href="#Variable1549_Sigma"><i class="var">Sigma</i></a>)) >
<i class="keyword">Rule</i>
<span class="name"><a href="../../../Values/Primitive/Booleans/index.html#Name_and">and</a></span>(<span class="name"><a href="../../../Values/Composite/Sets/index.html#Name_is-in-set">is-in-set</a></span>(<a href="#Variable1699_L"><i class="var">L</i></a>, <span class="name"><a href="../../../Values/Composite/Maps/index.html#Name_dom">dom</a></span>(<a href="#Variable1738_Sigma"><i class="var">Sigma</i></a>)),
<span class="name"><a href="../../../Values/Primitive/Booleans/index.html#Name_not">not</a></span> <span class="name"><a href="../../../Values/Value-Types/index.html#Name_is-value">is-value</a></span>(<span class="name"><a href="../../../Values/Composite/Maps/index.html#Name_map-lookup">map-lookup</a></span>(<a href="#Variable1738_Sigma"><i class="var">Sigma</i></a>, <a href="#Variable1699_L"><i class="var">L</i></a>)),
<span class="name"><a href="../../../Values/Value-Types/index.html#Name_is-in-type">is-in-type</a></span>(<a href="#Variable1722_Val"><i class="var">Val</i></a>, <a href="#Variable1707_T"><i class="var">T</i></a>))
== <span class="name"><a href="../../../Values/Primitive/Booleans/index.html#Name_false">false</a></span>
----------------------------------------------------------------------------
< <span class="name"><a href="#Name_initialise-variable">initialise-variable</a></span>(<span class="name"><a href="#Name_variable">variable</a></span>(<span id="Variable1699_L"><i class="var">L</i></span>:<span class="name"><a href="#Name_locations">locations</a></span>, <span id="Variable1707_T"><i class="var">T</i></span>:<span class="name"><a href="../../../Values/Value-Types/index.html#Name_types">types</a></span>), <span id="Variable1722_Val"><i class="var">Val</i></span>:<span class="name"><a href="../../../Values/Value-Types/index.html#Name_values">values</a></span>) ,
<span class="ent-name"><a href="#Name_store">store</a></span>(<span id="Variable1738_Sigma"><i class="var">Sigma</i></span>) > ---> < <span class="name"><a href="../../Abnormal/Failing/index.html#Name_fail">fail</a></span> , <span class="ent-name"><a href="#Name_store">store</a></span>(<a href="#Variable1738_Sigma"><i class="var">Sigma</i></a>) ></code></pre></div>
<div class="highlighter-rouge"><pre class="highlight"><code><i class="keyword">Funcon</i>
<span class="name"><span id="Name_allocate-initialised-variable">allocate-initialised-variable</span></span>(<span id="Variable1777_T"><i class="var">T</i></span>, <span id="Variable1783_Val"><i class="var">Val</i></span>:<span id="Variable1787_T"><i class="var">T</i></span>) : =><span class="name"><a href="#Name_variables">variables</a></span>
~> <span class="name"><a href="../Giving/index.html#Name_give">give</a></span>(<span class="name"><a href="#Name_allocate-variable">allocate-variable</a></span>(<i class="var">T</i>),
<span class="name"><a href="../Flowing/index.html#Name_sequential">sequential</a></span>(<span class="name"><a href="#Name_initialise-variable">initialise-variable</a></span>(<span class="name"><a href="../Giving/index.html#Name_given">given</a></span>, <a href="#Variable1783_Val"><i class="var">Val</i></a>), <span class="name"><a href="../Giving/index.html#Name_given">given</a></span>))
<i class="keyword">Alias</i>
<span class="name"><span id="Name_alloc-init">alloc-init</span></span> = <span class="name"><a href="#Name_allocate-initialised-variable">allocate-initialised-variable</a></span></code></pre></div>
<code><span class="name"><a href="#Name_allocate-initialised-variable">allocate-initialised-variable</a></span>(<i class="var">T</i>, <i class="var">Val</i>)</code> allocates a simple variable for
storing values of type <code><i class="var">T</i></code>, initialises its value to <code><i class="var">Val</i></code>, and returns the
variable.
<div class="highlighter-rouge"><pre class="highlight"><code><i class="keyword">Funcon</i>
<span class="name"><span id="Name_assign">assign</span></span>(_:<span class="name"><a href="#Name_variables">variables</a></span>, _:<span class="name"><a href="../../../Values/Value-Types/index.html#Name_values">values</a></span>) : =><span class="name"><a href="../../../Values/Primitive/Null/index.html#Name_null-type">null-type</a></span></code></pre></div>
<code><span class="name"><a href="#Name_assign">assign</a></span>(<i class="var">Var</i>, <i class="var">Val</i>)</code> assigns the value <code><i class="var">Val</i></code> to the variable <code><i class="var">Var</i></code>,
provided that <code><i class="var">Var</i></code> was allocated with a type that contains <code><i class="var">Val</i></code>.
<div class="highlighter-rouge"><pre class="highlight"><code><i class="keyword">Rule</i>
<span class="name"><a href="../../../Values/Primitive/Booleans/index.html#Name_and">and</a></span>(<span class="name"><a href="../../../Values/Composite/Sets/index.html#Name_is-in-set">is-in-set</a></span>(<a href="#Variable2088_L"><i class="var">L</i></a>, <span class="name"><a href="../../../Values/Composite/Maps/index.html#Name_dom">dom</a></span>(<a href="#Variable2127_Sigma"><i class="var">Sigma</i></a>)), <span class="name"><a href="../../../Values/Value-Types/index.html#Name_is-in-type">is-in-type</a></span>(<a href="#Variable2111_Val"><i class="var">Val</i></a>, <a href="#Variable2096_T"><i class="var">T</i></a>)) == <span class="name"><a href="../../../Values/Primitive/Booleans/index.html#Name_true">true</a></span>
-----------------------------------------------------------------------
< <span class="name"><a href="#Name_assign">assign</a></span>(<span class="name"><a href="#Name_variable">variable</a></span>(<span id="Variable2088_L"><i class="var">L</i></span>:<span class="name"><a href="#Name_locations">locations</a></span>, <span id="Variable2096_T"><i class="var">T</i></span>:<span class="name"><a href="../../../Values/Value-Types/index.html#Name_types">types</a></span>), <span id="Variable2111_Val"><i class="var">Val</i></span>:<span class="name"><a href="../../../Values/Value-Types/index.html#Name_values">values</a></span>) ,
<span class="ent-name"><a href="#Name_store">store</a></span>(<span id="Variable2127_Sigma"><i class="var">Sigma</i></span>) > ---> < <span class="name"><a href="../../../Values/Primitive/Null/index.html#Name_null-value">null-value</a></span> , <span class="ent-name"><a href="#Name_store">store</a></span>(<span class="name"><a href="../../../Values/Composite/Maps/index.html#Name_map-override">map-override</a></span>({<a href="#Variable2088_L"><i class="var">L</i></a>|-><a href="#Variable2111_Val"><i class="var">Val</i></a>}, <a href="#Variable2127_Sigma"><i class="var">Sigma</i></a>)) >
<i class="keyword">Rule</i>
<span class="name"><a href="../../../Values/Primitive/Booleans/index.html#Name_and">and</a></span>(<span class="name"><a href="../../../Values/Composite/Sets/index.html#Name_is-in-set">is-in-set</a></span>(<a href="#Variable2249_L"><i class="var">L</i></a>, <span class="name"><a href="../../../Values/Composite/Maps/index.html#Name_dom">dom</a></span>(<a href="#Variable2288_Sigma"><i class="var">Sigma</i></a>)), <span class="name"><a href="../../../Values/Value-Types/index.html#Name_is-in-type">is-in-type</a></span>(<a href="#Variable2272_Val"><i class="var">Val</i></a>, <a href="#Variable2257_T"><i class="var">T</i></a>)) == <span class="name"><a href="../../../Values/Primitive/Booleans/index.html#Name_false">false</a></span>
--------------------------------------------------------------------------
< <span class="name"><a href="#Name_assign">assign</a></span>(<span class="name"><a href="#Name_variable">variable</a></span>(<span id="Variable2249_L"><i class="var">L</i></span>:<span class="name"><a href="#Name_locations">locations</a></span>,<span id="Variable2257_T"><i class="var">T</i></span>:<span class="name"><a href="../../../Values/Value-Types/index.html#Name_types">types</a></span>), <span id="Variable2272_Val"><i class="var">Val</i></span>:<span class="name"><a href="../../../Values/Value-Types/index.html#Name_values">values</a></span>) ,
<span class="ent-name"><a href="#Name_store">store</a></span>(<span id="Variable2288_Sigma"><i class="var">Sigma</i></span>) > ---> < <span class="name"><a href="../../Abnormal/Failing/index.html#Name_fail">fail</a></span> , <span class="ent-name"><a href="#Name_store">store</a></span>(<a href="#Variable2288_Sigma"><i class="var">Sigma</i></a>) ></code></pre></div>
<div class="highlighter-rouge"><pre class="highlight"><code><i class="keyword">Funcon</i>
<span class="name"><span id="Name_assigned">assigned</span></span>(_:<span class="name"><a href="#Name_variables">variables</a></span>) : =><span class="name"><a href="../../../Values/Value-Types/index.html#Name_values">values</a></span></code></pre></div>
<code><span class="name"><a href="#Name_assigned">assigned</a></span>(<i class="var">Var</i>)</code> gives the value assigned to the variable <code><i class="var">Var</i></code>,
failing if no value is currently assigned.
<div class="highlighter-rouge"><pre class="highlight"><code><i class="keyword">Rule</i>
<span class="name"><a href="../../../Values/Composite/Maps/index.html#Name_map-lookup">map-lookup</a></span>(<a href="#Variable2454_Sigma"><i class="var">Sigma</i></a>, <a href="#Variable2424_L"><i class="var">L</i></a>) ~> (<span id="Variable2403_Val"><i class="var">Val</i></span>:<span class="name"><a href="../../../Values/Value-Types/index.html#Name_values">values</a></span>)
------------------------------------------------------------------
< <span class="name"><a href="#Name_assigned">assigned</a></span>(<span class="name"><a href="#Name_variable">variable</a></span>(<span id="Variable2424_L"><i class="var">L</i></span>:<span class="name"><a href="#Name_locations">locations</a></span>, <span id="Variable2432_T"><i class="var">T</i></span>:<span class="name"><a href="../../../Values/Value-Types/index.html#Name_types">types</a></span>)) , <span class="ent-name"><a href="#Name_store">store</a></span>(<span id="Variable2454_Sigma"><i class="var">Sigma</i></span>) >
---> < <a href="#Variable2403_Val"><i class="var">Val</i></a> , <span class="ent-name"><a href="#Name_store">store</a></span>(<a href="#Variable2454_Sigma"><i class="var">Sigma</i></a>) >
<i class="keyword">Rule</i>
<span class="name"><a href="../../../Values/Composite/Maps/index.html#Name_map-lookup">map-lookup</a></span>(<a href="#Variable2555_Sigma"><i class="var">Sigma</i></a>, <a href="#Variable2525_L"><i class="var">L</i></a>) == ( )
------------------------------------------------------------------
< <span class="name"><a href="#Name_assigned">assigned</a></span>(<span class="name"><a href="#Name_variable">variable</a></span>(<span id="Variable2525_L"><i class="var">L</i></span>:<span class="name"><a href="#Name_locations">locations</a></span>, <span id="Variable2533_T"><i class="var">T</i></span>:<span class="name"><a href="../../../Values/Value-Types/index.html#Name_types">types</a></span>)) , <span class="ent-name"><a href="#Name_store">store</a></span>(<span id="Variable2555_Sigma"><i class="var">Sigma</i></span>) >
---> < <span class="name"><a href="../../Abnormal/Failing/index.html#Name_fail">fail</a></span> , <span class="ent-name"><a href="#Name_store">store</a></span>(<a href="#Variable2555_Sigma"><i class="var">Sigma</i></a>) ></code></pre></div>
<div class="highlighter-rouge"><pre class="highlight"><code><i class="keyword">Funcon</i>
<span class="name"><span id="Name_current-value">current-value</span></span>(_:<span class="name"><a href="../../../Values/Value-Types/index.html#Name_values">values</a></span>) : =><span class="name"><a href="../../../Values/Value-Types/index.html#Name_values">values</a></span></code></pre></div>
<code><span class="name"><a href="#Name_current-value">current-value</a></span>(<i class="var">V</i>)</code> gives the same result as <code><span class="name"><a href="#Name_assigned">assigned</a></span>(<i class="var">V</i>)</code> when <code><i class="var">V</i></code> is a
simple variable, and otherwise gives <code><i class="var">V</i></code>.
It represents implicit dereferencing of a value that might be a variable.
<div class="highlighter-rouge"><pre class="highlight"><code><i class="keyword">Rule</i>
<span class="name"><a href="#Name_current-value">current-value</a></span>(<span id="Variable2686_Var"><i class="var">Var</i></span>:<span class="name"><a href="#Name_variables">variables</a></span>) ~> <span class="name"><a href="#Name_assigned">assigned</a></span>(<a href="#Variable2686_Var"><i class="var">Var</i></a>)
<i class="keyword">Rule</i>
<span class="name"><a href="#Name_current-value">current-value</a></span>(<span id="Variable2716_U"><i class="var">U</i></span>:~<span class="name"><a href="#Name_variables">variables</a></span>) ~> <a href="#Variable2716_U"><i class="var">U</i></a></code></pre></div>
<div class="highlighter-rouge"><pre class="highlight"><code><i class="keyword">Funcon</i>
<span class="name"><span id="Name_un-assign">un-assign</span></span>(_:<span class="name"><a href="#Name_variables">variables</a></span>) : =><span class="name"><a href="../../../Values/Primitive/Null/index.html#Name_null-type">null-type</a></span></code></pre></div>
<code><span class="name"><a href="#Name_un-assign">un-assign</a></span>(<i class="var">Var</i>)</code> remove the value assigned to the variable <code><i class="var">Var</i></code>.
<div class="highlighter-rouge"><pre class="highlight"><code><i class="keyword">Rule</i>
<span class="name"><a href="../../../Values/Composite/Sets/index.html#Name_is-in-set">is-in-set</a></span>(<a href="#Variable2833_L"><i class="var">L</i></a>, <span class="name"><a href="../../../Values/Composite/Maps/index.html#Name_dom">dom</a></span>(<a href="#Variable2863_Sigma"><i class="var">Sigma</i></a>)) == <span class="name"><a href="../../../Values/Primitive/Booleans/index.html#Name_true">true</a></span>
--------------------------------------------------------------------------
< <span class="name"><a href="#Name_un-assign">un-assign</a></span>(<span class="name"><a href="#Name_variable">variable</a></span>(<span id="Variable2833_L"><i class="var">L</i></span>:<span class="name"><a href="#Name_locations">locations</a></span>, <span id="Variable2841_T"><i class="var">T</i></span>:<span class="name"><a href="../../../Values/Value-Types/index.html#Name_types">types</a></span>)) , <span class="ent-name"><a href="#Name_store">store</a></span>(<span id="Variable2863_Sigma"><i class="var">Sigma</i></span>) >
---> < <span class="name"><a href="../../../Values/Primitive/Null/index.html#Name_null-value">null-value</a></span> , <span class="ent-name"><a href="#Name_store">store</a></span>(<span class="name"><a href="../../../Values/Composite/Maps/index.html#Name_map-override">map-override</a></span>({<a href="#Variable2833_L"><i class="var">L</i></a> |-> ( )}, <a href="#Variable2863_Sigma"><i class="var">Sigma</i></a>)) >
<i class="keyword">Rule</i>
<span class="name"><a href="../../../Values/Composite/Sets/index.html#Name_is-in-set">is-in-set</a></span>(<a href="#Variable2958_L"><i class="var">L</i></a>, <span class="name"><a href="../../../Values/Composite/Maps/index.html#Name_dom">dom</a></span>(<a href="#Variable2988_Sigma"><i class="var">Sigma</i></a>)) == <span class="name"><a href="../../../Values/Primitive/Booleans/index.html#Name_false">false</a></span>
--------------------------------------------------------------------------
< <span class="name"><a href="#Name_un-assign">un-assign</a></span>(<span class="name"><a href="#Name_variable">variable</a></span>(<span id="Variable2958_L"><i class="var">L</i></span>:<span class="name"><a href="#Name_locations">locations</a></span>, <span id="Variable2966_T"><i class="var">T</i></span>:<span class="name"><a href="../../../Values/Value-Types/index.html#Name_types">types</a></span>)) , <span class="ent-name"><a href="#Name_store">store</a></span>(<span id="Variable2988_Sigma"><i class="var">Sigma</i></span>) >
---> < <span class="name"><a href="../../Abnormal/Failing/index.html#Name_fail">fail</a></span> , <span class="ent-name"><a href="#Name_store">store</a></span>(<a href="#Variable2988_Sigma"><i class="var">Sigma</i></a>) ></code></pre></div>
#### Structured variables
Structured variables are structured values where some components are
simple variables. Such component variables can be selected using the
same funcons as for selecting components of structured values.
Structured variables containing both simple variables and values correspond
to hybrid structures where particular components are mutable.
All datatypes (except for abstractions) can be used to form structured
variables. So can maps, but not sets or multisets.
Structural generalisations of <code><span class="name"><a href="#Name_assign">assign</a></span>(<i class="var">Var</i>, <i class="var">Val</i>)</code> and
<code><span class="name"><a href="#Name_assigned">assigned</a></span>(<i class="var">Var</i>)</code> access all the simple variables contained in a
structured variable. Assignment requires each component value of a hybrid
structured variable to be equal to the corresponding component of the
structured value.
<div class="highlighter-rouge"><pre class="highlight"><code><i class="keyword">Funcon</i>
<span class="name"><span id="Name_structural-assign">structural-assign</span></span>(_:<span class="name"><a href="../../../Values/Value-Types/index.html#Name_values">values</a></span>, _:<span class="name"><a href="../../../Values/Value-Types/index.html#Name_values">values</a></span>) : =><span class="name"><a href="../../../Values/Primitive/Null/index.html#Name_null-type">null-type</a></span></code></pre></div>
<code><span class="name"><a href="#Name_structural-assign">structural-assign</a></span>(<i class="var">V<sub class="sub">1</sub></i>, <i class="var">V<sub class="sub">2</sub></i>)</code> takes a (potentially) structured variable
<code><i class="var">V<sub class="sub">1</sub></i></code>and a (potentially) structured value <code><i class="var">V<sub class="sub">2</sub></i></code>. Provided that the structure
and all non-variable values in <code><i class="var">V<sub class="sub">1</sub></i></code> match the structure and corresponding
values of <code><i class="var">V<sub class="sub">2</sub></i></code>, all the simple variables in <code><i class="var">V<sub class="sub">1</sub></i></code> are assigned the
corresponding values of <code><i class="var">V<sub class="sub">2</sub></i></code>; otherwise the assignment fails.
<div class="highlighter-rouge"><pre class="highlight"><code><i class="keyword">Rule</i>
<span class="name"><a href="#Name_structural-assign">structural-assign</a></span>(<span id="Variable3274_V1"><i class="var">V<sub class="sub">1</sub></i></span>:<span class="name"><a href="#Name_variables">variables</a></span>, <span id="Variable3283_V2"><i class="var">V<sub class="sub">2</sub></i></span>:<span class="name"><a href="../../../Values/Value-Types/index.html#Name_values">values</a></span>)
~> <span class="name"><a href="#Name_assign">assign</a></span>(<a href="#Variable3274_V1"><i class="var">V<sub class="sub">1</sub></i></a>, <a href="#Variable3283_V2"><i class="var">V<sub class="sub">2</sub></i></a>)
<i class="keyword">Rule</i>
<a href="#Variable3418_V1"><i class="var">V<sub class="sub">1</sub></i></a> : ~(<span class="name"><a href="#Name_variables">variables</a></span>)
<a href="#Variable3418_V1"><i class="var">V<sub class="sub">1</sub></i></a> ~> <span class="name"><a href="../../../Values/Composite/Datatypes/index.html#Name_datatype-value">datatype-value</a></span>(<span id="Variable3346_I1"><i class="var">I<sub class="sub">1</sub></i></span>:<span class="name"><a href="../Binding/index.html#Name_identifiers">identifiers</a></span>, <span id="Variable3356_V1*"><i class="var">V<sub class="sub">1</sub><sup class="sup">*</sup></i></span>:<span class="name"><a href="../../../Values/Value-Types/index.html#Name_values">values</a></span><sup class="sup">*</sup>)
<a href="#Variable3427_V2"><i class="var">V<sub class="sub">2</sub></i></a> ~> <span class="name"><a href="../../../Values/Composite/Datatypes/index.html#Name_datatype-value">datatype-value</a></span>(<span id="Variable3382_I2"><i class="var">I<sub class="sub">2</sub></i></span>:<span class="name"><a href="../Binding/index.html#Name_identifiers">identifiers</a></span>, <span id="Variable3392_V2*"><i class="var">V<sub class="sub">2</sub><sup class="sup">*</sup></i></span>:<span class="name"><a href="../../../Values/Value-Types/index.html#Name_values">values</a></span><sup class="sup">*</sup>)
-----------------------------------------------------------------------
<span class="name"><a href="#Name_structural-assign">structural-assign</a></span>(<span id="Variable3418_V1"><i class="var">V<sub class="sub">1</sub></i></span>:<span class="name"><a href="../../../Values/Composite/Datatypes/index.html#Name_datatype-values">datatype-values</a></span>, <span id="Variable3427_V2"><i class="var">V<sub class="sub">2</sub></i></span>:<span class="name"><a href="../../../Values/Composite/Datatypes/index.html#Name_datatype-values">datatype-values</a></span>)
~> <span class="name"><a href="../Flowing/index.html#Name_sequential">sequential</a></span>(
<span class="name"><a href="../../Abnormal/Failing/index.html#Name_check-true">check-true</a></span>(<span class="name"><a href="../../../Values/Value-Types/index.html#Name_is-equal">is-equal</a></span>(<a href="#Variable3346_I1"><i class="var">I<sub class="sub">1</sub></i></a>, <a href="#Variable3382_I2"><i class="var">I<sub class="sub">2</sub></i></a>)),
<span class="name"><a href="../Flowing/index.html#Name_effect">effect</a></span>(<span class="name"><a href="../../../Values/Composite/Tuples/index.html#Name_tuple">tuple</a></span>(<span class="name"><a href="../Giving/index.html#Name_interleave-map">interleave-map</a></span>(
<span class="name"><a href="#Name_structural-assign">structural-assign</a></span>(<span class="name"><a href="../../../Values/Composite/Tuples/index.html#Name_tuple-elements">tuple-elements</a></span>(<span class="name"><a href="../Giving/index.html#Name_given">given</a></span>)),
<span class="name"><a href="../../../Values/Composite/Tuples/index.html#Name_tuple-zip">tuple-zip</a></span>(<span class="name"><a href="../../../Values/Composite/Tuples/index.html#Name_tuple">tuple</a></span>(<a href="#Variable3356_V1*"><i class="var">V<sub class="sub">1</sub><sup class="sup">*</sup></i></a>), <span class="name"><a href="../../../Values/Composite/Tuples/index.html#Name_tuple">tuple</a></span>(<a href="#Variable3392_V2*"><i class="var">V<sub class="sub">2</sub><sup class="sup">*</sup></i></a>))))),
<span class="name"><a href="../../../Values/Primitive/Null/index.html#Name_null-value">null-value</a></span>)</code></pre></div>
Note that simple variables are datatype values.
<div class="highlighter-rouge"><pre class="highlight"><code><i class="keyword">Rule</i>
<span class="name"><a href="../../../Values/Composite/Maps/index.html#Name_dom">dom</a></span>(<a href="#Variable3587_M1"><i class="var">M<sub class="sub">1</sub></i></a>) == {}
------------------------------------------------------
<span class="name"><a href="#Name_structural-assign">structural-assign</a></span>(<span id="Variable3587_M1"><i class="var">M<sub class="sub">1</sub></i></span>:<span class="name"><a href="../../../Values/Composite/Maps/index.html#Name_maps">maps</a></span>(_,_), <span id="Variable3610_M2"><i class="var">M<sub class="sub">2</sub></i></span>:<span class="name"><a href="../../../Values/Composite/Maps/index.html#Name_maps">maps</a></span>(_,_))
~> <span class="name"><a href="../../Abnormal/Failing/index.html#Name_check-true">check-true</a></span>(<span class="name"><a href="../../../Values/Value-Types/index.html#Name_is-equal">is-equal</a></span>(<span class="name"><a href="../../../Values/Composite/Maps/index.html#Name_dom">dom</a></span>(<a href="#Variable3610_M2"><i class="var">M<sub class="sub">2</sub></i></a>), { }))
<i class="keyword">Rule</i>
<span class="name"><a href="../../../Values/Composite/Sets/index.html#Name_some-element">some-element</a></span>(<span class="name"><a href="../../../Values/Composite/Maps/index.html#Name_dom">dom</a></span>(<a href="#Variable3706_M1"><i class="var">M<sub class="sub">1</sub></i></a>)) ~> <span id="Variable3694_K"><i class="var">K</i></span>
----------------------------------------------------------------------------
<span class="name"><a href="#Name_structural-assign">structural-assign</a></span>(<span id="Variable3706_M1"><i class="var">M<sub class="sub">1</sub></i></span>:<span class="name"><a href="../../../Values/Composite/Maps/index.html#Name_maps">maps</a></span>(_, _), <span id="Variable3729_M2"><i class="var">M<sub class="sub">2</sub></i></span>:<span class="name"><a href="../../../Values/Composite/Maps/index.html#Name_maps">maps</a></span>(_, _))
~> <span class="name"><a href="../Flowing/index.html#Name_sequential">sequential</a></span>(<span class="name"><a href="../../Abnormal/Failing/index.html#Name_check-true">check-true</a></span>(<span class="name"><a href="../../../Values/Composite/Sets/index.html#Name_is-in-set">is-in-set</a></span>(<a href="#Variable3694_K"><i class="var">K</i></a>, <span class="name"><a href="../../../Values/Composite/Maps/index.html#Name_dom">dom</a></span>(<a href="#Variable3729_M2"><i class="var">M<sub class="sub">2</sub></i></a>))),
<span class="name"><a href="#Name_structural-assign">structural-assign</a></span>(<span class="name"><a href="../../../Values/Composite/Maps/index.html#Name_map-lookup">map-lookup</a></span>(<a href="#Variable3706_M1"><i class="var">M<sub class="sub">1</sub></i></a>, <a href="#Variable3694_K"><i class="var">K</i></a>), <span class="name"><a href="../../../Values/Composite/Maps/index.html#Name_map-lookup">map-lookup</a></span>(<a href="#Variable3729_M2"><i class="var">M<sub class="sub">2</sub></i></a>, <a href="#Variable3694_K"><i class="var">K</i></a>)),
<span class="name"><a href="#Name_structural-assign">structural-assign</a></span>(<span class="name"><a href="../../../Values/Composite/Maps/index.html#Name_map-delete">map-delete</a></span>(<a href="#Variable3706_M1"><i class="var">M<sub class="sub">1</sub></i></a>, {<a href="#Variable3694_K"><i class="var">K</i></a>}), <span class="name"><a href="../../../Values/Composite/Maps/index.html#Name_map-delete">map-delete</a></span>(<a href="#Variable3729_M2"><i class="var">M<sub class="sub">2</sub></i></a>, {<a href="#Variable3694_K"><i class="var">K</i></a>})))
<i class="keyword">Rule</i>
<a href="#Variable3945_V1"><i class="var">V<sub class="sub">1</sub></i></a> : ~(<span class="name"><a href="../../../Values/Composite/Datatypes/index.html#Name_datatype-values">datatype-values</a></span>|<span class="name"><a href="../../../Values/Composite/Maps/index.html#Name_maps">maps</a></span>(_, _))
---------------------------------------------------------------
<span class="name"><a href="#Name_structural-assign">structural-assign</a></span>(<span id="Variable3945_V1"><i class="var">V<sub class="sub">1</sub></i></span>:<span class="name"><a href="../../../Values/Value-Types/index.html#Name_values">values</a></span>,<span id="Variable3954_V2"><i class="var">V<sub class="sub">2</sub></i></span>:<span class="name"><a href="../../../Values/Value-Types/index.html#Name_values">values</a></span>)
~> <span class="name"><a href="../../Abnormal/Failing/index.html#Name_check-true">check-true</a></span>(<span class="name"><a href="../../../Values/Value-Types/index.html#Name_is-equal">is-equal</a></span>(<a href="#Variable3945_V1"><i class="var">V<sub class="sub">1</sub></i></a>, <a href="#Variable3954_V2"><i class="var">V<sub class="sub">2</sub></i></a>))</code></pre></div>
<div class="highlighter-rouge"><pre class="highlight"><code><i class="keyword">Funcon</i>
<span class="name"><span id="Name_structural-assigned">structural-assigned</span></span>(_:<span class="name"><a href="../../../Values/Value-Types/index.html#Name_values">values</a></span>) : =><span class="name"><a href="../../../Values/Value-Types/index.html#Name_values">values</a></span></code></pre></div>
<code><span class="name"><a href="#Name_structural-assigned">structural-assigned</a></span>(<i class="var">V</i>)</code> takes a (potentially) structured variable <code><i class="var">V</i></code>,
and computes the value of <code><i class="var">V</i></code> with all simple variables in <code><i class="var">V</i></code> replaced by
their assigned values, failing if any of them do not have assigned values.
When <code><i class="var">V</i></code> is just a simple variable or a (possibly structured) value with no
component variables, <code><span class="name"><a href="#Name_structural-assigned">structural-assigned</a></span>(<i class="var">V</i>)</code> gives the same result as
<code><span class="name"><a href="#Name_current-value">current-value</a></span>(<i class="var">V</i>)</code>.
<div class="highlighter-rouge"><pre class="highlight"><code><i class="keyword">Rule</i>
<span class="name"><a href="#Name_structural-assigned">structural-assigned</a></span>(<span id="Variable4138_Var"><i class="var">Var</i></span>:<span class="name"><a href="#Name_variables">variables</a></span>) ~> <span class="name"><a href="#Name_assigned">assigned</a></span>(<a href="#Variable4138_Var"><i class="var">Var</i></a>)
<i class="keyword">Rule</i>
<a href="#Variable4222_V"><i class="var">V</i></a> : ~(<span class="name"><a href="#Name_variables">variables</a></span>)
<a href="#Variable4222_V"><i class="var">V</i></a> ~> <span class="name"><a href="../../../Values/Composite/Datatypes/index.html#Name_datatype-value">datatype-value</a></span>(<span id="Variable4189_I"><i class="var">I</i></span>:<span class="name"><a href="../Binding/index.html#Name_identifiers">identifiers</a></span>, <span id="Variable4198_V*"><i class="var">V<sup class="sup">*</sup></i></span>:<span class="name"><a href="../../../Values/Value-Types/index.html#Name_values">values</a></span><sup class="sup">*</sup>)
----------------------------------------------------------------------------
<span class="name"><a href="#Name_structural-assigned">structural-assigned</a></span>(<span id="Variable4222_V"><i class="var">V</i></span>:<span class="name"><a href="../../../Values/Composite/Datatypes/index.html#Name_datatype-values">datatype-values</a></span>)
~> <span class="name"><a href="../../../Values/Composite/Datatypes/index.html#Name_datatype-value">datatype-value</a></span>(<a href="#Variable4189_I"><i class="var">I</i></a>, <span class="name"><a href="../Giving/index.html#Name_interleave-map">interleave-map</a></span>(<span class="name"><a href="#Name_structural-assigned">structural-assigned</a></span>(<span class="name"><a href="../Giving/index.html#Name_given">given</a></span>), <a href="#Variable4198_V*"><i class="var">V<sup class="sup">*</sup></i></a>))</code></pre></div>
Note that simple variables are datatype values.
<div class="highlighter-rouge"><pre class="highlight"><code><i class="keyword">Rule</i>
<span class="name"><a href="#Name_structural-assigned">structural-assigned</a></span>(<span id="Variable4282_M"><i class="var">M</i></span>:<span class="name"><a href="../../../Values/Composite/Maps/index.html#Name_maps">maps</a></span>(_, _))
~> <span class="name"><a href="../../../Values/Composite/Maps/index.html#Name_map">map</a></span>(<span class="name"><a href="../Giving/index.html#Name_interleave-map">interleave-map</a></span>(<span class="name"><a href="#Name_structural-assigned">structural-assigned</a></span>(<span class="name"><a href="../Giving/index.html#Name_given">given</a></span>), <span class="name"><a href="../../../Values/Composite/Maps/index.html#Name_map-elements">map-elements</a></span>(<a href="#Variable4282_M"><i class="var">M</i></a>)))
<i class="keyword">Rule</i>
<a href="#Variable4387_U"><i class="var">U</i></a> : ~(<span class="name"><a href="../../../Values/Composite/Datatypes/index.html#Name_datatype-values">datatype-values</a></span>|<span class="name"><a href="../../../Values/Composite/Maps/index.html#Name_maps">maps</a></span>(_, _))
------------------------------------------
<span class="name"><a href="#Name_structural-assigned">structural-assigned</a></span>(<span id="Variable4387_U"><i class="var">U</i></span>:<span class="name"><a href="../../../Values/Value-Types/index.html#Name_values">values</a></span>) ~> <a href="#Variable4387_U"><i class="var">U</i></a></code></pre></div>
____
From the [PLanCompS Project] | [CBS-beta issues...] | [Suggest an improvement...]
[Storing.cbs]: Storing.cbs
"CBS SOURCE FILE"
[Funcons-beta]: /CBS-beta/docs/Funcons-beta
"FUNCONS-BETA"
[Unstable-Funcons-beta]: /CBS-beta/docs/Unstable-Funcons-beta
"UNSTABLE-FUNCONS-BETA"
[Languages-beta]: /CBS-beta/docs/Languages-beta
"LANGUAGES-BETA"
[Unstable-Languages-beta]: /CBS-beta/docs/Unstable-Languages-beta
"UNSTABLE-LANGUAGES-BETA"
[CBS-beta]: /CBS-beta "CBS-BETA"
[PLanCompS Project]: https://plancomps.github.io
"PROGRAMMING LANGUAGE COMPONENTS AND SPECIFICATIONS PROJECT HOME PAGE"
[CBS-beta issues...]: https://github.com/plancomps/CBS-beta/issues
"CBS-BETA ISSUE REPORTS ON GITHUB"
[Suggest an improvement...]: mailto:plancomps@gmail.com?Subject=CBS-beta%20-%20comment&Body=Re%3A%20CBS-beta%20specification%20at%20Computations/Normal/Storing/Storing.cbs%0A%0AComment/Query/Issue/Suggestion%3A%0A%0A%0ASignature%3A%0A
"GENERATE AN EMAIL TEMPLATE"

12
IBAF-cbs/Funcons-beta/Computations/Normal/Storing/tests/allocate-initialised-variable.config Normal file
View File

@@ -0,0 +1,12 @@
general {
funcon-term:
initialise-storing
give(
allocate-initialised-variable(booleans,true),
check-true(assigned(given)))
;
}
tests {
result-term: null-value;
}

10
IBAF-cbs/Funcons-beta/Computations/Normal/Storing/tests/allocate-variable.config Normal file
View File

@@ -0,0 +1,10 @@
general {
funcon-term:
initialise-storing
not is-equal(allocate-variable(values), allocate-variable(values))
;
}
tests {
result-term: true;
}

15
IBAF-cbs/Funcons-beta/Computations/Normal/Storing/tests/assign.config Normal file
View File

@@ -0,0 +1,15 @@
general {
funcon-term:
initialise-storing
give(
allocate-initialised-variable(booleans,false),
sequential(
assign(given,true),
else(assign(given,42), print"OK")))
;
}
tests {
result-term: null-value;
standard-out: ["OK"];
}

16
IBAF-cbs/Funcons-beta/Computations/Normal/Storing/tests/assigned.config Normal file
View File

@@ -0,0 +1,16 @@
general {
funcon-term:
initialise-storing
give(
allocate-initialised-variable(booleans,true),
sequential(
check-true assigned(given),
store-clear,
else(assigned(given), print"OK")))
;
}
tests {
result-term: null-value;
standard-out: ["OK"];
}

29
IBAF-cbs/Funcons-beta/Computations/Normal/Storing/tests/current-value-2.config Normal file
View File

@@ -0,0 +1,29 @@
general {
funcon-term:
initialise-storing
give(
{ "a" |-> allocate-initialised-variable(booleans,false),
"b" |-> 42,
"c" |-> allocate-initialised-variable(booleans,true),
"d" |-> 13 },
sequential(
check-true is-equal(
current-value(map()),
map()),
check-true is-equal(
current-value(given),
{"a"|->variable(atom("@1"), booleans),"b"|->42
,"c"|->variable(atom("@2"), booleans),"d"|->13}),
check-true is-equal(
current-value(lookup(given,"a")),false),
check-true is-equal(
current-value(lookup(given,"c")),true),
check-true is-equal(
current-value{42},
{42})))
;
}
tests {
result-term: null-value;
}

14
IBAF-cbs/Funcons-beta/Computations/Normal/Storing/tests/current-value.config Normal file
View File

@@ -0,0 +1,14 @@
general {
funcon-term:
initialise-storing
sequential(
check-true is-equal(
current-value(allocate-initialised-variable(integers,42)),
42),
check-true is-equal(current-value(42), 42))
;
}
tests {
result-term: null-value;
}

10
IBAF-cbs/Funcons-beta/Computations/Normal/Storing/tests/initialise-storing.config Normal file
View File

@@ -0,0 +1,10 @@
general {
funcon-term:
initialise-storing(print"OK")
;
}
tests {
result-term: null-value;
standard-out: ["OK"];
}

Some files were not shown because too many files have changed in this diff Show More