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

155
IBAF-cbs/Funcons-beta/Values/Composite/Sets/Sets.cbs Normal file
View File

@@ -0,0 +1,155 @@
### Sets
[
Type sets
Funcon set
Funcon set-elements
Funcon is-in-set
Funcon is-subset
Funcon set-insert
Funcon set-unite
Funcon set-intersect
Funcon set-difference
Funcon set-size
Funcon some-element
Funcon element-not-in
]
Meta-variables
GT <: ground-values
Built-in Type
sets(GT)
/*
`sets(GT)` is the type of possibly-empty finite sets `{V1, ..., Vn}`
where `V1:GT`, ..., `Vn:GT`.
*/
Built-in Funcon
set(_:(GT)*) : =>sets(GT)
/*
The notation `{V1, ..., Vn}` for `set(V1, ..., Vn)` is built-in.
*/
Assert
{V*:(GT)*} == set(V*)
/*
Note that `set(...)` is not a constructor operation. The order and duplicates
of argument values are ignored (e.g., `{1,2,1}` denotes the same set as `{1,2}`
and `{2,1}`).
*/
Built-in Funcon
set-elements(_:sets(GT)) : =>(GT)*
/*
For each set `S`, the sequence of values `V*` returned by `set-elements(S)`
contains each element of `S` just once. The order of the values in `V*` is
unspecified, and may vary between sets (e.g., `set-elements{1,2}` could be
`(1,2)` and `set-elements{1,2,3}` could be `(3,2,1)`).
*/
Assert
set(set-elements(S)) == S
Built-in Funcon
is-in-set(_:GT, _:sets(GT)) : =>booleans
/*
`is-in-set(GV,S)` tests whether `GV` is in the set `S`.
*/
Assert
is-in-set(GV:GT, { }) == false
Assert
is-in-set(GV:GT, {GV}:sets(GT)) == true
Built-in Funcon
is-subset(_:sets(GT), _:sets(GT)) : =>booleans
/*
`is-subset(S1,S2)` tests whether `S1` is a subset of `S2`.
*/
Assert
is-subset({ }, S:sets(GT)) == true
Assert
is-subset(S:sets(GT), S) == true
Built-in Funcon
set-insert(_:GT, _:sets(GT)) : =>sets(GT)
/*
`set-insert(GV, S)` returns the set union of `{GV}` and `S`.
*/
Assert
is-in-set(GV:GT, set-insert(GV:GT, S:sets(GT))) == true
Built-in Funcon
set-unite(_:(sets(GT))*) : =>sets(GT)
/*
`set-unite(...)` unites a sequence of sets.
*/
Assert
set-unite(S:sets(GT), S) == S
Assert
set-unite(S1:sets(GT), S2:sets(GT)) == set-unite(S2, S1)
Assert
set-unite(S1:sets(GT), set-unite(S2:sets(GT), S3:sets(GT))) ==
set-unite(set-unite(S1, S2), S3)
Assert
set-unite(S1:sets(GT), S2:sets(GT), S3:sets(GT)) ==
set-unite(S1, set-unite(S2, S3))
Assert
set-unite(S:sets(GT)) == S
Assert
set-unite( ) == { }
Built-in Funcon
set-intersect(_:(sets(GT))+) : =>sets(GT)
/*
`set-intersect(GT,...)` intersects a non-empty sequence of sets.
*/
Assert
set-intersect(S:sets(GT), S) == S
Assert
set-intersect(S1:sets(GT), S2:sets(GT)) == set-intersect(S2, S1)
Assert
set-intersect(S1:sets(GT), set-intersect(S2:sets(GT), S3:sets(GT))) ==
set-intersect(set-intersect(S1, S2), S3)
Assert
set-intersect(S1:sets(GT), S2:sets(GT), S3:sets(GT)) ==
set-intersect(S1, set-intersect(S2, S3))
Assert
set-intersect(S:sets(GT)) == S
Built-in Funcon
set-difference(_:sets(GT), _:sets(GT)) : =>sets(GT)
/*
`set-difference(S1, S2)` returns the set containing those elements of `S1`
that are not in `S2`.
*/
Built-in Funcon
set-size(_:sets(GT)) : =>natural-numbers
Assert
set-size(S:sets(GT)) == length(set-elements(S))
Funcon
some-element(_:sets(GT)) : =>GT?
Assert
some-element(S:sets(GT)) == index(1, set-elements(S))
Assert
some-element{ } == ( )
Built-in Funcon
element-not-in(GT:types, _:set(GT)) : =>GT?
/*
`element-not-in(GT, S)` gives an element of the type `GT` not in the set
`S`, or `( )` when `S` is empty. When the set of elements of `GT` is infinite,
`element-not-in(GT, S)` never gives `( )`.
*/

198
IBAF-cbs/Funcons-beta/Values/Composite/Sets/index.md Normal file
View File

@@ -0,0 +1,198 @@
---
layout: default
title: "Sets"
parent: Composite
ancestor: Funcons-beta
---
[Funcons-beta] : [Sets.cbs]
-----------------------------
### Sets
<div class="highlighter-rouge"><pre class="highlight"><code>[
<i class="keyword">Type</i> <span class="name"><a href="#Name_sets">sets</a></span>
<i class="keyword">Funcon</i> <span class="name"><a href="#Name_set">set</a></span>
<i class="keyword">Funcon</i> <span class="name"><a href="#Name_set-elements">set-elements</a></span>
<i class="keyword">Funcon</i> <span class="name"><a href="#Name_is-in-set">is-in-set</a></span>
<i class="keyword">Funcon</i> <span class="name"><a href="#Name_is-subset">is-subset</a></span>
<i class="keyword">Funcon</i> <span class="name"><a href="#Name_set-insert">set-insert</a></span>
<i class="keyword">Funcon</i> <span class="name"><a href="#Name_set-unite">set-unite</a></span>
<i class="keyword">Funcon</i> <span class="name"><a href="#Name_set-intersect">set-intersect</a></span>
<i class="keyword">Funcon</i> <span class="name"><a href="#Name_set-difference">set-difference</a></span>
<i class="keyword">Funcon</i> <span class="name"><a href="#Name_set-size">set-size</a></span>
<i class="keyword">Funcon</i> <span class="name"><a href="#Name_some-element">some-element</a></span>
<i class="keyword">Funcon</i> <span class="name"><a href="#Name_element-not-in">element-not-in</a></span>
]</code></pre></div>
<div class="highlighter-rouge"><pre class="highlight"><code><i class="keyword">Meta-variables</i>
<span id="PartVariable_GT"><i class="var">GT</i></span> <: <span class="name"><a href="../../Value-Types/index.html#Name_ground-values">ground-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_sets">sets</span></span>(<span id="Variable76_GT"><i class="var">GT</i></span>)</code></pre></div>
<code><span class="name"><a href="#Name_sets">sets</a></span>(<i class="var">GT</i>)</code> is the type of possibly-empty finite sets <code>{<i class="var">V<sub class="sub">1</sub></i>, ..., <i class="var">Vn</i>}</code>
where <code><i class="var">V<sub class="sub">1</sub></i>:<i class="var">GT</i></code>, ..., <code><i class="var">Vn</i>:<i class="var">GT</i></code>.
<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_set">set</span></span>(_:(<span id="Variable190_GT"><i class="var">GT</i></span>)<sup class="sup">*</sup>) : =><span class="name"><a href="#Name_sets">sets</a></span>(<span id="Variable212_GT"><i class="var">GT</i></span>)</code></pre></div>
The notation <code>{<i class="var">V<sub class="sub">1</sub></i>, ..., <i class="var">Vn</i>}</code> for <code><span class="name"><a href="#Name_set">set</a></span>(<i class="var">V<sub class="sub">1</sub></i>, ..., <i class="var">Vn</i>)</code> is built-in.
<div class="highlighter-rouge"><pre class="highlight"><code><i class="keyword">Assert</i>
{<i class="var">V<sup class="sup">*</sup></i>:(<i class="var">GT</i>)<sup class="sup">*</sup>} == <span class="name"><a href="#Name_set">set</a></span>(<i class="var">V<sup class="sup">*</sup></i>)</code></pre></div>
Note that <code><span class="name"><a href="#Name_set">set</a></span>(...)</code> is not a constructor operation. The order and duplicates
of argument values are ignored (e.g., <code>{1,2,1}</code> denotes the same set as <code>{1,2}</code>
and <code>{2,1}</code>).
<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_set-elements">set-elements</span></span>(_:<span class="name"><a href="#Name_sets">sets</a></span>(<span id="Variable418_GT"><i class="var">GT</i></span>)) : =>(<span id="Variable438_GT"><i class="var">GT</i></span>)<sup class="sup">*</sup></code></pre></div>
For each set <code><i class="var">S</i></code>, the sequence of values <code><i class="var">V<sup class="sup">*</sup></i></code> returned by <code><span class="name"><a href="#Name_set-elements">set-elements</a></span>(<i class="var">S</i>)</code>
contains each element of <code><i class="var">S</i></code> just once. The order of the values in <code><i class="var">V<sup class="sup">*</sup></i></code> is
unspecified, and may vary between sets (e.g., <code><span class="name"><a href="#Name_set-elements">set-elements</a></span>{1,2}</code> could be
<code>(1,2)</code> and <code><span class="name"><a href="#Name_set-elements">set-elements</a></span>{1,2,3}</code> could be <code>(3,2,1)</code>).
<div class="highlighter-rouge"><pre class="highlight"><code><i class="keyword">Assert</i>
<span class="name"><a href="#Name_set">set</a></span>(<span class="name"><a href="#Name_set-elements">set-elements</a></span>(<i class="var">S</i>)) == <i class="var">S</i></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_is-in-set">is-in-set</span></span>(_:<span id="Variable646_GT"><i class="var">GT</i></span>, _:<span class="name"><a href="#Name_sets">sets</a></span>(<span id="Variable658_GT"><i class="var">GT</i></span>)) : =><span class="name"><a href="../../Primitive/Booleans/index.html#Name_booleans">booleans</a></span></code></pre></div>
<code><span class="name"><a href="#Name_is-in-set">is-in-set</a></span>(<i class="var">GV</i>,<i class="var">S</i>)</code> tests whether <code><i class="var">GV</i></code> is in the set <code><i class="var">S</i></code>.
<div class="highlighter-rouge"><pre class="highlight"><code><i class="keyword">Assert</i>
<span class="name"><a href="#Name_is-in-set">is-in-set</a></span>(<i class="var">GV</i>:<i class="var">GT</i>, { }) == <span class="name"><a href="../../Primitive/Booleans/index.html#Name_false">false</a></span>
<i class="keyword">Assert</i>
<span class="name"><a href="#Name_is-in-set">is-in-set</a></span>(<i class="var">GV</i>:<i class="var">GT</i>, {<i class="var">GV</i>}:<span class="name"><a href="#Name_sets">sets</a></span>(<i class="var">GT</i>)) == <span class="name"><a href="../../Primitive/Booleans/index.html#Name_true">true</a></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_is-subset">is-subset</span></span>(_:<span class="name"><a href="#Name_sets">sets</a></span>(<span id="Variable821_GT"><i class="var">GT</i></span>), _:<span class="name"><a href="#Name_sets">sets</a></span>(<span id="Variable839_GT"><i class="var">GT</i></span>)) : =><span class="name"><a href="../../Primitive/Booleans/index.html#Name_booleans">booleans</a></span></code></pre></div>
<code><span class="name"><a href="#Name_is-subset">is-subset</a></span>(<i class="var">S<sub class="sub">1</sub></i>,<i class="var">S<sub class="sub">2</sub></i>)</code> tests whether <code><i class="var">S<sub class="sub">1</sub></i></code> is a subset of <code><i class="var">S<sub class="sub">2</sub></i></code>.
<div class="highlighter-rouge"><pre class="highlight"><code><i class="keyword">Assert</i>
<span class="name"><a href="#Name_is-subset">is-subset</a></span>({ }, <i class="var">S</i>:<span class="name"><a href="#Name_sets">sets</a></span>(<i class="var">GT</i>)) == <span class="name"><a href="../../Primitive/Booleans/index.html#Name_true">true</a></span>
<i class="keyword">Assert</i>
<span class="name"><a href="#Name_is-subset">is-subset</a></span>(<i class="var">S</i>:<span class="name"><a href="#Name_sets">sets</a></span>(<i class="var">GT</i>), <i class="var">S</i>) == <span class="name"><a href="../../Primitive/Booleans/index.html#Name_true">true</a></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_set-insert">set-insert</span></span>(_:<span id="Variable1001_GT"><i class="var">GT</i></span>, _:<span class="name"><a href="#Name_sets">sets</a></span>(<span id="Variable1013_GT"><i class="var">GT</i></span>)) : =><span class="name"><a href="#Name_sets">sets</a></span>(<span id="Variable1035_GT"><i class="var">GT</i></span>)</code></pre></div>
<code><span class="name"><a href="#Name_set-insert">set-insert</a></span>(<i class="var">GV</i>, <i class="var">S</i>)</code> returns the set union of <code>{<i class="var">GV</i>}</code> and <code><i class="var">S</i></code>.
<div class="highlighter-rouge"><pre class="highlight"><code><i class="keyword">Assert</i>
<span class="name"><a href="#Name_is-in-set">is-in-set</a></span>(<i class="var">GV</i>:<i class="var">GT</i>, <span class="name"><a href="#Name_set-insert">set-insert</a></span>(<i class="var">GV</i>:<i class="var">GT</i>, <i class="var">S</i>:<span class="name"><a href="#Name_sets">sets</a></span>(<i class="var">GT</i>))) == <span class="name"><a href="../../Primitive/Booleans/index.html#Name_true">true</a></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_set-unite">set-unite</span></span>(_:(<span class="name"><a href="#Name_sets">sets</a></span>(<span id="Variable1178_GT"><i class="var">GT</i></span>))<sup class="sup">*</sup>) : =><span class="name"><a href="#Name_sets">sets</a></span>(<span id="Variable1206_GT"><i class="var">GT</i></span>)</code></pre></div>
<code><span class="name"><a href="#Name_set-unite">set-unite</a></span>(...)</code> unites a sequence of sets.
<div class="highlighter-rouge"><pre class="highlight"><code><i class="keyword">Assert</i>
<span class="name"><a href="#Name_set-unite">set-unite</a></span>(<i class="var">S</i>:<span class="name"><a href="#Name_sets">sets</a></span>(<i class="var">GT</i>), <i class="var">S</i>) == <i class="var">S</i>
<i class="keyword">Assert</i>
<span class="name"><a href="#Name_set-unite">set-unite</a></span>(<i class="var">S<sub class="sub">1</sub></i>:<span class="name"><a href="#Name_sets">sets</a></span>(<i class="var">GT</i>), <i class="var">S<sub class="sub">2</sub></i>:<span class="name"><a href="#Name_sets">sets</a></span>(<i class="var">GT</i>)) == <span class="name"><a href="#Name_set-unite">set-unite</a></span>(<i class="var">S<sub class="sub">2</sub></i>, <i class="var">S<sub class="sub">1</sub></i>)
<i class="keyword">Assert</i>
<span class="name"><a href="#Name_set-unite">set-unite</a></span>(<i class="var">S<sub class="sub">1</sub></i>:<span class="name"><a href="#Name_sets">sets</a></span>(<i class="var">GT</i>), <span class="name"><a href="#Name_set-unite">set-unite</a></span>(<i class="var">S<sub class="sub">2</sub></i>:<span class="name"><a href="#Name_sets">sets</a></span>(<i class="var">GT</i>), <i class="var">S<sub class="sub">3</sub></i>:<span class="name"><a href="#Name_sets">sets</a></span>(<i class="var">GT</i>))) ==
<span class="name"><a href="#Name_set-unite">set-unite</a></span>(<span class="name"><a href="#Name_set-unite">set-unite</a></span>(<i class="var">S<sub class="sub">1</sub></i>, <i class="var">S<sub class="sub">2</sub></i>), <i class="var">S<sub class="sub">3</sub></i>)
<i class="keyword">Assert</i>
<span class="name"><a href="#Name_set-unite">set-unite</a></span>(<i class="var">S<sub class="sub">1</sub></i>:<span class="name"><a href="#Name_sets">sets</a></span>(<i class="var">GT</i>), <i class="var">S<sub class="sub">2</sub></i>:<span class="name"><a href="#Name_sets">sets</a></span>(<i class="var">GT</i>), <i class="var">S<sub class="sub">3</sub></i>:<span class="name"><a href="#Name_sets">sets</a></span>(<i class="var">GT</i>)) ==
<span class="name"><a href="#Name_set-unite">set-unite</a></span>(<i class="var">S<sub class="sub">1</sub></i>, <span class="name"><a href="#Name_set-unite">set-unite</a></span>(<i class="var">S<sub class="sub">2</sub></i>, <i class="var">S<sub class="sub">3</sub></i>))
<i class="keyword">Assert</i>
<span class="name"><a href="#Name_set-unite">set-unite</a></span>(<i class="var">S</i>:<span class="name"><a href="#Name_sets">sets</a></span>(<i class="var">GT</i>)) == <i class="var">S</i>
<i class="keyword">Assert</i>
<span class="name"><a href="#Name_set-unite">set-unite</a></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_set-intersect">set-intersect</span></span>(_:(<span class="name"><a href="#Name_sets">sets</a></span>(<span id="Variable1611_GT"><i class="var">GT</i></span>))<sup class="sup">+</sup>) : =><span class="name"><a href="#Name_sets">sets</a></span>(<span id="Variable1639_GT"><i class="var">GT</i></span>)</code></pre></div>
<code><span class="name"><a href="#Name_set-intersect">set-intersect</a></span>(<i class="var">GT</i>,...)</code> intersects a non-empty sequence of sets.
<div class="highlighter-rouge"><pre class="highlight"><code><i class="keyword">Assert</i>
<span class="name"><a href="#Name_set-intersect">set-intersect</a></span>(<i class="var">S</i>:<span class="name"><a href="#Name_sets">sets</a></span>(<i class="var">GT</i>), <i class="var">S</i>) == <i class="var">S</i>
<i class="keyword">Assert</i>
<span class="name"><a href="#Name_set-intersect">set-intersect</a></span>(<i class="var">S<sub class="sub">1</sub></i>:<span class="name"><a href="#Name_sets">sets</a></span>(<i class="var">GT</i>), <i class="var">S<sub class="sub">2</sub></i>:<span class="name"><a href="#Name_sets">sets</a></span>(<i class="var">GT</i>)) == <span class="name"><a href="#Name_set-intersect">set-intersect</a></span>(<i class="var">S<sub class="sub">2</sub></i>, <i class="var">S<sub class="sub">1</sub></i>)
<i class="keyword">Assert</i>
<span class="name"><a href="#Name_set-intersect">set-intersect</a></span>(<i class="var">S<sub class="sub">1</sub></i>:<span class="name"><a href="#Name_sets">sets</a></span>(<i class="var">GT</i>), <span class="name"><a href="#Name_set-intersect">set-intersect</a></span>(<i class="var">S<sub class="sub">2</sub></i>:<span class="name"><a href="#Name_sets">sets</a></span>(<i class="var">GT</i>), <i class="var">S<sub class="sub">3</sub></i>:<span class="name"><a href="#Name_sets">sets</a></span>(<i class="var">GT</i>))) ==
<span class="name"><a href="#Name_set-intersect">set-intersect</a></span>(<span class="name"><a href="#Name_set-intersect">set-intersect</a></span>(<i class="var">S<sub class="sub">1</sub></i>, <i class="var">S<sub class="sub">2</sub></i>), <i class="var">S<sub class="sub">3</sub></i>)
<i class="keyword">Assert</i>
<span class="name"><a href="#Name_set-intersect">set-intersect</a></span>(<i class="var">S<sub class="sub">1</sub></i>:<span class="name"><a href="#Name_sets">sets</a></span>(<i class="var">GT</i>), <i class="var">S<sub class="sub">2</sub></i>:<span class="name"><a href="#Name_sets">sets</a></span>(<i class="var">GT</i>), <i class="var">S<sub class="sub">3</sub></i>:<span class="name"><a href="#Name_sets">sets</a></span>(<i class="var">GT</i>)) ==
<span class="name"><a href="#Name_set-intersect">set-intersect</a></span>(<i class="var">S<sub class="sub">1</sub></i>, <span class="name"><a href="#Name_set-intersect">set-intersect</a></span>(<i class="var">S<sub class="sub">2</sub></i>, <i class="var">S<sub class="sub">3</sub></i>))
<i class="keyword">Assert</i>
<span class="name"><a href="#Name_set-intersect">set-intersect</a></span>(<i class="var">S</i>:<span class="name"><a href="#Name_sets">sets</a></span>(<i class="var">GT</i>)) == <i class="var">S</i></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_set-difference">set-difference</span></span>(_:<span class="name"><a href="#Name_sets">sets</a></span>(<span id="Variable2038_GT"><i class="var">GT</i></span>), _:<span class="name"><a href="#Name_sets">sets</a></span>(<span id="Variable2056_GT"><i class="var">GT</i></span>)) : =><span class="name"><a href="#Name_sets">sets</a></span>(<span id="Variable2078_GT"><i class="var">GT</i></span>)</code></pre></div>
<code><span class="name"><a href="#Name_set-difference">set-difference</a></span>(<i class="var">S<sub class="sub">1</sub></i>, <i class="var">S<sub class="sub">2</sub></i>)</code> returns the set containing those elements of <code><i class="var">S<sub class="sub">1</sub></i></code>
that are not in <code><i class="var">S<sub class="sub">2</sub></i></code>.
<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_set-size">set-size</span></span>(_:<span class="name"><a href="#Name_sets">sets</a></span>(<span id="Variable2160_GT"><i class="var">GT</i></span>)) : =><span class="name"><a href="../../Primitive/Integers/index.html#Name_natural-numbers">natural-numbers</a></span></code></pre></div>
<div class="highlighter-rouge"><pre class="highlight"><code><i class="keyword">Assert</i>
<span class="name"><a href="#Name_set-size">set-size</a></span>(<i class="var">S</i>:<span class="name"><a href="#Name_sets">sets</a></span>(<i class="var">GT</i>)) == <span class="name"><a href="../Sequences/index.html#Name_length">length</a></span>(<span class="name"><a href="#Name_set-elements">set-elements</a></span>(<i class="var">S</i>))</code></pre></div>
<div class="highlighter-rouge"><pre class="highlight"><code><i class="keyword">Funcon</i>
<span class="name"><span id="Name_some-element">some-element</span></span>(_:<span class="name"><a href="#Name_sets">sets</a></span>(<span id="Variable2237_GT"><i class="var">GT</i></span>)) : =><span id="Variable2258_GT?"><i class="var">GT<sup class="sup">?</sup></i></span>
<i class="keyword">Assert</i>
<span class="name"><a href="#Name_some-element">some-element</a></span>(<i class="var">S</i>:<span class="name"><a href="#Name_sets">sets</a></span>(<i class="var">GT</i>)) == <span class="name"><a href="../Sequences/index.html#Name_index">index</a></span>(1, <span class="name"><a href="#Name_set-elements">set-elements</a></span>(<i class="var">S</i>))
<i class="keyword">Assert</i>
<span class="name"><a href="#Name_some-element">some-element</a></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_element-not-in">element-not-in</span></span>(<span id="Variable2328_GT"><i class="var">GT</i></span>:<span class="name"><a href="../../Value-Types/index.html#Name_types">types</a></span>, _:<span class="name"><a href="#Name_set">set</a></span>(<span id="Variable2341_GT"><i class="var">GT</i></span>)) : =><span id="Variable2363_GT?"><i class="var">GT<sup class="sup">?</sup></i></span></code></pre></div>
<code><span class="name"><a href="#Name_element-not-in">element-not-in</a></span>(<i class="var">GT</i>, <i class="var">S</i>)</code> gives an element of the type <code><i class="var">GT</i></code> not in the set
<code><i class="var">S</i></code>, or <code>( )</code> when <code><i class="var">S</i></code> is empty. When the set of elements of <code><i class="var">GT</i></code> is infinite,
<code><span class="name"><a href="#Name_element-not-in">element-not-in</a></span>(<i class="var">GT</i>, <i class="var">S</i>)</code> never gives <code>( )</code>.
____
From the [PLanCompS Project] | [CBS-beta issues...] | [Suggest an improvement...]
[Sets.cbs]: Sets.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%20Values/Composite/Sets/Sets.cbs%0A%0AComment/Query/Issue/Suggestion%3A%0A%0A%0ASignature%3A%0A
"GENERATE AN EMAIL TEMPLATE"

27
IBAF-cbs/Funcons-beta/Values/Composite/Sets/tests/set-difference.config Normal file
View File

@@ -0,0 +1,27 @@
general {
funcon-term:
initialise-giving finalise-failing
sequential (
print set-difference({1},set()),
print set-difference(set(),{2}),
print set-difference({1},{2}),
print set-difference({1,2},{1,2}),
print set-difference({1,2},{1}),
print set-difference({1,2},set()),
print "OK"
)
;
}
tests {
result-term: null-value;
standard-out: [
{1},
{},
{1},
{},
{2},
{1,2},
"OK"
];
}

15
IBAF-cbs/Funcons-beta/Values/Composite/Sets/tests/set-elements.config Normal file
View File

@@ -0,0 +1,15 @@
general {
funcon-term:
initialise-giving finalise-failing
sequential (
print tuple(set-elements set( )),
print tuple(set-elements {1}),
print tuple(set-elements {2,3})
)
;
}
tests {
result-term: null-value;
standard-out: [tuple(), tuple(1), tuple(2, 3) ];
}

27
IBAF-cbs/Funcons-beta/Values/Composite/Sets/tests/set-unite.config Normal file
View File

@@ -0,0 +1,27 @@
general {
funcon-term:
initialise-giving finalise-failing
sequential (
print set-unite({1},set()),
print set-unite(set(),{2}),
print set-unite({1},{2}),
print set-unite({1}),
print set-unite(set()),
print set-unite(),
print "OK"
)
;
}
tests {
result-term: null-value;
standard-out: [
{1},
{2},
{1,2},
{1},
set(),
set(),
"OK"
];
}

21
IBAF-cbs/Funcons-beta/Values/Composite/Sets/tests/set.config Normal file
View File

@@ -0,0 +1,21 @@
general {
funcon-term:
initialise-giving finalise-failing
sequential (
print set(),
print {1},
print {1,2,3},
print cast({1,2}, sets(integers))
)
;
}
tests {
result-term: null-value;
standard-out: [
set(),
{1},
{1, 2, 3},
{1, 2}
];
}

15
IBAF-cbs/Funcons-beta/Values/Composite/Sets/tests/some-element.config Normal file
View File

@@ -0,0 +1,15 @@
general {
funcon-term:
initialise-giving finalise-failing
sequential (
print some-element {1},
print some-element {1,2},
print some-element {1,2,3}
)
;
}
tests {
result-term: null-value;
standard-out: [1, 1, 1];
}