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

110
IBAF-cbs/Funcons-beta/Values/Composite/Bits/Bits.cbs Normal file
View File

@@ -0,0 +1,110 @@
### Bits and bit vectors
[
Type bits
Datatype bit-vectors
Funcon bit-vector
Type bytes Alias octets
Funcon bit-vector-not
Funcon bit-vector-and
Funcon bit-vector-or
Funcon bit-vector-xor
Funcon bit-vector-shift-left
Funcon bit-vector-logical-shift-right
Funcon bit-vector-arithmetic-shift-right
Funcon integer-to-bit-vector
Funcon bit-vector-to-integer
Funcon bit-vector-to-natural
Funcon unsigned-bit-vector-maximum
Funcon signed-bit-vector-maximum
Funcon signed-bit-vector-minimum
Funcon is-in-signed-bit-vector
Funcon is-in-unsigned-bit-vector
]
#### Bits
Type
bits ~> booleans
/*
`false` represents the absence of a bit, `true` its presence.
*/
#### Bit vectors
Datatype
bit-vectors(N:natural-numbers) ::= bit-vector(_:bits^N)
Type
bytes ~> bit-vectors(8)
Alias
octets = bytes
Meta-variables
BT <: bit-vectors(_)
Built-in Funcon
bit-vector-not(_:BT) : =>BT
Built-in Funcon
bit-vector-and(_:BT, _:BT) : =>BT
Built-in Funcon
bit-vector-or(_:BT, _:BT) : =>BT
Built-in Funcon
bit-vector-xor(_:BT, _:BT) : =>BT
/*
The above four funcons are the natural extensions of funcons from `booleans`
to `bit-vectors(N)` of the same length.
*/
Built-in Funcon
bit-vector-shift-left(_:BT, _:natural-numbers) : BT
Built-in Funcon
bit-vector-logical-shift-right(_:BT, _:natural-numbers) : BT
Built-in Funcon
bit-vector-arithmetic-shift-right(_:BT, _:natural-numbers) : BT
Built-in Funcon
integer-to-bit-vector(_:integers, N:natural-numbers) : bit-vectors(N)
/*
`integer-to-bit-vector(M, N)` converts an integer `M` to a bit-vector of
length `N`, using Two's Complement representation. If the integer is out of
range of the representation, it will wrap around (modulo 2^N).
*/
Built-in Funcon
bit-vector-to-integer(_:BT) : =>integers
/*
`bit-vector-to-integer(B)` interprets a bit-vector `BV` as an integer
in Two's Complement representation.
*/
Built-in Funcon
bit-vector-to-natural(_:BT) : =>natural-numbers
/*
`bit-vector-to-natural(BV)` interprets a bit-vector `BV` as a natural number
in unsigned representation.
*/
Funcon
unsigned-bit-vector-maximum(N:natural-numbers) : =>natural-numbers
~> integer-subtract(integer-power(2, N), 1)
Funcon
signed-bit-vector-maximum(N:natural-numbers) : =>integers
~> integer-subtract(integer-power(2, integer-subtract(N, 1)), 1)
Funcon
signed-bit-vector-minimum(N:natural-numbers) : =>integers
~> integer-negate(integer-power(2, integer-subtract(N, 1)))
Funcon
is-in-signed-bit-vector(M:integers, N:natural-numbers) : =>booleans
~> and(integer-is-less-or-equal(M, signed-bit-vector-maximum(N)),
integer-is-greater-or-equal(M, signed-bit-vector-minimum(N)))
Funcon
is-in-unsigned-bit-vector(M:integers, N:natural-numbers) : =>booleans
~> and(integer-is-less-or-equal(M, unsigned-bit-vector-maximum(N)),
integer-is-greater-or-equal(M, 0))

152
IBAF-cbs/Funcons-beta/Values/Composite/Bits/index.md Normal file
View File

@@ -0,0 +1,152 @@
---
layout: default
title: "Bits"
parent: Composite
ancestor: Funcons-beta
---
[Funcons-beta] : [Bits.cbs]
-----------------------------
### Bits and bit vectors
<div class="highlighter-rouge"><pre class="highlight"><code>[
<i class="keyword">Type</i> <span class="name"><a href="#Name_bits">bits</a></span>
<i class="keyword">Datatype</i> <span class="name"><a href="#Name_bit-vectors">bit-vectors</a></span>
<i class="keyword">Funcon</i> <span class="name"><a href="#Name_bit-vector">bit-vector</a></span>
<i class="keyword">Type</i> <span class="name"><a href="#Name_bytes">bytes</a></span> <i class="keyword">Alias</i> <span class="name"><a href="#Name_octets">octets</a></span>
<i class="keyword">Funcon</i> <span class="name"><a href="#Name_bit-vector-not">bit-vector-not</a></span>
<i class="keyword">Funcon</i> <span class="name"><a href="#Name_bit-vector-and">bit-vector-and</a></span>
<i class="keyword">Funcon</i> <span class="name"><a href="#Name_bit-vector-or">bit-vector-or</a></span>
<i class="keyword">Funcon</i> <span class="name"><a href="#Name_bit-vector-xor">bit-vector-xor</a></span>
<i class="keyword">Funcon</i> <span class="name"><a href="#Name_bit-vector-shift-left">bit-vector-shift-left</a></span>
<i class="keyword">Funcon</i> <span class="name"><a href="#Name_bit-vector-logical-shift-right">bit-vector-logical-shift-right</a></span>
<i class="keyword">Funcon</i> <span class="name"><a href="#Name_bit-vector-arithmetic-shift-right">bit-vector-arithmetic-shift-right</a></span>
<i class="keyword">Funcon</i> <span class="name"><a href="#Name_integer-to-bit-vector">integer-to-bit-vector</a></span>
<i class="keyword">Funcon</i> <span class="name"><a href="#Name_bit-vector-to-integer">bit-vector-to-integer</a></span>
<i class="keyword">Funcon</i> <span class="name"><a href="#Name_bit-vector-to-natural">bit-vector-to-natural</a></span>
<i class="keyword">Funcon</i> <span class="name"><a href="#Name_unsigned-bit-vector-maximum">unsigned-bit-vector-maximum</a></span>
<i class="keyword">Funcon</i> <span class="name"><a href="#Name_signed-bit-vector-maximum">signed-bit-vector-maximum</a></span>
<i class="keyword">Funcon</i> <span class="name"><a href="#Name_signed-bit-vector-minimum">signed-bit-vector-minimum</a></span>
<i class="keyword">Funcon</i> <span class="name"><a href="#Name_is-in-signed-bit-vector">is-in-signed-bit-vector</a></span>
<i class="keyword">Funcon</i> <span class="name"><a href="#Name_is-in-unsigned-bit-vector">is-in-unsigned-bit-vector</a></span>
]</code></pre></div>
#### Bits
<div class="highlighter-rouge"><pre class="highlight"><code><i class="keyword">Type</i>
<span class="name"><span id="Name_bits">bits</span></span> ~> <span class="name"><a href="../../Primitive/Booleans/index.html#Name_booleans">booleans</a></span></code></pre></div>
<code><span class="name"><a href="../../Primitive/Booleans/index.html#Name_false">false</a></span></code> represents the absence of a bit, <code><span class="name"><a href="../../Primitive/Booleans/index.html#Name_true">true</a></span></code> its presence.
#### Bit vectors
<div class="highlighter-rouge"><pre class="highlight"><code><i class="keyword">Datatype</i>
<span class="name"><span id="Name_bit-vectors">bit-vectors</span></span>(<span id="Variable145_N"><i class="var">N</i></span>:<span class="name"><a href="../../Primitive/Integers/index.html#Name_natural-numbers">natural-numbers</a></span>) ::= <span id="Name_bit-vector">bit-vector</span>(_:<span class="name"><a href="#Name_bits">bits</a></span>^<span id="Variable166_N"><i class="var">N</i></span>)</code></pre></div>
<div class="highlighter-rouge"><pre class="highlight"><code><i class="keyword">Type</i>
<span class="name"><span id="Name_bytes">bytes</span></span> ~> <span class="name"><a href="#Name_bit-vectors">bit-vectors</a></span>(8)
<i class="keyword">Alias</i>
<span class="name"><span id="Name_octets">octets</span></span> = <span class="name"><a href="#Name_bytes">bytes</a></span></code></pre></div>
<div class="highlighter-rouge"><pre class="highlight"><code><i class="keyword">Meta-variables</i>
<span id="PartVariable_BT"><i class="var">BT</i></span> <: <span class="name"><a href="#Name_bit-vectors">bit-vectors</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_bit-vector-not">bit-vector-not</span></span>(_:<span id="Variable234_BT"><i class="var">BT</i></span>) : =><span id="Variable248_BT"><i class="var">BT</i></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_bit-vector-and">bit-vector-and</span></span>(_:<span id="Variable261_BT"><i class="var">BT</i></span>, _:<span id="Variable272_BT"><i class="var">BT</i></span>) : =><span id="Variable287_BT"><i class="var">BT</i></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_bit-vector-or">bit-vector-or</span></span>(_:<span id="Variable300_BT"><i class="var">BT</i></span>, _:<span id="Variable311_BT"><i class="var">BT</i></span>) : =><span id="Variable326_BT"><i class="var">BT</i></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_bit-vector-xor">bit-vector-xor</span></span>(_:<span id="Variable339_BT"><i class="var">BT</i></span>, _:<span id="Variable350_BT"><i class="var">BT</i></span>) : =><span id="Variable365_BT"><i class="var">BT</i></span></code></pre></div>
The above four funcons are the natural extensions of funcons from <code><span class="name"><a href="../../Primitive/Booleans/index.html#Name_booleans">booleans</a></span></code>
to <code><span class="name"><a href="#Name_bit-vectors">bit-vectors</a></span>(<i class="var">N</i>)</code> of the same length.
<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_bit-vector-shift-left">bit-vector-shift-left</span></span>(_:<span id="Variable414_BT"><i class="var">BT</i></span>, _:<span class="name"><a href="../../Primitive/Integers/index.html#Name_natural-numbers">natural-numbers</a></span>) : <span id="Variable436_BT"><i class="var">BT</i></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_bit-vector-logical-shift-right">bit-vector-logical-shift-right</span></span>(_:<span id="Variable448_BT"><i class="var">BT</i></span>, _:<span class="name"><a href="../../Primitive/Integers/index.html#Name_natural-numbers">natural-numbers</a></span>) : <span id="Variable470_BT"><i class="var">BT</i></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_bit-vector-arithmetic-shift-right">bit-vector-arithmetic-shift-right</span></span>(_:<span id="Variable482_BT"><i class="var">BT</i></span>, _:<span class="name"><a href="../../Primitive/Integers/index.html#Name_natural-numbers">natural-numbers</a></span>) : <span id="Variable504_BT"><i class="var">BT</i></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_integer-to-bit-vector">integer-to-bit-vector</span></span>(_:<span class="name"><a href="../../Primitive/Integers/index.html#Name_integers">integers</a></span>, <span id="Variable521_N"><i class="var">N</i></span>:<span class="name"><a href="../../Primitive/Integers/index.html#Name_natural-numbers">natural-numbers</a></span>) : <span class="name"><a href="#Name_bit-vectors">bit-vectors</a></span>(<span id="Variable537_N"><i class="var">N</i></span>)</code></pre></div>
<code><span class="name"><a href="#Name_integer-to-bit-vector">integer-to-bit-vector</a></span>(<i class="var">M</i>, <i class="var">N</i>)</code> converts an integer <code><i class="var">M</i></code> to a bit-vector of
length <code><i class="var">N</i></code>, using Two's Complement representation. If the integer is out of
range of the representation, it will wrap around (modulo 2^N).
<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_bit-vector-to-integer">bit-vector-to-integer</span></span>(_:<span id="Variable613_BT"><i class="var">BT</i></span>) : =><span class="name"><a href="../../Primitive/Integers/index.html#Name_integers">integers</a></span></code></pre></div>
<code><span class="name"><a href="#Name_bit-vector-to-integer">bit-vector-to-integer</a></span>(<i class="var">B</i>)</code> interprets a bit-vector <code><i class="var">BV</i></code> as an integer
in Two's Complement representation.
<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_bit-vector-to-natural">bit-vector-to-natural</span></span>(_:<span id="Variable676_BT"><i class="var">BT</i></span>) : =><span class="name"><a href="../../Primitive/Integers/index.html#Name_natural-numbers">natural-numbers</a></span></code></pre></div>
<code><span class="name"><a href="#Name_bit-vector-to-natural">bit-vector-to-natural</a></span>(<i class="var">BV</i>)</code> interprets a bit-vector <code><i class="var">BV</i></code> as a natural number
in unsigned representation.
<div class="highlighter-rouge"><pre class="highlight"><code><i class="keyword">Funcon</i>
<span class="name"><span id="Name_unsigned-bit-vector-maximum">unsigned-bit-vector-maximum</span></span>(<span id="Variable736_N"><i class="var">N</i></span>:<span class="name"><a href="../../Primitive/Integers/index.html#Name_natural-numbers">natural-numbers</a></span>) : =><span class="name"><a href="../../Primitive/Integers/index.html#Name_natural-numbers">natural-numbers</a></span>
~> <span class="name"><a href="../../Primitive/Integers/index.html#Name_integer-subtract">integer-subtract</a></span>(<span class="name"><a href="../../Primitive/Integers/index.html#Name_integer-power">integer-power</a></span>(2, <a href="#Variable736_N"><i class="var">N</i></a>), 1)</code></pre></div>
<div class="highlighter-rouge"><pre class="highlight"><code><i class="keyword">Funcon</i>
<span class="name"><span id="Name_signed-bit-vector-maximum">signed-bit-vector-maximum</span></span>(<span id="Variable783_N"><i class="var">N</i></span>:<span class="name"><a href="../../Primitive/Integers/index.html#Name_natural-numbers">natural-numbers</a></span>) : =><span class="name"><a href="../../Primitive/Integers/index.html#Name_integers">integers</a></span>
~> <span class="name"><a href="../../Primitive/Integers/index.html#Name_integer-subtract">integer-subtract</a></span>(<span class="name"><a href="../../Primitive/Integers/index.html#Name_integer-power">integer-power</a></span>(2, <span class="name"><a href="../../Primitive/Integers/index.html#Name_integer-subtract">integer-subtract</a></span>(<a href="#Variable783_N"><i class="var">N</i></a>, 1)), 1)</code></pre></div>
<div class="highlighter-rouge"><pre class="highlight"><code><i class="keyword">Funcon</i>
<span class="name"><span id="Name_signed-bit-vector-minimum">signed-bit-vector-minimum</span></span>(<span id="Variable840_N"><i class="var">N</i></span>:<span class="name"><a href="../../Primitive/Integers/index.html#Name_natural-numbers">natural-numbers</a></span>) : =><span class="name"><a href="../../Primitive/Integers/index.html#Name_integers">integers</a></span>
~> <span class="name"><a href="../../Primitive/Integers/index.html#Name_integer-negate">integer-negate</a></span>(<span class="name"><a href="../../Primitive/Integers/index.html#Name_integer-power">integer-power</a></span>(2, <span class="name"><a href="../../Primitive/Integers/index.html#Name_integer-subtract">integer-subtract</a></span>(<a href="#Variable840_N"><i class="var">N</i></a>, 1)))</code></pre></div>
<div class="highlighter-rouge"><pre class="highlight"><code><i class="keyword">Funcon</i>
<span class="name"><span id="Name_is-in-signed-bit-vector">is-in-signed-bit-vector</span></span>(<span id="Variable894_M"><i class="var">M</i></span>:<span class="name"><a href="../../Primitive/Integers/index.html#Name_integers">integers</a></span>, <span id="Variable903_N"><i class="var">N</i></span>:<span class="name"><a href="../../Primitive/Integers/index.html#Name_natural-numbers">natural-numbers</a></span>) : =><span class="name"><a href="../../Primitive/Booleans/index.html#Name_booleans">booleans</a></span>
~> <span class="name"><a href="../../Primitive/Booleans/index.html#Name_and">and</a></span>(<span class="name"><a href="../../Primitive/Integers/index.html#Name_integer-is-less-or-equal">integer-is-less-or-equal</a></span>(<a href="#Variable894_M"><i class="var">M</i></a>, <span class="name"><a href="#Name_signed-bit-vector-maximum">signed-bit-vector-maximum</a></span>(<a href="#Variable903_N"><i class="var">N</i></a>)),
<span class="name"><a href="../../Primitive/Integers/index.html#Name_integer-is-greater-or-equal">integer-is-greater-or-equal</a></span>(<a href="#Variable894_M"><i class="var">M</i></a>, <span class="name"><a href="#Name_signed-bit-vector-minimum">signed-bit-vector-minimum</a></span>(<a href="#Variable903_N"><i class="var">N</i></a>)))</code></pre></div>
<div class="highlighter-rouge"><pre class="highlight"><code><i class="keyword">Funcon</i>
<span class="name"><span id="Name_is-in-unsigned-bit-vector">is-in-unsigned-bit-vector</span></span>(<span id="Variable984_M"><i class="var">M</i></span>:<span class="name"><a href="../../Primitive/Integers/index.html#Name_integers">integers</a></span>, <span id="Variable993_N"><i class="var">N</i></span>:<span class="name"><a href="../../Primitive/Integers/index.html#Name_natural-numbers">natural-numbers</a></span>) : =><span class="name"><a href="../../Primitive/Booleans/index.html#Name_booleans">booleans</a></span>
~> <span class="name"><a href="../../Primitive/Booleans/index.html#Name_and">and</a></span>(<span class="name"><a href="../../Primitive/Integers/index.html#Name_integer-is-less-or-equal">integer-is-less-or-equal</a></span>(<a href="#Variable984_M"><i class="var">M</i></a>, <span class="name"><a href="#Name_unsigned-bit-vector-maximum">unsigned-bit-vector-maximum</a></span>(<a href="#Variable993_N"><i class="var">N</i></a>)),
<span class="name"><a href="../../Primitive/Integers/index.html#Name_integer-is-greater-or-equal">integer-is-greater-or-equal</a></span>(<a href="#Variable984_M"><i class="var">M</i></a>, 0))</code></pre></div>
____
From the [PLanCompS Project] | [CBS-beta issues...] | [Suggest an improvement...]
[Bits.cbs]: Bits.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/Bits/Bits.cbs%0A%0AComment/Query/Issue/Suggestion%3A%0A%0A%0ASignature%3A%0A
"GENERATE AN EMAIL TEMPLATE"

86
IBAF-cbs/Funcons-beta/Values/Composite/Classes/Classes.cbs Normal file
View File

@@ -0,0 +1,86 @@
### Classes
[
Datatype classes
Funcon class
Funcon class-instantiator
Funcon class-feature-map
Funcon class-superclass-name-sequence
Funcon class-name-tree
Funcon is-subclass-name
Funcon class-name-single-inheritance-feature-map
]
Datatype
classes ::=
class(_:thunks(references(objects)), _:environments, _:identifiers*)
/*
`class(Thunk, Env, C*)` is a class with:
* a thunk `Thunk` for instantiating the class,
* an environment `Env` with the features declared by the class, and
* a sequence `C*` of names of direct superclasses.
`class(Thunk, Env)` is a base class, having no superclasses.
`class(Thunk, Env, C)` is a class with a single superclass.
Class instantiation forces its thunk to compute a reference to an object.
Features are inherited from superclasses. When features with the same name
are declared in simultaneously inherited classes, the order of the superclass
identifiers in `C*` may affect resolution of references to features.
Overloading of feature names is supported by using type maps as features.
The class table is represented by binding class names to classes.
The class superclass hierarchy is assumed to be acyclic.
*/
Funcon
class-instantiator(_:classes) : =>thunks(references(objects))
Rule
class-instantiator
class(Thunk:thunks(_), Envs:environments, C*:identifiers*) ~> Thunk
Funcon
class-feature-map(_:classes) : =>environments
Rule
class-feature-map
class(Thunk:thunks(_), Env:environments, C*:identifiers*) ~> Env
Funcon
class-superclass-name-sequence(_:classes) : =>identifiers*
Rule
class-superclass-name-sequence
class(Thunk:thunks(_), Env:environments, C*:identifiers*) ~> C*
Funcon
class-name-tree(_:identifiers) : =>trees(identifiers)
/*
`class-name-tree C` forms a tree where the branches are the class name
trees for the superclasses of `C`.
*/
Rule
class-name-tree(C : identifiers)
~> tree(C,
interleave-map(
class-name-tree given,
class-superclass-name-sequence bound-value C))
Funcon
is-subclass-name(C:identifiers, C':identifiers) : =>booleans
~> is-in-set(C, { forest-value-sequence class-name-tree C' })
/*
The result of `is-subclass-name(C, C')` does not depend on the order of
the names in `forest-value-sequence class-name-tree C'`.
*/
Funcon
class-name-single-inheritance-feature-map(C:identifiers) : =>environments
~> map-override interleave-map(
class-feature-map bound-value given,
single-branching-sequence class-name-tree C)
/*
For multiple inheritance, different resolution orders can be specified
by using different linearisations of the class name tree.
*/

125
IBAF-cbs/Funcons-beta/Values/Composite/Classes/index.md Normal file
View File

@@ -0,0 +1,125 @@
---
layout: default
title: "Classes"
parent: Composite
ancestor: Funcons-beta
---
[Funcons-beta] : [Classes.cbs]
-----------------------------
### Classes
<div class="highlighter-rouge"><pre class="highlight"><code>[
<i class="keyword">Datatype</i> <span class="name"><a href="#Name_classes">classes</a></span>
<i class="keyword">Funcon</i> <span class="name"><a href="#Name_class">class</a></span>
<i class="keyword">Funcon</i> <span class="name"><a href="#Name_class-instantiator">class-instantiator</a></span>
<i class="keyword">Funcon</i> <span class="name"><a href="#Name_class-feature-map">class-feature-map</a></span>
<i class="keyword">Funcon</i> <span class="name"><a href="#Name_class-superclass-name-sequence">class-superclass-name-sequence</a></span>
<i class="keyword">Funcon</i> <span class="name"><a href="#Name_class-name-tree">class-name-tree</a></span>
<i class="keyword">Funcon</i> <span class="name"><a href="#Name_is-subclass-name">is-subclass-name</a></span>
<i class="keyword">Funcon</i> <span class="name"><a href="#Name_class-name-single-inheritance-feature-map">class-name-single-inheritance-feature-map</a></span>
]</code></pre></div>
<div class="highlighter-rouge"><pre class="highlight"><code><i class="keyword">Datatype</i>
<span class="name"><span id="Name_classes">classes</span></span> ::=
<span id="Name_class">class</span>(_:<span class="name"><a href="../../Abstraction/Thunks/index.html#Name_thunks">thunks</a></span>(<span class="name"><a href="../References/index.html#Name_references">references</a></span>(<span class="name"><a href="../Objects/index.html#Name_objects">objects</a></span>)), _:<span class="name"><a href="../../../Computations/Normal/Binding/index.html#Name_environments">environments</a></span>, _:<span class="name"><a href="../../../Computations/Normal/Binding/index.html#Name_identifiers">identifiers</a></span><sup class="sup">*</sup>)</code></pre></div>
<code><span class="name"><a href="#Name_class">class</a></span>(<i class="var">Thunk</i>, <i class="var">Env</i>, <i class="var">C<sup class="sup">*</sup></i>)</code> is a class with:
* a thunk <code><i class="var">Thunk</i></code> for instantiating the class,
* an environment <code><i class="var">Env</i></code> with the features declared by the class, and
* a sequence <code><i class="var">C<sup class="sup">*</sup></i></code> of names of direct superclasses.
<code><span class="name"><a href="#Name_class">class</a></span>(<i class="var">Thunk</i>, <i class="var">Env</i>)</code> is a base class, having no superclasses.
<code><span class="name"><a href="#Name_class">class</a></span>(<i class="var">Thunk</i>, <i class="var">Env</i>, <i class="var">C</i>)</code> is a class with a single superclass.
Class instantiation forces its thunk to compute a reference to an object.
Features are inherited from superclasses. When features with the same name
are declared in simultaneously inherited classes, the order of the superclass
identifiers in <code><i class="var">C<sup class="sup">*</sup></i></code> may affect resolution of references to features.
Overloading of feature names is supported by using type maps as features.
The class table is represented by binding class names to classes.
The class superclass hierarchy is assumed to be acyclic.
<div class="highlighter-rouge"><pre class="highlight"><code><i class="keyword">Funcon</i>
<span class="name"><span id="Name_class-instantiator">class-instantiator</span></span>(_:<span class="name"><a href="#Name_classes">classes</a></span>) : =><span class="name"><a href="../../Abstraction/Thunks/index.html#Name_thunks">thunks</a></span>(<span class="name"><a href="../References/index.html#Name_references">references</a></span>(<span class="name"><a href="../Objects/index.html#Name_objects">objects</a></span>))
<i class="keyword">Rule</i>
<span class="name"><a href="#Name_class-instantiator">class-instantiator</a></span>
<span class="name"><a href="#Name_class">class</a></span>(<span id="Variable308_Thunk"><i class="var">Thunk</i></span>:<span class="name"><a href="../../Abstraction/Thunks/index.html#Name_thunks">thunks</a></span>(_), <span id="Variable325_Envs"><i class="var">Envs</i></span>:<span class="name"><a href="../../../Computations/Normal/Binding/index.html#Name_environments">environments</a></span>, <span id="Variable334_C*"><i class="var">C<sup class="sup">*</sup></i></span>:<span class="name"><a href="../../../Computations/Normal/Binding/index.html#Name_identifiers">identifiers</a></span><sup class="sup">*</sup>) ~> <a href="#Variable308_Thunk"><i class="var">Thunk</i></a></code></pre></div>
<div class="highlighter-rouge"><pre class="highlight"><code><i class="keyword">Funcon</i>
<span class="name"><span id="Name_class-feature-map">class-feature-map</span></span>(_:<span class="name"><a href="#Name_classes">classes</a></span>) : =><span class="name"><a href="../../../Computations/Normal/Binding/index.html#Name_environments">environments</a></span>
<i class="keyword">Rule</i>
<span class="name"><a href="#Name_class-feature-map">class-feature-map</a></span>
<span class="name"><a href="#Name_class">class</a></span>(<span id="Variable383_Thunk"><i class="var">Thunk</i></span>:<span class="name"><a href="../../Abstraction/Thunks/index.html#Name_thunks">thunks</a></span>(_), <span id="Variable400_Env"><i class="var">Env</i></span>:<span class="name"><a href="../../../Computations/Normal/Binding/index.html#Name_environments">environments</a></span>, <span id="Variable409_C*"><i class="var">C<sup class="sup">*</sup></i></span>:<span class="name"><a href="../../../Computations/Normal/Binding/index.html#Name_identifiers">identifiers</a></span><sup class="sup">*</sup>) ~> <a href="#Variable400_Env"><i class="var">Env</i></a></code></pre></div>
<div class="highlighter-rouge"><pre class="highlight"><code><i class="keyword">Funcon</i>
<span class="name"><span id="Name_class-superclass-name-sequence">class-superclass-name-sequence</span></span>(_:<span class="name"><a href="#Name_classes">classes</a></span>) : =><span class="name"><a href="../../../Computations/Normal/Binding/index.html#Name_identifiers">identifiers</a></span><sup class="sup">*</sup>
<i class="keyword">Rule</i>
<span class="name"><a href="#Name_class-superclass-name-sequence">class-superclass-name-sequence</a></span>
<span class="name"><a href="#Name_class">class</a></span>(<span id="Variable460_Thunk"><i class="var">Thunk</i></span>:<span class="name"><a href="../../Abstraction/Thunks/index.html#Name_thunks">thunks</a></span>(_), <span id="Variable477_Env"><i class="var">Env</i></span>:<span class="name"><a href="../../../Computations/Normal/Binding/index.html#Name_environments">environments</a></span>, <span id="Variable486_C*"><i class="var">C<sup class="sup">*</sup></i></span>:<span class="name"><a href="../../../Computations/Normal/Binding/index.html#Name_identifiers">identifiers</a></span><sup class="sup">*</sup>) ~> <a href="#Variable486_C*"><i class="var">C<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_class-name-tree">class-name-tree</span></span>(_:<span class="name"><a href="../../../Computations/Normal/Binding/index.html#Name_identifiers">identifiers</a></span>) : =><span class="name"><a href="../Trees/index.html#Name_trees">trees</a></span>(<span class="name"><a href="../../../Computations/Normal/Binding/index.html#Name_identifiers">identifiers</a></span>)</code></pre></div>
<code><span class="name"><a href="#Name_class-name-tree">class-name-tree</a></span> <i class="var">C</i></code> forms a tree where the branches are the class name
trees for the superclasses of <code><i class="var">C</i></code>.
<div class="highlighter-rouge"><pre class="highlight"><code><i class="keyword">Rule</i>
<span class="name"><a href="#Name_class-name-tree">class-name-tree</a></span>(<span id="Variable576_C"><i class="var">C</i></span> : <span class="name"><a href="../../../Computations/Normal/Binding/index.html#Name_identifiers">identifiers</a></span>)
~> <span class="name"><a href="../Trees/index.html#Name_tree">tree</a></span>(<a href="#Variable576_C"><i class="var">C</i></a>,
<span class="name"><a href="../../../Computations/Normal/Giving/index.html#Name_interleave-map">interleave-map</a></span>(
<span class="name"><a href="#Name_class-name-tree">class-name-tree</a></span> <span class="name"><a href="../../../Computations/Normal/Giving/index.html#Name_given">given</a></span>,
<span class="name"><a href="#Name_class-superclass-name-sequence">class-superclass-name-sequence</a></span> <span class="name"><a href="../../../Computations/Normal/Binding/index.html#Name_bound-value">bound-value</a></span> <a href="#Variable576_C"><i class="var">C</i></a>))</code></pre></div>
<div class="highlighter-rouge"><pre class="highlight"><code><i class="keyword">Funcon</i>
<span class="name"><span id="Name_is-subclass-name">is-subclass-name</span></span>(<span id="Variable628_C"><i class="var">C</i></span>:<span class="name"><a href="../../../Computations/Normal/Binding/index.html#Name_identifiers">identifiers</a></span>, <span id="Variable638_C'"><i class="var">C&prime;</i></span>:<span class="name"><a href="../../../Computations/Normal/Binding/index.html#Name_identifiers">identifiers</a></span>) : =><span class="name"><a href="../../Primitive/Booleans/index.html#Name_booleans">booleans</a></span>
~> <span class="name"><a href="../Sets/index.html#Name_is-in-set">is-in-set</a></span>(<a href="#Variable628_C"><i class="var">C</i></a>, { <span class="name"><a href="../Trees/index.html#Name_forest-value-sequence">forest-value-sequence</a></span> <span class="name"><a href="#Name_class-name-tree">class-name-tree</a></span> <a href="#Variable638_C'"><i class="var">C&prime;</i></a> })</code></pre></div>
The result of <code><span class="name"><a href="#Name_is-subclass-name">is-subclass-name</a></span>(<i class="var">C</i>, <i class="var">C&prime;</i>)</code> does not depend on the order of
the names in <code><span class="name"><a href="../Trees/index.html#Name_forest-value-sequence">forest-value-sequence</a></span> <span class="name"><a href="#Name_class-name-tree">class-name-tree</a></span> <i class="var">C&prime;</i></code>.
<div class="highlighter-rouge"><pre class="highlight"><code><i class="keyword">Funcon</i>
<span class="name"><span id="Name_class-name-single-inheritance-feature-map">class-name-single-inheritance-feature-map</span></span>(<span id="Variable740_C"><i class="var">C</i></span>:<span class="name"><a href="../../../Computations/Normal/Binding/index.html#Name_identifiers">identifiers</a></span>) : =><span class="name"><a href="../../../Computations/Normal/Binding/index.html#Name_environments">environments</a></span>
~> <span class="name"><a href="../Maps/index.html#Name_map-override">map-override</a></span> <span class="name"><a href="../../../Computations/Normal/Giving/index.html#Name_interleave-map">interleave-map</a></span>(
<span class="name"><a href="#Name_class-feature-map">class-feature-map</a></span> <span class="name"><a href="../../../Computations/Normal/Binding/index.html#Name_bound-value">bound-value</a></span> <span class="name"><a href="../../../Computations/Normal/Giving/index.html#Name_given">given</a></span>,
<span class="name"><a href="../Trees/index.html#Name_single-branching-sequence">single-branching-sequence</a></span> <span class="name"><a href="#Name_class-name-tree">class-name-tree</a></span> <a href="#Variable740_C"><i class="var">C</i></a>)</code></pre></div>
For multiple inheritance, different resolution orders can be specified
by using different linearisations of the class name tree.
____
From the [PLanCompS Project] | [CBS-beta issues...] | [Suggest an improvement...]
[Classes.cbs]: Classes.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/Classes/Classes.cbs%0A%0AComment/Query/Issue/Suggestion%3A%0A%0A%0ASignature%3A%0A
"GENERATE AN EMAIL TEMPLATE"

120
IBAF-cbs/Funcons-beta/Values/Composite/Classes/tests/class-feature-map.config Normal file
View File

@@ -0,0 +1,120 @@
//[https://en.wikipedia.org/wiki/C3_linearization]:
//class O
//class A extends O
//class B extends O
//class C extends O
//class D extends O
//class E extends O
//class K1 extends A, B, C
//class K2 extends D, B, E
//class K3 extends D, A
//class Z extends K1, K2, K3
general {
funcon-term:
initialise-giving initialise-generating initialise-binding finalise-failing
scope(collateral(
{"O" |->
class(
thunk abstraction reference
object(fresh-atom,"O",map()),
map())}
,
{"A" |->
class(
thunk abstraction reference
object(fresh-atom,"A",map(),
object(fresh-atom,"O",map())),
{"a" |-> 1}, "O")}
,
{"B" |->
class(
thunk abstraction reference
object(fresh-atom,"B",map(),
object(fresh-atom,"O",map())),
map(), "O")}
,
{"C" |->
class(
thunk abstraction reference
object(fresh-atom,"C",map(),
object(fresh-atom,"O",map())),
map(), "O")}
,
{"D" |->
class(
thunk abstraction reference
object(fresh-atom,"D",map(),
object(fresh-atom,"O",map())),
map(), "O")}
,
{"E" |->
class(
thunk abstraction reference
object(fresh-atom,"E",map(),
object(fresh-atom,"O",map())),
map(), "O")}
,
{"K1" |->
class(
thunk abstraction reference
object(fresh-atom,"K1",map(),
object(fresh-atom,"A",map(),object(fresh-atom,"O",map())),
object(fresh-atom,"B",map(),object(fresh-atom,"O",map())),
object(fresh-atom,"C",map(),object(fresh-atom,"O",map()))),
{"k1" |-> 1, "a" |-> 2} , "A", "B", "C")}
,
{"K2" |->
class(
thunk abstraction reference
object(fresh-atom,"K2",map(),
object(fresh-atom,"D",map(),object(fresh-atom,"O",map())),
object(fresh-atom,"B",map(),object(fresh-atom,"O",map())),
object(fresh-atom,"E",map(),object(fresh-atom,"O",map()))),
map(), "D", "B", "E")}
,
{"K3" |->
class(
thunk abstraction reference
object(fresh-atom,"K3",map(),
object(fresh-atom,"D",map(),object(fresh-atom,"O",map())),
object(fresh-atom,"A",map(),object(fresh-atom,"O",map()))),
map(), "D", "A")}
,
{"Z" |->
class(
thunk abstraction reference
object(fresh-atom,"Z",map(),
object(fresh-atom,"K1",map(),
object(fresh-atom,"A",map(),object(fresh-atom,"O",map())),
object(fresh-atom,"B",map(),object(fresh-atom,"O",map())),
object(fresh-atom,"C",map(),object(fresh-atom,"O",map()))),
object(fresh-atom,"K2",map(),
object(fresh-atom,"D",map(),object(fresh-atom,"O",map())),
object(fresh-atom,"B",map(),object(fresh-atom,"O",map())),
object(fresh-atom,"E",map(),object(fresh-atom,"O",map()))),
object(fresh-atom,"K3",map(),
object(fresh-atom,"D",map(),object(fresh-atom,"O",map())),
object(fresh-atom,"A",map(),object(fresh-atom,"O",map())))),
map(), "K1", "K2", "K3")}
),
sequential(
print class-feature-map bound-value "O",
print class-feature-map bound-value "A",
print class-feature-map bound-value "K1"
)
)
;
}
tests {
result-term: null-value;
standard-out: [
map()
,
{"a" |-> 1 }
,
{"k1" |-> 1, "a" |-> 2}
];
}

127
IBAF-cbs/Funcons-beta/Values/Composite/Classes/tests/class-instantiator.config Normal file
View File

@@ -0,0 +1,127 @@
//[https://en.wikipedia.org/wiki/C3_linearization]:
//class O
//class A extends O
//class B extends O
//class C extends O
//class D extends O
//class E extends O
//class K1 extends A, B, C
//class K2 extends D, B, E
//class K3 extends D, A
//class Z extends K1, K2, K3
general {
funcon-term:
initialise-giving initialise-generating initialise-binding finalise-failing
scope(collateral(
{"O" |->
class(
thunk abstraction reference
object(fresh-atom,"O",map()),
map())}
,
{"A" |->
class(
thunk abstraction reference
object(fresh-atom,"A",map(),
object(fresh-atom,"O",map())),
map(), "O")}
,
{"B" |->
class(
thunk abstraction reference
object(fresh-atom,"B",map(),
object(fresh-atom,"O",map())),
map(), "O")}
,
{"C" |->
class(
thunk abstraction reference
object(fresh-atom,"C",map(),
object(fresh-atom,"O",map())),
map(), "O")}
,
{"D" |->
class(
thunk abstraction reference
object(fresh-atom,"D",map(),
object(fresh-atom,"O",map())),
map(), "O")}
,
{"E" |->
class(
thunk abstraction reference
object(fresh-atom,"E",map(),
object(fresh-atom,"O",map())),
map(), "O")}
,
{"K1" |->
class(
thunk abstraction reference
object(fresh-atom,"K1",map(),
object(fresh-atom,"A",map(),object(fresh-atom,"O",map())),
object(fresh-atom,"B",map(),object(fresh-atom,"O",map())),
object(fresh-atom,"C",map(),object(fresh-atom,"O",map()))),
map(), "A", "B", "C")}
,
{"K2" |->
class(
thunk abstraction reference
object(fresh-atom,"K2",map(),
object(fresh-atom,"D",map(),object(fresh-atom,"O",map())),
object(fresh-atom,"B",map(),object(fresh-atom,"O",map())),
object(fresh-atom,"E",map(),object(fresh-atom,"O",map()))),
map(), "D", "B", "E")}
,
{"K3" |->
class(
thunk abstraction reference
object(fresh-atom,"K3",map(),
object(fresh-atom,"D",map(),object(fresh-atom,"O",map())),
object(fresh-atom,"A",map(),object(fresh-atom,"O",map()))),
map(), "D", "A")}
,
{"Z" |->
class(
thunk abstraction reference
object(fresh-atom,"Z",map(),
object(fresh-atom,"K1",map(),
object(fresh-atom,"A",map(),object(fresh-atom,"O",map())),
object(fresh-atom,"B",map(),object(fresh-atom,"O",map())),
object(fresh-atom,"C",map(),object(fresh-atom,"O",map()))),
object(fresh-atom,"K2",map(),
object(fresh-atom,"D",map(),object(fresh-atom,"O",map())),
object(fresh-atom,"B",map(),object(fresh-atom,"O",map())),
object(fresh-atom,"E",map(),object(fresh-atom,"O",map()))),
object(fresh-atom,"K3",map(),
object(fresh-atom,"D",map(),object(fresh-atom,"O",map())),
object(fresh-atom,"A",map(),object(fresh-atom,"O",map())))),
map(), "K1", "K2", "K3")}
),
sequential(
print class-instantiator bound-value "O",
print class-instantiator bound-value "A",
print class-instantiator bound-value "K1"
)
)
;
}
tests {
result-term: null-value;
standard-out: [
thunk abstraction reference
object(fresh-atom,"O",map())
,
thunk abstraction reference
object(fresh-atom,"A",map(),
object(fresh-atom,"O",map()))
,
thunk abstraction reference
object(fresh-atom,"K1",map(),
object(fresh-atom,"A",map(),object(fresh-atom,"O",map())),
object(fresh-atom,"B",map(),object(fresh-atom,"O",map())),
object(fresh-atom,"C",map(),object(fresh-atom,"O",map())))
];
}

127
IBAF-cbs/Funcons-beta/Values/Composite/Classes/tests/class-name-single-inheritance-feature-map.config Normal file
View File

@@ -0,0 +1,127 @@
//[https://en.wikipedia.org/wiki/C3_linearization]:
//class O
//class A extends O
//class B extends O
//class C extends O
//class D extends O
//class E extends O
//class K1 extends A, B, C
//class K2 extends D, B, E
//class K3 extends D, A
//class Z extends K1, K2, K3
general {
funcon-term:
initialise-giving initialise-generating initialise-binding finalise-failing
scope(collateral(
{"O" |->
class(
thunk abstraction reference
object(fresh-atom,"O",map()),
map())}
,
{"A" |->
class(
thunk abstraction reference
object(fresh-atom,"A",map(),
object(fresh-atom,"O",map())),
{"a" |-> 1}, "O")}
,
{"B" |->
class(
thunk abstraction reference
object(fresh-atom,"B",map(),
object(fresh-atom,"O",map())),
map(), "O")}
,
{"C" |->
class(
thunk abstraction reference
object(fresh-atom,"C",map(),
object(fresh-atom,"O",map())),
map(), "O")}
,
{"D" |->
class(
thunk abstraction reference
object(fresh-atom,"D",map(),
object(fresh-atom,"O",map())),
map(), "O")}
,
{"E" |->
class(
thunk abstraction reference
object(fresh-atom,"E",map(),
object(fresh-atom,"O",map())),
map(), "O")}
,
{"K1" |->
class(
thunk abstraction reference
object(fresh-atom,"K1",map(),
object(fresh-atom,"A",map(),object(fresh-atom,"O",map())),
object(fresh-atom,"B",map(),object(fresh-atom,"O",map())),
object(fresh-atom,"C",map(),object(fresh-atom,"O",map()))),
{"k1" |-> 1, "a" |-> 2} , "A", "B", "C")}
,
{"K2" |->
class(
thunk abstraction reference
object(fresh-atom,"K2",map(),
object(fresh-atom,"D",map(),object(fresh-atom,"O",map())),
object(fresh-atom,"B",map(),object(fresh-atom,"O",map())),
object(fresh-atom,"E",map(),object(fresh-atom,"O",map()))),
map(), "D", "B", "E")}
,
{"K3" |->
class(
thunk abstraction reference
object(fresh-atom,"K3",map(),
object(fresh-atom,"D",map(),object(fresh-atom,"O",map())),
object(fresh-atom,"A",map(),object(fresh-atom,"O",map()))),
map(), "D", "A")}
,
{"K4" |->
class(
thunk abstraction reference
object(fresh-atom,"K3",map(),
object(fresh-atom,"A",map(),object(fresh-atom,"O",map()))),
{"k4" |-> 1, "a" |-> 2}, "A")}
,
{"Z" |->
class(
thunk abstraction reference
object(fresh-atom,"Z",map(),
object(fresh-atom,"K1",map(),
object(fresh-atom,"A",map(),object(fresh-atom,"O",map())),
object(fresh-atom,"B",map(),object(fresh-atom,"O",map())),
object(fresh-atom,"C",map(),object(fresh-atom,"O",map()))),
object(fresh-atom,"K2",map(),
object(fresh-atom,"D",map(),object(fresh-atom,"O",map())),
object(fresh-atom,"B",map(),object(fresh-atom,"O",map())),
object(fresh-atom,"E",map(),object(fresh-atom,"O",map()))),
object(fresh-atom,"K3",map(),
object(fresh-atom,"D",map(),object(fresh-atom,"O",map())),
object(fresh-atom,"A",map(),object(fresh-atom,"O",map())))),
map(), "K1", "K2", "K3")}
),
sequential(
print class-name-single-inheritance-feature-map "O",
print class-name-single-inheritance-feature-map "A",
print class-name-single-inheritance-feature-map "K4"
)
)
;
}
tests {
result-term: null-value;
standard-out: [
map()
,
{"a" |-> 1 }
,
{"k4" |-> 1, "a" |-> 2}
];
}

129
IBAF-cbs/Funcons-beta/Values/Composite/Classes/tests/class-name-tree.config Normal file
View File

@@ -0,0 +1,129 @@
//[https://en.wikipedia.org/wiki/C3_linearization]:
//class O
//class A extends O
//class B extends O
//class C extends O
//class D extends O
//class E extends O
//class K1 extends A, B, C
//class K2 extends D, B, E
//class K3 extends D, A
//class Z extends K1, K2, K3
general {
funcon-term:
initialise-giving initialise-generating initialise-binding finalise-failing
scope(collateral(
{"O" |->
class(
thunk abstraction reference
object(fresh-atom,"O",map()),
map())}
,
{"A" |->
class(
thunk abstraction reference
object(fresh-atom,"A",map(),
object(fresh-atom,"O",map())),
map(), "O")}
,
{"B" |->
class(
thunk abstraction reference
object(fresh-atom,"B",map(),
object(fresh-atom,"O",map())),
map(), "O")}
,
{"C" |->
class(
thunk abstraction reference
object(fresh-atom,"C",map(),
object(fresh-atom,"O",map())),
map(), "O")}
,
{"D" |->
class(
thunk abstraction reference
object(fresh-atom,"D",map(),
object(fresh-atom,"O",map())),
map(), "O")}
,
{"E" |->
class(
thunk abstraction reference
object(fresh-atom,"E",map(),
object(fresh-atom,"O",map())),
map(), "O")}
,
{"K1" |->
class(
thunk abstraction reference
object(fresh-atom,"K1",map(),
object(fresh-atom,"A",map(),object(fresh-atom,"O",map())),
object(fresh-atom,"B",map(),object(fresh-atom,"O",map())),
object(fresh-atom,"C",map(),object(fresh-atom,"O",map()))),
map(), "A", "B", "C")}
,
{"K2" |->
class(
thunk abstraction reference
object(fresh-atom,"K2",map(),
object(fresh-atom,"D",map(),object(fresh-atom,"O",map())),
object(fresh-atom,"B",map(),object(fresh-atom,"O",map())),
object(fresh-atom,"E",map(),object(fresh-atom,"O",map()))),
map(), "D", "B", "E")}
,
{"K3" |->
class(
thunk abstraction reference
object(fresh-atom,"K3",map(),
object(fresh-atom,"D",map(),object(fresh-atom,"O",map())),
object(fresh-atom,"A",map(),object(fresh-atom,"O",map()))),
map(), "D", "A")}
,
{"Z" |->
class(
thunk abstraction reference
object(fresh-atom,"Z",map(),
object(fresh-atom,"K1",map(),
object(fresh-atom,"A",map(),object(fresh-atom,"O",map())),
object(fresh-atom,"B",map(),object(fresh-atom,"O",map())),
object(fresh-atom,"C",map(),object(fresh-atom,"O",map()))),
object(fresh-atom,"K2",map(),
object(fresh-atom,"D",map(),object(fresh-atom,"O",map())),
object(fresh-atom,"B",map(),object(fresh-atom,"O",map())),
object(fresh-atom,"E",map(),object(fresh-atom,"O",map()))),
object(fresh-atom,"K3",map(),
object(fresh-atom,"D",map(),object(fresh-atom,"O",map())),
object(fresh-atom,"A",map(),object(fresh-atom,"O",map())))),
map(), "K1", "K2", "K3")}
),
sequential(
print class-name-tree "O",
print class-name-tree "A",
print class-name-tree "K1",
print class-name-tree "Z"
)
)
;
}
tests {
result-term: null-value;
standard-out: [
tree("O")
,
tree("A", tree("O"))
,
tree("K1", tree("A", tree("O")), tree("B", tree("O")), tree("C", tree("O")))
,
tree("Z",
tree("K1", tree("A", tree("O")), tree("B", tree("O")), tree("C", tree("O")))
,
tree("K2", tree("D", tree("O")), tree("B", tree("O")), tree("E", tree("O")))
,
tree("K3", tree("D", tree("O")), tree("A", tree("O")))
)
];
}

120
IBAF-cbs/Funcons-beta/Values/Composite/Classes/tests/class-superclass-name-sequence.config Normal file
View File

@@ -0,0 +1,120 @@
//[https://en.wikipedia.org/wiki/C3_linearization]:
//class O
//class A extends O
//class B extends O
//class C extends O
//class D extends O
//class E extends O
//class K1 extends A, B, C
//class K2 extends D, B, E
//class K3 extends D, A
//class Z extends K1, K2, K3
general {
funcon-term:
initialise-giving initialise-generating initialise-binding finalise-failing
scope(collateral(
{"O" |->
class(
thunk abstraction reference
object(fresh-atom,"O",map()),
map())}
,
{"A" |->
class(
thunk abstraction reference
object(fresh-atom,"A",map(),
object(fresh-atom,"O",map())),
map(), "O")}
,
{"B" |->
class(
thunk abstraction reference
object(fresh-atom,"B",map(),
object(fresh-atom,"O",map())),
map(), "O")}
,
{"C" |->
class(
thunk abstraction reference
object(fresh-atom,"C",map(),
object(fresh-atom,"O",map())),
map(), "O")}
,
{"D" |->
class(
thunk abstraction reference
object(fresh-atom,"D",map(),
object(fresh-atom,"O",map())),
map(), "O")}
,
{"E" |->
class(
thunk abstraction reference
object(fresh-atom,"E",map(),
object(fresh-atom,"O",map())),
map(), "O")}
,
{"K1" |->
class(
thunk abstraction reference
object(fresh-atom,"K1",map(),
object(fresh-atom,"A",map(),object(fresh-atom,"O",map())),
object(fresh-atom,"B",map(),object(fresh-atom,"O",map())),
object(fresh-atom,"C",map(),object(fresh-atom,"O",map()))),
map(), "A", "B", "C")}
,
{"K2" |->
class(
thunk abstraction reference
object(fresh-atom,"K2",map(),
object(fresh-atom,"D",map(),object(fresh-atom,"O",map())),
object(fresh-atom,"B",map(),object(fresh-atom,"O",map())),
object(fresh-atom,"E",map(),object(fresh-atom,"O",map()))),
map(), "D", "B", "E")}
,
{"K3" |->
class(
thunk abstraction reference
object(fresh-atom,"K3",map(),
object(fresh-atom,"D",map(),object(fresh-atom,"O",map())),
object(fresh-atom,"A",map(),object(fresh-atom,"O",map()))),
map(), "D", "A")}
,
{"Z" |->
class(
thunk abstraction reference
object(fresh-atom,"Z",map(),
object(fresh-atom,"K1",map(),
object(fresh-atom,"A",map(),object(fresh-atom,"O",map())),
object(fresh-atom,"B",map(),object(fresh-atom,"O",map())),
object(fresh-atom,"C",map(),object(fresh-atom,"O",map()))),
object(fresh-atom,"K2",map(),
object(fresh-atom,"D",map(),object(fresh-atom,"O",map())),
object(fresh-atom,"B",map(),object(fresh-atom,"O",map())),
object(fresh-atom,"E",map(),object(fresh-atom,"O",map()))),
object(fresh-atom,"K3",map(),
object(fresh-atom,"D",map(),object(fresh-atom,"O",map())),
object(fresh-atom,"A",map(),object(fresh-atom,"O",map())))),
map(), "K1", "K2", "K3")}
),
sequential(
print [class-superclass-name-sequence bound-value "O"],
print [class-superclass-name-sequence bound-value "A"],
print [class-superclass-name-sequence bound-value "K1"]
)
)
;
}
tests {
result-term: null-value;
standard-out: [
[]
,
["O"]
,
["A", "B", "C"]
];
}

142
IBAF-cbs/Funcons-beta/Values/Composite/Classes/tests/class.config Normal file
View File

@@ -0,0 +1,142 @@
//[https://en.wikipedia.org/wiki/C3_linearization]:
//class O
//class A extends O
//class B extends O
//class C extends O
//class D extends O
//class E extends O
//class K1 extends A, B, C
//class K2 extends D, B, E
//class K3 extends D, A
//class Z extends K1, K2, K3
general {
funcon-term:
initialise-giving initialise-generating initialise-binding finalise-failing
scope(collateral(
{"O" |->
class(
thunk abstraction reference
object(fresh-atom,"O",map()),
map())}
,
{"A" |->
class(
thunk abstraction reference
object(fresh-atom,"A",map(),
object(fresh-atom,"O",map())),
map(), "O")}
,
{"B" |->
class(
thunk abstraction reference
object(fresh-atom,"B",map(),
object(fresh-atom,"O",map())),
map(), "O")}
,
{"C" |->
class(
thunk abstraction reference
object(fresh-atom,"C",map(),
object(fresh-atom,"O",map())),
map(), "O")}
,
{"D" |->
class(
thunk abstraction reference
object(fresh-atom,"D",map(),
object(fresh-atom,"O",map())),
map(), "O")}
,
{"E" |->
class(
thunk abstraction reference
object(fresh-atom,"E",map(),
object(fresh-atom,"O",map())),
map(), "O")}
,
{"K1" |->
class(
thunk abstraction reference
object(fresh-atom,"K1",map(),
object(fresh-atom,"A",map(),object(fresh-atom,"O",map())),
object(fresh-atom,"B",map(),object(fresh-atom,"O",map())),
object(fresh-atom,"C",map(),object(fresh-atom,"O",map()))),
map(), "A", "B", "C")}
,
{"K2" |->
class(
thunk abstraction reference
object(fresh-atom,"K2",map(),
object(fresh-atom,"D",map(),object(fresh-atom,"O",map())),
object(fresh-atom,"B",map(),object(fresh-atom,"O",map())),
object(fresh-atom,"E",map(),object(fresh-atom,"O",map()))),
map(), "D", "B", "E")}
,
{"K3" |->
class(
thunk abstraction reference
object(fresh-atom,"K3",map(),
object(fresh-atom,"D",map(),object(fresh-atom,"O",map())),
object(fresh-atom,"A",map(),object(fresh-atom,"O",map()))),
map(), "D", "A")}
,
{"Z" |->
class(
thunk abstraction reference
object(fresh-atom,"Z",map(),
object(fresh-atom,"K1",map(),
object(fresh-atom,"A",map(),object(fresh-atom,"O",map())),
object(fresh-atom,"B",map(),object(fresh-atom,"O",map())),
object(fresh-atom,"C",map(),object(fresh-atom,"O",map()))),
object(fresh-atom,"K2",map(),
object(fresh-atom,"D",map(),object(fresh-atom,"O",map())),
object(fresh-atom,"B",map(),object(fresh-atom,"O",map())),
object(fresh-atom,"E",map(),object(fresh-atom,"O",map()))),
object(fresh-atom,"K3",map(),
object(fresh-atom,"D",map(),object(fresh-atom,"O",map())),
object(fresh-atom,"A",map(),object(fresh-atom,"O",map())))),
map(), "K1", "K2", "K3")}
),
sequential(
print bound-value "O",
print bound-value "A",
print bound-value "K1",
print bound-value "Z"
)
)
;
}
tests {
result-term: null-value;
standard-out: [
class(thunk abstraction reference object(fresh-atom,"O",map()), map())
,
class(thunk abstraction reference
object(fresh-atom,"A",map(), object(fresh-atom,"O",map())), map(), "O")
,
class(thunk abstraction reference
object(fresh-atom,"K1",map(),
object(fresh-atom,"A",map(),object(fresh-atom,"O",map())),
object(fresh-atom,"B",map(),object(fresh-atom,"O",map())),
object(fresh-atom,"C",map(),object(fresh-atom,"O",map()))),
map(), "A", "B", "C")
,
class(thunk abstraction reference
object(fresh-atom,"Z",map(),
object(fresh-atom,"K1",map(),
object(fresh-atom,"A",map(),object(fresh-atom,"O",map())),
object(fresh-atom,"B",map(),object(fresh-atom,"O",map())),
object(fresh-atom,"C",map(),object(fresh-atom,"O",map()))),
object(fresh-atom,"K2",map(),
object(fresh-atom,"D",map(),object(fresh-atom,"O",map())),
object(fresh-atom,"B",map(),object(fresh-atom,"O",map())),
object(fresh-atom,"E",map(),object(fresh-atom,"O",map()))),
object(fresh-atom,"K3",map(),
object(fresh-atom,"D",map(),object(fresh-atom,"O",map())),
object(fresh-atom,"A",map(),object(fresh-atom,"O",map())))),
map(), "K1", "K2", "K3")
];
}

124
IBAF-cbs/Funcons-beta/Values/Composite/Classes/tests/is-subclass-name.config Normal file
View File

@@ -0,0 +1,124 @@
//[https://en.wikipedia.org/wiki/C3_linearization]:
//class O
//class A extends O
//class B extends O
//class C extends O
//class D extends O
//class E extends O
//class K1 extends A, B, C
//class K2 extends D, B, E
//class K3 extends D, A
//class Z extends K1, K2, K3
general {
funcon-term:
initialise-giving initialise-generating initialise-binding finalise-failing
scope(collateral(
{"O" |->
class(
thunk abstraction reference
object(fresh-atom,"O",map()),
map())}
,
{"A" |->
class(
thunk abstraction reference
object(fresh-atom,"A",map(),
object(fresh-atom,"O",map())),
map(), "O")}
,
{"B" |->
class(
thunk abstraction reference
object(fresh-atom,"B",map(),
object(fresh-atom,"O",map())),
map(), "O")}
,
{"C" |->
class(
thunk abstraction reference
object(fresh-atom,"C",map(),
object(fresh-atom,"O",map())),
map(), "O")}
,
{"D" |->
class(
thunk abstraction reference
object(fresh-atom,"D",map(),
object(fresh-atom,"O",map())),
map(), "O")}
,
{"E" |->
class(
thunk abstraction reference
object(fresh-atom,"E",map(),
object(fresh-atom,"O",map())),
map(), "O")}
,
{"K1" |->
class(
thunk abstraction reference
object(fresh-atom,"K1",map(),
object(fresh-atom,"A",map(),object(fresh-atom,"O",map())),
object(fresh-atom,"B",map(),object(fresh-atom,"O",map())),
object(fresh-atom,"C",map(),object(fresh-atom,"O",map()))),
map(), "A", "B", "C")}
,
{"K2" |->
class(
thunk abstraction reference
object(fresh-atom,"K2",map(),
object(fresh-atom,"D",map(),object(fresh-atom,"O",map())),
object(fresh-atom,"B",map(),object(fresh-atom,"O",map())),
object(fresh-atom,"E",map(),object(fresh-atom,"O",map()))),
map(), "D", "B", "E")}
,
{"K3" |->
class(
thunk abstraction reference
object(fresh-atom,"K3",map(),
object(fresh-atom,"D",map(),object(fresh-atom,"O",map())),
object(fresh-atom,"A",map(),object(fresh-atom,"O",map()))),
map(), "D", "A")}
,
{"Z" |->
class(
thunk abstraction reference
object(fresh-atom,"Z",map(),
object(fresh-atom,"K1",map(),
object(fresh-atom,"A",map(),object(fresh-atom,"O",map())),
object(fresh-atom,"B",map(),object(fresh-atom,"O",map())),
object(fresh-atom,"C",map(),object(fresh-atom,"O",map()))),
object(fresh-atom,"K2",map(),
object(fresh-atom,"D",map(),object(fresh-atom,"O",map())),
object(fresh-atom,"B",map(),object(fresh-atom,"O",map())),
object(fresh-atom,"E",map(),object(fresh-atom,"O",map()))),
object(fresh-atom,"K3",map(),
object(fresh-atom,"D",map(),object(fresh-atom,"O",map())),
object(fresh-atom,"A",map(),object(fresh-atom,"O",map())))),
map(), "K1", "K2", "K3")}
),
sequential(
print {forest-value-sequence class-name-tree "O"},
print {forest-value-sequence class-name-tree "A"},
print {forest-value-sequence class-name-tree "K1"},
print {forest-value-sequence class-name-tree "K2"},
print {forest-value-sequence class-name-tree "K3"},
print {forest-value-sequence class-name-tree "Z"}
)
)
;
}
tests {
result-term: null-value;
standard-out: [
{"O"},
{"A","O"},
{"A","B","C","K1","O"},
{"B","D","E","K2","O"},
{"A","D","K3","O"},
{"A","B","C","D","E","K1","K2","K3","O","Z"}
];
}

41
IBAF-cbs/Funcons-beta/Values/Composite/Datatypes/Datatypes.cbs Normal file
View File

@@ -0,0 +1,41 @@
### Datatypes
[
Type datatype-values
Funcon datatype-value
Funcon datatype-value-id
Funcon datatype-value-elements
]
/*
A datatype value consists of an identifier and a sequence of values.
'Datatype T ::= ...' declares the type `T` to refer to a fresh value
constructor in `types`, and asserts ``T <: datatype-values``.
Each constructor funcon 'F(_:T1,...,_:Tn)' of the datatype declaration
generates values in `T` of the form `datatype-value("F", V1, ..., Vn)` from
`V1:T1`, ..., `Vn:Tn`.
Note that a computation `X` cannot be directly included in datatype values:
it is necessary to encapsulate it in `abstraction(X)`.
'Datatype T', followed by declarations of constructor funcons for 'T',
allows specification of GADTs.
*/
Built-in Type
datatype-values
Built-in Funcon
datatype-value(_:identifiers, _:values*) : datatype-values
Funcon
datatype-value-id(_:datatype-values) : =>identifiers
Rule
datatype-value-id(datatype-value(I:identifiers, _*:values*)) ~> I
Funcon
datatype-value-elements(_:datatype-values) : =>values*
Rule
datatype-value-elements(datatype-value(_:identifiers, V*:values*)) ~> V*

76
IBAF-cbs/Funcons-beta/Values/Composite/Datatypes/index.md Normal file
View File

@@ -0,0 +1,76 @@
---
layout: default
title: "Datatypes"
parent: Composite
ancestor: Funcons-beta
---
[Funcons-beta] : [Datatypes.cbs]
-----------------------------
### Datatypes
<div class="highlighter-rouge"><pre class="highlight"><code>[
<i class="keyword">Type</i> <span class="name"><a href="#Name_datatype-values">datatype-values</a></span>
<i class="keyword">Funcon</i> <span class="name"><a href="#Name_datatype-value">datatype-value</a></span>
<i class="keyword">Funcon</i> <span class="name"><a href="#Name_datatype-value-id">datatype-value-id</a></span>
<i class="keyword">Funcon</i> <span class="name"><a href="#Name_datatype-value-elements">datatype-value-elements</a></span>
]</code></pre></div>
A datatype value consists of an identifier and a sequence of values.
'Datatype T ::= ...' declares the type <code><i class="var">T</i></code> to refer to a fresh value
constructor in <code><span class="name"><a href="../../Value-Types/index.html#Name_types">types</a></span></code>, and asserts <code><i class="var">T</i> <: <span class="name"><a href="#Name_datatype-values">datatype-values</a></span></code>.
Each constructor funcon 'F(_:T1,...,_:Tn)' of the datatype declaration
generates values in <code><i class="var">T</i></code> of the form <code><span class="name"><a href="#Name_datatype-value">datatype-value</a></span>("F", <i class="var">V<sub class="sub">1</sub></i>, ..., <i class="var">Vn</i>)</code> from
<code><i class="var">V<sub class="sub">1</sub></i>:<i class="var">T<sub class="sub">1</sub></i></code>, ..., <code><i class="var">Vn</i>:<i class="var">Tn</i></code>.
Note that a computation <code><i class="var">X</i></code> cannot be directly included in datatype values:
it is necessary to encapsulate it in <code><span class="name"><a href="../../Abstraction/Generic/index.html#Name_abstraction">abstraction</a></span>(<i class="var">X</i>)</code>.
'Datatype T', followed by declarations of constructor funcons for 'T',
allows specification of GADTs.
<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_datatype-values">datatype-values</span></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_datatype-value">datatype-value</span></span>(_:<span class="name"><a href="../../../Computations/Normal/Binding/index.html#Name_identifiers">identifiers</a></span>, _:<span class="name"><a href="../../Value-Types/index.html#Name_values">values</a></span><sup class="sup">*</sup>) : <span class="name"><a href="#Name_datatype-values">datatype-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_datatype-value-id">datatype-value-id</span></span>(_:<span class="name"><a href="#Name_datatype-values">datatype-values</a></span>) : =><span class="name"><a href="../../../Computations/Normal/Binding/index.html#Name_identifiers">identifiers</a></span>
<i class="keyword">Rule</i>
<span class="name"><a href="#Name_datatype-value-id">datatype-value-id</a></span>(<span class="name"><a href="#Name_datatype-value">datatype-value</a></span>(<span id="Variable250_I"><i class="var">I</i></span>:<span class="name"><a href="../../../Computations/Normal/Binding/index.html#Name_identifiers">identifiers</a></span>, _*:<span class="name"><a href="../../Value-Types/index.html#Name_values">values</a></span><sup class="sup">*</sup>)) ~> <a href="#Variable250_I"><i class="var">I</i></a></code></pre></div>
<div class="highlighter-rouge"><pre class="highlight"><code><i class="keyword">Funcon</i>
<span class="name"><span id="Name_datatype-value-elements">datatype-value-elements</span></span>(_:<span class="name"><a href="#Name_datatype-values">datatype-values</a></span>) : =><span class="name"><a href="../../Value-Types/index.html#Name_values">values</a></span><sup class="sup">*</sup>
<i class="keyword">Rule</i>
<span class="name"><a href="#Name_datatype-value-elements">datatype-value-elements</a></span>(<span class="name"><a href="#Name_datatype-value">datatype-value</a></span>(_:<span class="name"><a href="../../../Computations/Normal/Binding/index.html#Name_identifiers">identifiers</a></span>, <span id="Variable321_V*"><i class="var">V<sup class="sup">*</sup></i></span>:<span class="name"><a href="../../Value-Types/index.html#Name_values">values</a></span><sup class="sup">*</sup>)) ~> <a href="#Variable321_V*"><i class="var">V<sup class="sup">*</sup></i></a></code></pre></div>
____
From the [PLanCompS Project] | [CBS-beta issues...] | [Suggest an improvement...]
[Datatypes.cbs]: Datatypes.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/Datatypes/Datatypes.cbs%0A%0AComment/Query/Issue/Suggestion%3A%0A%0A%0ASignature%3A%0A
"GENERATE AN EMAIL TEMPLATE"

33
IBAF-cbs/Funcons-beta/Values/Composite/Graphs/Graphs.cbs Normal file
View File

@@ -0,0 +1,33 @@
### Graphs
[
Type directed-graphs
Funcon is-cyclic
Funcon topological-sort
]
Meta-variables
GT <: ground-values
Type
directed-graphs(GT) ~> maps(GT, sets(GT))
/*
`directed-graphs(GT)` models directed graphs with vertices of type `GT`,
represented as maps from vertices to the set of vertices to which the
vertex has an edge. E.g., the graph
(1)--->(2)
would be represented as `{ 1 |-> {2}, 2 |-> {} }`
*/
Built-in Funcon
is-cyclic(_:directed-graphs(GT)) : =>booleans
Built-in Funcon
topological-sort(_:directed-graphs(GT)) : =>(GT)*
/*
`topological-sort(DG)` returns a topological ordering of the vertices
of the graph `DG`, as a sequence of vertices, provided that `DG` is not
cyclic.
*/

69
IBAF-cbs/Funcons-beta/Values/Composite/Graphs/index.md Normal file
View File

@@ -0,0 +1,69 @@
---
layout: default
title: "Graphs"
parent: Composite
ancestor: Funcons-beta
---
[Funcons-beta] : [Graphs.cbs]
-----------------------------
### Graphs
<div class="highlighter-rouge"><pre class="highlight"><code>[
<i class="keyword">Type</i> <span class="name"><a href="#Name_directed-graphs">directed-graphs</a></span>
<i class="keyword">Funcon</i> <span class="name"><a href="#Name_is-cyclic">is-cyclic</a></span>
<i class="keyword">Funcon</i> <span class="name"><a href="#Name_topological-sort">topological-sort</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">Type</i>
<span class="name"><span id="Name_directed-graphs">directed-graphs</span></span>(<span id="Variable40_GT"><i class="var">GT</i></span>) ~> <span class="name"><a href="../Maps/index.html#Name_maps">maps</a></span>(<a href="#Variable40_GT"><i class="var">GT</i></a>, <span class="name"><a href="../Sets/index.html#Name_sets">sets</a></span>(<a href="#Variable40_GT"><i class="var">GT</i></a>))</code></pre></div>
<code><span class="name"><a href="#Name_directed-graphs">directed-graphs</a></span>(<i class="var">GT</i>)</code> models directed graphs with vertices of type <code><i class="var">GT</i></code>,
represented as maps from vertices to the set of vertices to which the
vertex has an edge. E.g., the graph
(1)--->(2)
would be represented as <code>{ 1 |-> {2}, 2 |-> {} }</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_is-cyclic">is-cyclic</span></span>(_:<span class="name"><a href="#Name_directed-graphs">directed-graphs</a></span>(<span id="Variable155_GT"><i class="var">GT</i></span>)) : =><span class="name"><a href="../../Primitive/Booleans/index.html#Name_booleans">booleans</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_topological-sort">topological-sort</span></span>(_:<span class="name"><a href="#Name_directed-graphs">directed-graphs</a></span>(<span id="Variable186_GT"><i class="var">GT</i></span>)) : =>(<span id="Variable206_GT"><i class="var">GT</i></span>)<sup class="sup">*</sup></code></pre></div>
<code><span class="name"><a href="#Name_topological-sort">topological-sort</a></span>(<i class="var">DG</i>)</code> returns a topological ordering of the vertices
of the graph <code><i class="var">DG</i></code>, as a sequence of vertices, provided that <code><i class="var">DG</i></code> is not
cyclic.
____
From the [PLanCompS Project] | [CBS-beta issues...] | [Suggest an improvement...]
[Graphs.cbs]: Graphs.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/Graphs/Graphs.cbs%0A%0AComment/Query/Issue/Suggestion%3A%0A%0A%0ASignature%3A%0A
"GENERATE AN EMAIL TEMPLATE"

98
IBAF-cbs/Funcons-beta/Values/Composite/Lists/Lists.cbs Normal file
View File

@@ -0,0 +1,98 @@
### Lists
[
Datatype lists
Funcon list
Funcon list-elements
Funcon list-nil Alias nil
Funcon list-cons Alias cons
Funcon list-head Alias head
Funcon list-tail Alias tail
Funcon list-length
Funcon list-append
]
Meta-variables
T <: values
Datatype
lists(T) ::= list(_:(T)*)
/*
`lists(T)` is the type of possibly-empty finite lists `[V1,...,Vn]`
where `V1:T`, ..., `Vn:T`.
N.B. `[T]` is always a single list value, and *not* interpreted as the
type `lists(T)`.
The notation `[V1, ..., Vn]` for `list(V1, ..., Vn)` is built-in.
*/
Assert
[V*:values*] == list(V*)
Funcon
list-elements(_:lists(T)) : =>(T)*
Rule
list-elements(list(V*:values*)) ~> V*
Funcon
list-nil : =>lists(_)
~> [ ]
Alias
nil = list-nil
Funcon
list-cons(_:T, _:lists(T)) : =>lists(T)
Alias
cons = list-cons
Rule
list-cons(V:values, [V*:values*]) ~> [V, V*]
Funcon
list-head(_:lists(T)) : =>(T)?
Alias
head = list-head
Rule
list-head[V:values, _*:values*] ~> V
Rule
list-head[ ] ~> ( )
Funcon
list-tail(_:lists(T)) : =>(lists(T))?
Alias
tail = list-tail
Rule
list-tail[_:values, V*:values*] ~> [V*]
Rule
list-tail[ ] ~> ( )
Funcon
list-length(_:lists(T)) : =>natural-numbers
Rule
list-length[V*:values*] ~> length(V*)
Funcon
list-append(_:(lists(T))*) : =>lists(T)
Rule
list-append([V1*:values*], [V2*:values*]) ~> [V1*, V2*]
Rule
list-append(L1:lists(_), L2:lists(_), L3:lists(_), L*:(lists(_))*)
~> list-append(L1, list-append(L2, L3, L*))
Rule
list-append( ) ~> [ ]
Rule
list-append(L:lists(_)) ~> L
/*
Datatypes of infinite and possibly-infinite lists can be specified as
algebraic datatypes using abstractions.
*/

132
IBAF-cbs/Funcons-beta/Values/Composite/Lists/index.md Normal file
View File

@@ -0,0 +1,132 @@
---
layout: default
title: "Lists"
parent: Composite
ancestor: Funcons-beta
---
[Funcons-beta] : [Lists.cbs]
-----------------------------
### Lists
<div class="highlighter-rouge"><pre class="highlight"><code>[
<i class="keyword">Datatype</i> <span class="name"><a href="#Name_lists">lists</a></span>
<i class="keyword">Funcon</i> <span class="name"><a href="#Name_list">list</a></span>
<i class="keyword">Funcon</i> <span class="name"><a href="#Name_list-elements">list-elements</a></span>
<i class="keyword">Funcon</i> <span class="name"><a href="#Name_list-nil">list-nil</a></span> <i class="keyword">Alias</i> <span class="name"><a href="#Name_nil">nil</a></span>
<i class="keyword">Funcon</i> <span class="name"><a href="#Name_list-cons">list-cons</a></span> <i class="keyword">Alias</i> <span class="name"><a href="#Name_cons">cons</a></span>
<i class="keyword">Funcon</i> <span class="name"><a href="#Name_list-head">list-head</a></span> <i class="keyword">Alias</i> <span class="name"><a href="#Name_head">head</a></span>
<i class="keyword">Funcon</i> <span class="name"><a href="#Name_list-tail">list-tail</a></span> <i class="keyword">Alias</i> <span class="name"><a href="#Name_tail">tail</a></span>
<i class="keyword">Funcon</i> <span class="name"><a href="#Name_list-length">list-length</a></span>
<i class="keyword">Funcon</i> <span class="name"><a href="#Name_list-append">list-append</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="../../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_lists">lists</span></span>(<span id="Variable80_T"><i class="var">T</i></span>) ::= <span id="Name_list">list</span>(_:(<span id="Variable96_T"><i class="var">T</i></span>)<sup class="sup">*</sup>)</code></pre></div>
<code><span class="name"><a href="#Name_lists">lists</a></span>(<i class="var">T</i>)</code> is the type of possibly-empty finite lists <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">T</i></code>, ..., <code><i class="var">Vn</i>:<i class="var">T</i></code>.
N.B. <code>[<i class="var">T</i>]</code> is always a single list value, and *not* interpreted as the
type <code><span class="name"><a href="#Name_lists">lists</a></span>(<i class="var">T</i>)</code>.
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_list">list</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>:<span class="name"><a href="../../Value-Types/index.html#Name_values">values</a></span><sup class="sup">*</sup>] == <span class="name"><a href="#Name_list">list</a></span>(<i class="var">V<sup class="sup">*</sup></i>)</code></pre></div>
<div class="highlighter-rouge"><pre class="highlight"><code><i class="keyword">Funcon</i>
<span class="name"><span id="Name_list-elements">list-elements</span></span>(_:<span class="name"><a href="#Name_lists">lists</a></span>(<span id="Variable363_T"><i class="var">T</i></span>)) : =>(<span id="Variable383_T"><i class="var">T</i></span>)<sup class="sup">*</sup>
<i class="keyword">Rule</i>
<span class="name"><a href="#Name_list-elements">list-elements</a></span>(<span class="name"><a href="#Name_list">list</a></span>(<span id="Variable401_V*"><i class="var">V<sup class="sup">*</sup></i></span>:<span class="name"><a href="../../Value-Types/index.html#Name_values">values</a></span><sup class="sup">*</sup>)) ~> <a href="#Variable401_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_list-nil">list-nil</span></span> : =><span class="name"><a href="#Name_lists">lists</a></span>(_)
~> [ ]
<i class="keyword">Alias</i>
<span class="name"><span id="Name_nil">nil</span></span> = <span class="name"><a href="#Name_list-nil">list-nil</a></span></code></pre></div>
<div class="highlighter-rouge"><pre class="highlight"><code><i class="keyword">Funcon</i>
<span class="name"><span id="Name_list-cons">list-cons</span></span>(_:<span id="Variable461_T"><i class="var">T</i></span>, _:<span class="name"><a href="#Name_lists">lists</a></span>(<span id="Variable473_T"><i class="var">T</i></span>)) : =><span class="name"><a href="#Name_lists">lists</a></span>(<span id="Variable495_T"><i class="var">T</i></span>)
<i class="keyword">Alias</i>
<span class="name"><span id="Name_cons">cons</span></span> = <span class="name"><a href="#Name_list-cons">list-cons</a></span></code></pre></div>
<div class="highlighter-rouge"><pre class="highlight"><code><i class="keyword">Rule</i>
<span class="name"><a href="#Name_list-cons">list-cons</a></span>(<span id="Variable513_V"><i class="var">V</i></span>:<span class="name"><a href="../../Value-Types/index.html#Name_values">values</a></span>, [<span id="Variable522_V*"><i class="var">V<sup class="sup">*</sup></i></span>:<span class="name"><a href="../../Value-Types/index.html#Name_values">values</a></span><sup class="sup">*</sup>]) ~> [<a href="#Variable513_V"><i class="var">V</i></a>, <a href="#Variable522_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_list-head">list-head</span></span>(_:<span class="name"><a href="#Name_lists">lists</a></span>(<span id="Variable569_T"><i class="var">T</i></span>)) : =>(<span id="Variable589_T"><i class="var">T</i></span>)<sup class="sup">?</sup>
<i class="keyword">Alias</i>
<span class="name"><span id="Name_head">head</span></span> = <span class="name"><a href="#Name_list-head">list-head</a></span></code></pre></div>
<div class="highlighter-rouge"><pre class="highlight"><code><i class="keyword">Rule</i>
<span class="name"><a href="#Name_list-head">list-head</a></span>[<span id="Variable608_V"><i class="var">V</i></span>:<span class="name"><a href="../../Value-Types/index.html#Name_values">values</a></span>, _*:<span class="name"><a href="../../Value-Types/index.html#Name_values">values</a></span><sup class="sup">*</sup>] ~> <a href="#Variable608_V"><i class="var">V</i></a>
<i class="keyword">Rule</i>
<span class="name"><a href="#Name_list-head">list-head</a></span>[ ] ~> ( )</code></pre></div>
<div class="highlighter-rouge"><pre class="highlight"><code><i class="keyword">Funcon</i>
<span class="name"><span id="Name_list-tail">list-tail</span></span>(_:<span class="name"><a href="#Name_lists">lists</a></span>(<span id="Variable659_T"><i class="var">T</i></span>)) : =>(<span class="name"><a href="#Name_lists">lists</a></span>(<span id="Variable680_T"><i class="var">T</i></span>))<sup class="sup">?</sup>
<i class="keyword">Alias</i>
<span class="name"><span id="Name_tail">tail</span></span> = <span class="name"><a href="#Name_list-tail">list-tail</a></span></code></pre></div>
<div class="highlighter-rouge"><pre class="highlight"><code><i class="keyword">Rule</i>
<span class="name"><a href="#Name_list-tail">list-tail</a></span>[_:<span class="name"><a href="../../Value-Types/index.html#Name_values">values</a></span>, <span id="Variable713_V*"><i class="var">V<sup class="sup">*</sup></i></span>:<span class="name"><a href="../../Value-Types/index.html#Name_values">values</a></span><sup class="sup">*</sup>] ~> [<a href="#Variable713_V*"><i class="var">V<sup class="sup">*</sup></i></a>]
<i class="keyword">Rule</i>
<span class="name"><a href="#Name_list-tail">list-tail</a></span>[ ] ~> ( )</code></pre></div>
<div class="highlighter-rouge"><pre class="highlight"><code><i class="keyword">Funcon</i>
<span class="name"><span id="Name_list-length">list-length</span></span>(_:<span class="name"><a href="#Name_lists">lists</a></span>(<span id="Variable762_T"><i class="var">T</i></span>)) : =><span class="name"><a href="../../Primitive/Integers/index.html#Name_natural-numbers">natural-numbers</a></span>
<i class="keyword">Rule</i>
<span class="name"><a href="#Name_list-length">list-length</a></span>[<span id="Variable789_V*"><i class="var">V<sup class="sup">*</sup></i></span>:<span class="name"><a href="../../Value-Types/index.html#Name_values">values</a></span><sup class="sup">*</sup>] ~> <span class="name"><a href="../Sequences/index.html#Name_length">length</a></span>(<a href="#Variable789_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_list-append">list-append</span></span>(_:(<span class="name"><a href="#Name_lists">lists</a></span>(<span id="Variable826_T"><i class="var">T</i></span>))<sup class="sup">*</sup>) : =><span class="name"><a href="#Name_lists">lists</a></span>(<span id="Variable854_T"><i class="var">T</i></span>)
<i class="keyword">Rule</i>
<span class="name"><a href="#Name_list-append">list-append</a></span>([<span id="Variable871_V1*"><i class="var">V<sub class="sub">1</sub><sup class="sup">*</sup></i></span>:<span class="name"><a href="../../Value-Types/index.html#Name_values">values</a></span><sup class="sup">*</sup>], [<span id="Variable888_V2*"><i class="var">V<sub class="sub">2</sub><sup class="sup">*</sup></i></span>:<span class="name"><a href="../../Value-Types/index.html#Name_values">values</a></span><sup class="sup">*</sup>]) ~> [<a href="#Variable871_V1*"><i class="var">V<sub class="sub">1</sub><sup class="sup">*</sup></i></a>, <a href="#Variable888_V2*"><i class="var">V<sub class="sub">2</sub><sup class="sup">*</sup></i></a>]
<i class="keyword">Rule</i>
<span class="name"><a href="#Name_list-append">list-append</a></span>(<span id="Variable935_L1"><i class="var">L<sub class="sub">1</sub></i></span>:<span class="name"><a href="#Name_lists">lists</a></span>(_), <span id="Variable953_L2"><i class="var">L<sub class="sub">2</sub></i></span>:<span class="name"><a href="#Name_lists">lists</a></span>(_), <span id="Variable971_L3"><i class="var">L<sub class="sub">3</sub></i></span>:<span class="name"><a href="#Name_lists">lists</a></span>(_), <span id="Variable989_L*"><i class="var">L<sup class="sup">*</sup></i></span>:(<span class="name"><a href="#Name_lists">lists</a></span>(_))<sup class="sup">*</sup>)
~> <span class="name"><a href="#Name_list-append">list-append</a></span>(<a href="#Variable935_L1"><i class="var">L<sub class="sub">1</sub></i></a>, <span class="name"><a href="#Name_list-append">list-append</a></span>(<a href="#Variable953_L2"><i class="var">L<sub class="sub">2</sub></i></a>, <a href="#Variable971_L3"><i class="var">L<sub class="sub">3</sub></i></a>, <a href="#Variable989_L*"><i class="var">L<sup class="sup">*</sup></i></a>))
<i class="keyword">Rule</i>
<span class="name"><a href="#Name_list-append">list-append</a></span>( ) ~> [ ]
<i class="keyword">Rule</i>
<span class="name"><a href="#Name_list-append">list-append</a></span>(<span id="Variable1080_L"><i class="var">L</i></span>:<span class="name"><a href="#Name_lists">lists</a></span>(_)) ~> <a href="#Variable1080_L"><i class="var">L</i></a></code></pre></div>
Datatypes of infinite and possibly-infinite lists can be specified as
algebraic datatypes using abstractions.
____
From the [PLanCompS Project] | [CBS-beta issues...] | [Suggest an improvement...]
[Lists.cbs]: Lists.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/Lists/Lists.cbs%0A%0AComment/Query/Issue/Suggestion%3A%0A%0A%0ASignature%3A%0A
"GENERATE AN EMAIL TEMPLATE"

30
IBAF-cbs/Funcons-beta/Values/Composite/Lists/tests/lists.config Normal file
View File

@@ -0,0 +1,30 @@
general {
funcon-term: sequential (
check-true(is-equal(tuple list-elements list( ), tuple( )))
, check-true(is-equal(tuple list-elements list(1), tuple(1)))
, check-true(is-equal(tuple list-elements list(1,2,1,3), tuple(1,2,1,3)))
, check-true(is-equal(list-nil, list( )))
, check-true(is-equal(list-cons(1,list( )), list(1)))
, check-true(is-equal(list-cons(1,list(2,3)), list(1,2,3)))
, check-true(is-equal(list-head(list(1)), 1))
, check-true(is-equal(list-head(list(1,2,3)), 1))
, check-true(not is-value list-head(list( )))
, check-true(is-equal(list-tail(list(1)), list( )))
, check-true(is-equal(list-tail(list(1,2,3)), list(2,3)))
, check-true(not is-value list-tail(list( )))
, check-true(is-equal(list-append( ), list( )))
, check-true(is-equal(list-append(list( )), list( )))
, check-true(is-equal(list-append(list(1,2,3,4)), list(1,2,3,4)))
, check-true(is-equal(list-append(list(1,2), list(3,4)), list(1,2,3,4)))
, check-true(is-equal(list-append(list(1), list(2,3,4)), list(1,2,3,4)))
, check-true(is-equal(list-append(list( ), list(1,2,3,4)), list(1,2,3,4)))
, check-true(is-equal(list-append(list(1,2,3,4),list( )), list(1,2,3,4)))
, check-true(is-equal(list-append(list(1),list(2),list(3,4)), list(1,2,3,4)))
, print "OK"
);
}
tests {
result-term : null-value;
standard-out : ["OK"];
}

111
IBAF-cbs/Funcons-beta/Values/Composite/Maps/Maps.cbs Normal file
View File

@@ -0,0 +1,111 @@
### Maps
[
Type maps
Funcon map
Funcon map-elements
Funcon map-lookup Alias lookup
Funcon map-domain Alias dom
Funcon map-override
Funcon map-unite
Funcon map-delete
]
Meta-variables
GT <: ground-values
T? <: values?
Built-in Type
maps(GT, T?)
/*
`maps(GT, T?)` is the type of possibly-empty finite maps from values of
type `GT` to optional values of type `T?`.
*/
Built-in Funcon
map(_:(tuples(GT, T?))*) : =>(maps(GT, T?))?
/*
`map(tuple(K1, V1?), ..., tuple(Kn, Vn?))` constructs a map from
`K1` to `V1?`, ..., `Kn` to `Vn?`, provided that `K1`, ..., `Kn`
are distinct, otherwise the result is `( )`.
Note that `map(...)` is not a constructor operation.
The built-in notation `{K1|->V1?, ..., Kn|->Vn?}` is equivalent to
`map(tuple(K1, V1?), ..., tuple(Kn, Vn?))`. Note however that in general,
maps cannot be identified with sets of tuples, since the values `Vi?` are
not restricted to `ground-values`.
When ``T? <: types``, ``maps(GT, T?) <: types``. The type `MT:maps(GT, T?)`
represents the set of value-maps `MV:maps(GT, values?)` such that
`dom(MV)` is a subset of `dom(MT)` and for all `K` in `dom(MV)`,
``map-lookup(MV, K) : map-lookup(MT, K)``.
*/
Built-in Funcon
map-elements(_:maps(GT, T?)) : =>(tuples(GT, T?))*
/*
The sequence of tuples `(tuple(K1, V1?), ..., tuple(Kn, Vn?))` given by
`map-elements(M)` contains each mapped value `Ki` just once. The order of
the elements is unspecified, and may vary between maps.
*/
Assert
map(map-elements(M)) == M
Built-in Funcon
map-lookup(_:maps(GT, T?), K:GT) : =>(T?)?
Alias
lookup = map-lookup
/*
`map-lookup(M,K)` gives the optional value to which `K` is mapped by `M`,
if any, and otherwise `( )`.
*/
Built-in Funcon
map-domain(_:maps(GT, T?)) : =>sets(GT)
Alias
dom = map-domain
/*
`map-domain(M)` gives the set of values mapped by `M`.
`map-lookup(M, K)` is always `( )` when `K` is not in `map-domain(M)`.
*/
Built-in Funcon
map-override(_:(maps(GT, T?))*) : =>maps(GT,T?)
/*
`map-override(...)` takes a sequence of maps. It returns the map whose
domain is the union of their domains, and which maps each of those values
to the same optional value as the first map in the sequence in whose domain
it occurs
.
When the domains of the `M*` are disjoint, `map-override(M*)` is equivalent
to `map-unite(M*)`.
*/
Built-in Funcon
map-unite(_:(maps(GT, T?))*) : =>(maps(GT, T?))?
/*
`map-unite(...)` takes a sequence of maps. It returns the map whose
domain is the union of their domains, and which maps each of those values
to the same optional value as the map in the sequence in whose domain it occurs,
provided that those domains are disjoint - otherwise the result is `( )`.
*/
Built-in Funcon
map-delete(_:maps(GT, T?), _:sets(GT)) : =>maps(GT, T?)
/*
`map-delete(M, S)` takes a map `M` and a set of values `S`, and returns the
map obtained from `M` by removing `S` from its domain.
*/
Assert
map-domain(map-delete(M, S)) == set-difference(map-domain(M), S)

147
IBAF-cbs/Funcons-beta/Values/Composite/Maps/index.md Normal file
View File

@@ -0,0 +1,147 @@
---
layout: default
title: "Maps"
parent: Composite
ancestor: Funcons-beta
---
[Funcons-beta] : [Maps.cbs]
-----------------------------
### Maps
<div class="highlighter-rouge"><pre class="highlight"><code>[
<i class="keyword">Type</i> <span class="name"><a href="#Name_maps">maps</a></span>
<i class="keyword">Funcon</i> <span class="name"><a href="#Name_map">map</a></span>
<i class="keyword">Funcon</i> <span class="name"><a href="#Name_map-elements">map-elements</a></span>
<i class="keyword">Funcon</i> <span class="name"><a href="#Name_map-lookup">map-lookup</a></span> <i class="keyword">Alias</i> <span class="name"><a href="#Name_lookup">lookup</a></span>
<i class="keyword">Funcon</i> <span class="name"><a href="#Name_map-domain">map-domain</a></span> <i class="keyword">Alias</i> <span class="name"><a href="#Name_dom">dom</a></span>
<i class="keyword">Funcon</i> <span class="name"><a href="#Name_map-override">map-override</a></span>
<i class="keyword">Funcon</i> <span class="name"><a href="#Name_map-unite">map-unite</a></span>
<i class="keyword">Funcon</i> <span class="name"><a href="#Name_map-delete">map-delete</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>
<span id="PartVariable_T?"><i class="var">T<sup class="sup">?</sup></i></span> <: <span class="name"><a href="../../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">Built-in</i> <i class="keyword">Type</i>
<span class="name"><span id="Name_maps">maps</span></span>(<span id="Variable82_GT"><i class="var">GT</i></span>, <span id="Variable89_T?"><i class="var">T<sup class="sup">?</sup></i></span>)</code></pre></div>
<code><span class="name"><a href="#Name_maps">maps</a></span>(<i class="var">GT</i>, <i class="var">T<sup class="sup">?</sup></i>)</code> is the type of possibly-empty finite maps from values of
type <code><i class="var">GT</i></code> to optional values of type <code><i class="var">T<sup class="sup">?</sup></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_map">map</span></span>(_:(<span class="name"><a href="../Tuples/index.html#Name_tuples">tuples</a></span>(<span id="Variable171_GT"><i class="var">GT</i></span>, <span id="Variable177_T?"><i class="var">T<sup class="sup">?</sup></i></span>))<sup class="sup">*</sup>) : =>(<span class="name"><a href="#Name_maps">maps</a></span>(<span id="Variable206_GT"><i class="var">GT</i></span>, <span id="Variable212_T?"><i class="var">T<sup class="sup">?</sup></i></span>))<sup class="sup">?</sup></code></pre></div>
<code><span class="name"><a href="#Name_map">map</a></span>(<span class="name"><a href="../Tuples/index.html#Name_tuple">tuple</a></span>(<i class="var">K<sub class="sub">1</sub></i>, <i class="var">V<sub class="sub">1</sub><sup class="sup">?</sup></i>), ..., <span class="name"><a href="../Tuples/index.html#Name_tuple">tuple</a></span>(<i class="var">Kn</i>, <i class="var">Vn<sup class="sup">?</sup></i>))</code> constructs a map from
<code><i class="var">K<sub class="sub">1</sub></i></code> to <code><i class="var">V<sub class="sub">1</sub><sup class="sup">?</sup></i></code>, ..., <code><i class="var">Kn</i></code> to <code><i class="var">Vn<sup class="sup">?</sup></i></code>, provided that <code><i class="var">K<sub class="sub">1</sub></i></code>, ..., <code><i class="var">Kn</i></code>
are distinct, otherwise the result is <code>( )</code>.
Note that <code><span class="name"><a href="#Name_map">map</a></span>(...)</code> is not a constructor operation.
The built-in notation <code>{<i class="var">K<sub class="sub">1</sub></i>|-><i class="var">V<sub class="sub">1</sub><sup class="sup">?</sup></i>, ..., <i class="var">Kn</i>|-><i class="var">Vn<sup class="sup">?</sup></i>}</code> is equivalent to
<code><span class="name"><a href="#Name_map">map</a></span>(<span class="name"><a href="../Tuples/index.html#Name_tuple">tuple</a></span>(<i class="var">K<sub class="sub">1</sub></i>, <i class="var">V<sub class="sub">1</sub><sup class="sup">?</sup></i>), ..., <span class="name"><a href="../Tuples/index.html#Name_tuple">tuple</a></span>(<i class="var">Kn</i>, <i class="var">Vn<sup class="sup">?</sup></i>))</code>. Note however that in general,
maps cannot be identified with sets of tuples, since the values <code><i class="var">Vi<sup class="sup">?</sup></i></code> are
not restricted to <code><span class="name"><a href="../../Value-Types/index.html#Name_ground-values">ground-values</a></span></code>.
When <code><i class="var">T<sup class="sup">?</sup></i> <: <span class="name"><a href="../../Value-Types/index.html#Name_types">types</a></span></code>, <code><span class="name"><a href="#Name_maps">maps</a></span>(<i class="var">GT</i>, <i class="var">T<sup class="sup">?</sup></i>) <: <span class="name"><a href="../../Value-Types/index.html#Name_types">types</a></span></code>. The type <code><i class="var">MT</i>:<span class="name"><a href="#Name_maps">maps</a></span>(<i class="var">GT</i>, <i class="var">T<sup class="sup">?</sup></i>)</code>
represents the set of value-maps <code><i class="var">MV</i>:<span class="name"><a href="#Name_maps">maps</a></span>(<i class="var">GT</i>, <span class="name"><a href="../../Value-Types/index.html#Name_values">values</a></span><sup class="sup">?</sup>)</code> such that
<code><span class="name"><a href="#Name_dom">dom</a></span>(<i class="var">MV</i>)</code> is a subset of <code><span class="name"><a href="#Name_dom">dom</a></span>(<i class="var">MT</i>)</code> and for all <code><i class="var">K</i></code> in <code><span class="name"><a href="#Name_dom">dom</a></span>(<i class="var">MV</i>)</code>,
<code><span class="name"><a href="#Name_map-lookup">map-lookup</a></span>(<i class="var">MV</i>, <i class="var">K</i>) : <span class="name"><a href="#Name_map-lookup">map-lookup</a></span>(<i class="var">MT</i>, <i class="var">K</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_map-elements">map-elements</span></span>(_:<span class="name"><a href="#Name_maps">maps</a></span>(<span id="Variable766_GT"><i class="var">GT</i></span>, <span id="Variable772_T?"><i class="var">T<sup class="sup">?</sup></i></span>)) : =>(<span class="name"><a href="../Tuples/index.html#Name_tuples">tuples</a></span>(<span id="Variable794_GT"><i class="var">GT</i></span>, <span id="Variable800_T?"><i class="var">T<sup class="sup">?</sup></i></span>))<sup class="sup">*</sup></code></pre></div>
The sequence of tuples <code>(<span class="name"><a href="../Tuples/index.html#Name_tuple">tuple</a></span>(<i class="var">K<sub class="sub">1</sub></i>, <i class="var">V<sub class="sub">1</sub><sup class="sup">?</sup></i>), ..., <span class="name"><a href="../Tuples/index.html#Name_tuple">tuple</a></span>(<i class="var">Kn</i>, <i class="var">Vn<sup class="sup">?</sup></i>))</code> given by
<code><span class="name"><a href="#Name_map-elements">map-elements</a></span>(<i class="var">M</i>)</code> contains each mapped value <code><i class="var">Ki</i></code> just once. The order of
the elements is unspecified, and may vary between maps.
<div class="highlighter-rouge"><pre class="highlight"><code><i class="keyword">Assert</i>
<span class="name"><a href="#Name_map">map</a></span>(<span class="name"><a href="#Name_map-elements">map-elements</a></span>(<i class="var">M</i>)) == <i class="var">M</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_map-lookup">map-lookup</span></span>(_:<span class="name"><a href="#Name_maps">maps</a></span>(<span id="Variable951_GT"><i class="var">GT</i></span>, <span id="Variable957_T?"><i class="var">T<sup class="sup">?</sup></i></span>), <span id="Variable972_K"><i class="var">K</i></span>:<span id="Variable976_GT"><i class="var">GT</i></span>) : =>(<span id="Variable992_T?"><i class="var">T<sup class="sup">?</sup></i></span>)<sup class="sup">?</sup>
<i class="keyword">Alias</i>
<span class="name"><span id="Name_lookup">lookup</span></span> = <span class="name"><a href="#Name_map-lookup">map-lookup</a></span></code></pre></div>
<code><span class="name"><a href="#Name_map-lookup">map-lookup</a></span>(<i class="var">M</i>,<i class="var">K</i>)</code> gives the optional value to which <code><i class="var">K</i></code> is mapped by <code><i class="var">M</i></code>,
if any, and otherwise <code>( )</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_map-domain">map-domain</span></span>(_:<span class="name"><a href="#Name_maps">maps</a></span>(<span id="Variable1086_GT"><i class="var">GT</i></span>, <span id="Variable1092_T?"><i class="var">T<sup class="sup">?</sup></i></span>)) : =><span class="name"><a href="../Sets/index.html#Name_sets">sets</a></span>(<span id="Variable1114_GT"><i class="var">GT</i></span>)
<i class="keyword">Alias</i>
<span class="name"><span id="Name_dom">dom</span></span> = <span class="name"><a href="#Name_map-domain">map-domain</a></span></code></pre></div>
<code><span class="name"><a href="#Name_map-domain">map-domain</a></span>(<i class="var">M</i>)</code> gives the set of values mapped by <code><i class="var">M</i></code>.
<code><span class="name"><a href="#Name_map-lookup">map-lookup</a></span>(<i class="var">M</i>, <i class="var">K</i>)</code> is always <code>( )</code> when <code><i class="var">K</i></code> is not in <code><span class="name"><a href="#Name_map-domain">map-domain</a></span>(<i class="var">M</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_map-override">map-override</span></span>(_:(<span class="name"><a href="#Name_maps">maps</a></span>(<span id="Variable1247_GT"><i class="var">GT</i></span>, <span id="Variable1253_T?"><i class="var">T<sup class="sup">?</sup></i></span>))<sup class="sup">*</sup>) : =><span class="name"><a href="#Name_maps">maps</a></span>(<span id="Variable1282_GT"><i class="var">GT</i></span>,<span id="Variable1288_T?"><i class="var">T<sup class="sup">?</sup></i></span>)</code></pre></div>
<code><span class="name"><a href="#Name_map-override">map-override</a></span>(...)</code> takes a sequence of maps. It returns the map whose
domain is the union of their domains, and which maps each of those values
to the same optional value as the first map in the sequence in whose domain
it occurs
.
When the domains of the <code><i class="var">M<sup class="sup">*</sup></i></code> are disjoint, <code><span class="name"><a href="#Name_map-override">map-override</a></span>(<i class="var">M<sup class="sup">*</sup></i>)</code> is equivalent
to <code><span class="name"><a href="#Name_map-unite">map-unite</a></span>(<i class="var">M<sup class="sup">*</sup></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_map-unite">map-unite</span></span>(_:(<span class="name"><a href="#Name_maps">maps</a></span>(<span id="Variable1389_GT"><i class="var">GT</i></span>, <span id="Variable1395_T?"><i class="var">T<sup class="sup">?</sup></i></span>))<sup class="sup">*</sup>) : =>(<span class="name"><a href="#Name_maps">maps</a></span>(<span id="Variable1424_GT"><i class="var">GT</i></span>, <span id="Variable1430_T?"><i class="var">T<sup class="sup">?</sup></i></span>))<sup class="sup">?</sup></code></pre></div>
<code><span class="name"><a href="#Name_map-unite">map-unite</a></span>(...)</code> takes a sequence of maps. It returns the map whose
domain is the union of their domains, and which maps each of those values
to the same optional value as the map in the sequence in whose domain it occurs,
provided that those domains are disjoint - otherwise the result is <code>( )</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_map-delete">map-delete</span></span>(_:<span class="name"><a href="#Name_maps">maps</a></span>(<span id="Variable1494_GT"><i class="var">GT</i></span>, <span id="Variable1500_T?"><i class="var">T<sup class="sup">?</sup></i></span>), _:<span class="name"><a href="../Sets/index.html#Name_sets">sets</a></span>(<span id="Variable1519_GT"><i class="var">GT</i></span>)) : =><span class="name"><a href="#Name_maps">maps</a></span>(<span id="Variable1541_GT"><i class="var">GT</i></span>, <span id="Variable1547_T?"><i class="var">T<sup class="sup">?</sup></i></span>)</code></pre></div>
<code><span class="name"><a href="#Name_map-delete">map-delete</a></span>(<i class="var">M</i>, <i class="var">S</i>)</code> takes a map <code><i class="var">M</i></code> and a set of values <code><i class="var">S</i></code>, and returns the
map obtained from <code><i class="var">M</i></code> by removing <code><i class="var">S</i></code> from its domain.
<div class="highlighter-rouge"><pre class="highlight"><code><i class="keyword">Assert</i>
<span class="name"><a href="#Name_map-domain">map-domain</a></span>(<span class="name"><a href="#Name_map-delete">map-delete</a></span>(<i class="var">M</i>, <i class="var">S</i>)) == <span class="name"><a href="../Sets/index.html#Name_set-difference">set-difference</a></span>(<span class="name"><a href="#Name_map-domain">map-domain</a></span>(<i class="var">M</i>), <i class="var">S</i>)</code></pre></div>
____
From the [PLanCompS Project] | [CBS-beta issues...] | [Suggest an improvement...]
[Maps.cbs]: Maps.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/Maps/Maps.cbs%0A%0AComment/Query/Issue/Suggestion%3A%0A%0A%0ASignature%3A%0A
"GENERATE AN EMAIL TEMPLATE"

29
IBAF-cbs/Funcons-beta/Values/Composite/Maps/tests/map-delete.config Normal file
View File

@@ -0,0 +1,29 @@
general {
funcon-term:
initialise-giving finalise-failing
sequential (
print map-delete({1 |-> 2},{}),
print map-delete({1 |-> 2, 3 |-> 4},{}),
print map-delete(map(),{1}),
print map-delete({1 |-> 2},{1}),
print map-delete({1 |-> 2, 3 |-> 4},{1}),
print map-delete({1 |-> 2, 3 |-> 4},{3}),
print map-delete({1 |-> 2, 3 |-> 4},{1,3}),
print "OK"
)
;
}
tests {
result-term: null-value;
standard-out: [
{1 |-> 2},
{1 |-> 2, 3 |-> 4},
map(),
map(),
{3 |-> 4},
{1 |-> 2},
map(),
"OK"
];
}

16
IBAF-cbs/Funcons-beta/Values/Composite/Maps/tests/map-domain.config Normal file
View File

@@ -0,0 +1,16 @@
general {
funcon-term:
initialise-giving finalise-failing
sequential (
print map-domain map(),
print map-domain{1|->2},
print map-domain{1|->2,3|->4},
print map-domain{1|->2,3|->( )}
)
;
}
tests {
result-term: null;
standard-out: [{}, {1}, {1,3}, {1,3}];
}

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

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

22
IBAF-cbs/Funcons-beta/Values/Composite/Maps/tests/map-lookup.config Normal file
View File

@@ -0,0 +1,22 @@
general {
funcon-term:
initialise-giving finalise-failing
sequential (
print map-lookup({1|->2}, 1),
print map-lookup({1|->2,3|->4}, 1),
print map-lookup({1|->2,3|->4}, 3),
else(
effect checked map-lookup(map(), 1),
effect checked map-lookup({1|->2}, 2),
effect checked map-lookup({1|->2,3|->4}, 2),
effect checked map-lookup({1|->2,3|->4}, 5),
print "OK"
)
)
;
}
tests {
result-term: null-value;
standard-out: [2, 2, 4, "OK"];
}

31
IBAF-cbs/Funcons-beta/Values/Composite/Maps/tests/map-override.config Normal file
View File

@@ -0,0 +1,31 @@
general {
funcon-term:
initialise-giving finalise-failing
sequential (
print map-override({1 |-> 2},map()),
print map-override(map(),{1 |-> 2}),
print map-override({1 |-> 2},{1 |-> 2}),
print map-override({1 |-> 2},{3 |-> 4}),
print map-override({1 |-> 2},{1 |-> 4}),
print map-override({1 |-> 2},{1 |-> 4},{1 |-> 2}),
print map-override({1 |-> 2}),
print map-override(map()),
print map-override()
)
;
}
tests {
result-term: null-value;
standard-out: [
{1 |-> 2},
{1 |-> 2},
{1 |-> 2},
{1 |-> 2, 3 |-> 4},
{1 |-> 2},
{1 |-> 2},
{1 |-> 2},
map(),
map()
];
}

31
IBAF-cbs/Funcons-beta/Values/Composite/Maps/tests/map-unite.config Normal file
View File

@@ -0,0 +1,31 @@
general {
funcon-term:
initialise-giving finalise-failing
sequential (
print map-unite({1 |-> 2},map()),
print map-unite(map(),{1 |-> 2}),
print map-unite({1 |-> 2},{3 |-> 4}),
print map-unite({1 |-> 2}),
print map-unite(map()),
print map-unite(),
else(
effect checked map-unite({1 |-> 2},{1 |-> 4}),
effect checked map-unite({1 |-> 2, 3 |-> 4},{5 |-> 6, 1 |-> 7}),
print "OK"
)
)
;
}
tests {
result-term: null-value;
standard-out: [
{1 |-> 2},
{1 |-> 2},
{1 |-> 2, 3 |-> 4},
{1 |-> 2},
map(),
map(),
"OK"
];
}

23
IBAF-cbs/Funcons-beta/Values/Composite/Maps/tests/map.config Normal file
View File

@@ -0,0 +1,23 @@
general {
funcon-term:
initialise-giving finalise-failing
sequential (
print map(),
print {1 |-> 2},
print {1 |-> 2, 3 |-> 4},
print {1 |-> 2, 3 |-> ()},
print cast({1 |-> 2}, maps(integers,integers))
)
;
}
tests {
result-term: null-value;
standard-out: [
map(),
{1 |-> 2},
{1 |-> 2, 3 |-> 4},
{1 |-> 2, 3 |-> ()},
{1 |-> 2}
];
}

77
IBAF-cbs/Funcons-beta/Values/Composite/Multisets/Multisets.cbs Normal file
View File

@@ -0,0 +1,77 @@
### Multisets (bags)
[
Type multisets
Funcon multiset
Funcon multiset-elements
Funcon multiset-occurrences
Funcon multiset-insert
Funcon multiset-delete
Funcon is-submultiset
]
Meta-variables
GT <: ground-values
Built-in Type
multisets(GT)
/*
`multisets(GT)` is the type of possibly-empty finite multisets of elements
of `GT`.
*/
Built-in Funcon
multiset(_:(GT)*) : =>multisets(GT)
/*
Note that `multiset(...)` is not a constructor operation. The order of
argument values is ignored, but duplicates are significant, e.g.,
`multiset(1, 2, 2)` is equivalent to `multiset(2, 1, 2)`, but not to
`multiset(1, 2)` or `multiset(2, 1)`.
*/
Built-in Funcon
multiset-elements(_:multisets(GT)) : =>(GT)*
/*
For each multiset `MS`, the sequence of values `V*` returned by
`multiset-elements(MS)` contains each element of `MS` the same number of times
as `MS` does.
The order of the values in `V*` is unspecified, and may vary between multisets.
*/
Assert
multiset(multiset-elements(S)) == S
Built-in Funcon
multiset-occurrences(_:GT, _:multisets(GT)) : =>natural-numbers
/*
`multiset-occurrences(GV, MS)` returns the number of occurrences of `GV`
in `MS`.
*/
Built-in Funcon
multiset-insert(_:GT, _:natural-numbers, _:multisets(GT)) : =>multisets(GT)
/*
`multiset-insert(GV, N, MS)` returns the multiset that differs from `MS`
by containing `N` more copies of `GV`.
*/
Built-in Funcon
multiset-delete(_:multisets(GT), _:GT, _:natural-numbers) : =>multisets(GT)
/*
`multiset-delete(MS, GV, N)` removes `N` copies of `V` from the multiset `MS`,
or all copies of `GV` if there are fewer than `N` in `MS`.
*/
Built-in Funcon
is-submultiset(_:multisets(GT), _:multisets(GT)) : =>booleans
/*
`is-submultiset(MS1, MS2)` tests whether every element of `MS1` has equal or
fewer occurrences in `MS1` than in `MS2`.
*/

114
IBAF-cbs/Funcons-beta/Values/Composite/Multisets/index.md Normal file
View File

@@ -0,0 +1,114 @@
---
layout: default
title: "Multisets"
parent: Composite
ancestor: Funcons-beta
---
[Funcons-beta] : [Multisets.cbs]
-----------------------------
### Multisets (bags)
<div class="highlighter-rouge"><pre class="highlight"><code>[
<i class="keyword">Type</i> <span class="name"><a href="#Name_multisets">multisets</a></span>
<i class="keyword">Funcon</i> <span class="name"><a href="#Name_multiset">multiset</a></span>
<i class="keyword">Funcon</i> <span class="name"><a href="#Name_multiset-elements">multiset-elements</a></span>
<i class="keyword">Funcon</i> <span class="name"><a href="#Name_multiset-occurrences">multiset-occurrences</a></span>
<i class="keyword">Funcon</i> <span class="name"><a href="#Name_multiset-insert">multiset-insert</a></span>
<i class="keyword">Funcon</i> <span class="name"><a href="#Name_multiset-delete">multiset-delete</a></span>
<i class="keyword">Funcon</i> <span class="name"><a href="#Name_is-submultiset">is-submultiset</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_multisets">multisets</span></span>(<span id="Variable56_GT"><i class="var">GT</i></span>)</code></pre></div>
<code><span class="name"><a href="#Name_multisets">multisets</a></span>(<i class="var">GT</i>)</code> is the type of possibly-empty finite multisets of elements
of <code><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_multiset">multiset</span></span>(_:(<span id="Variable115_GT"><i class="var">GT</i></span>)<sup class="sup">*</sup>) : =><span class="name"><a href="#Name_multisets">multisets</a></span>(<span id="Variable137_GT"><i class="var">GT</i></span>)</code></pre></div>
Note that <code><span class="name"><a href="#Name_multiset">multiset</a></span>(...)</code> is not a constructor operation. The order of
argument values is ignored, but duplicates are significant, e.g.,
<code><span class="name"><a href="#Name_multiset">multiset</a></span>(1, 2, 2)</code> is equivalent to <code><span class="name"><a href="#Name_multiset">multiset</a></span>(2, 1, 2)</code>, but not to
<code><span class="name"><a href="#Name_multiset">multiset</a></span>(1, 2)</code> or <code><span class="name"><a href="#Name_multiset">multiset</a></span>(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_multiset-elements">multiset-elements</span></span>(_:<span class="name"><a href="#Name_multisets">multisets</a></span>(<span id="Variable267_GT"><i class="var">GT</i></span>)) : =>(<span id="Variable287_GT"><i class="var">GT</i></span>)<sup class="sup">*</sup></code></pre></div>
For each multiset <code><i class="var">MS</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_multiset-elements">multiset-elements</a></span>(<i class="var">MS</i>)</code> contains each element of <code><i class="var">MS</i></code> the same number of times
as <code><i class="var">MS</i></code> does.
The order of the values in <code><i class="var">V<sup class="sup">*</sup></i></code> is unspecified, and may vary between multisets.
<div class="highlighter-rouge"><pre class="highlight"><code><i class="keyword">Assert</i>
<span class="name"><a href="#Name_multiset">multiset</a></span>(<span class="name"><a href="#Name_multiset-elements">multiset-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_multiset-occurrences">multiset-occurrences</span></span>(_:<span id="Variable426_GT"><i class="var">GT</i></span>, _:<span class="name"><a href="#Name_multisets">multisets</a></span>(<span id="Variable438_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>
<code><span class="name"><a href="#Name_multiset-occurrences">multiset-occurrences</a></span>(<i class="var">GV</i>, <i class="var">MS</i>)</code> returns the number of occurrences of <code><i class="var">GV</i></code>
in <code><i class="var">MS</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_multiset-insert">multiset-insert</span></span>(_:<span id="Variable527_GT"><i class="var">GT</i></span>, _:<span class="name"><a href="../../Primitive/Integers/index.html#Name_natural-numbers">natural-numbers</a></span>, _:<span class="name"><a href="#Name_multisets">multisets</a></span>(<span id="Variable547_GT"><i class="var">GT</i></span>)) : =><span class="name"><a href="#Name_multisets">multisets</a></span>(<span id="Variable570_GT"><i class="var">GT</i></span>)</code></pre></div>
<code><span class="name"><a href="#Name_multiset-insert">multiset-insert</a></span>(<i class="var">GV</i>, <i class="var">N</i>, <i class="var">MS</i>)</code> returns the multiset that differs from <code><i class="var">MS</i></code>
by containing <code><i class="var">N</i></code> more copies of <code><i class="var">GV</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_multiset-delete">multiset-delete</span></span>(_:<span class="name"><a href="#Name_multisets">multisets</a></span>(<span id="Variable667_GT"><i class="var">GT</i></span>), _:<span id="Variable684_GT"><i class="var">GT</i></span>, _:<span class="name"><a href="../../Primitive/Integers/index.html#Name_natural-numbers">natural-numbers</a></span>) : =><span class="name"><a href="#Name_multisets">multisets</a></span>(<span id="Variable709_GT"><i class="var">GT</i></span>)</code></pre></div>
<code><span class="name"><a href="#Name_multiset-delete">multiset-delete</a></span>(<i class="var">MS</i>, <i class="var">GV</i>, <i class="var">N</i>)</code> removes <code><i class="var">N</i></code> copies of <code><i class="var">V</i></code> from the multiset <code><i class="var">MS</i></code>,
or all copies of <code><i class="var">GV</i></code> if there are fewer than <code><i class="var">N</i></code> in <code><i class="var">MS</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_is-submultiset">is-submultiset</span></span>(_:<span class="name"><a href="#Name_multisets">multisets</a></span>(<span id="Variable845_GT"><i class="var">GT</i></span>), _:<span class="name"><a href="#Name_multisets">multisets</a></span>(<span id="Variable863_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-submultiset">is-submultiset</a></span>(<i class="var">MS<sub class="sub">1</sub></i>, <i class="var">MS<sub class="sub">2</sub></i>)</code> tests whether every element of <code><i class="var">MS<sub class="sub">1</sub></i></code> has equal or
fewer occurrences in <code><i class="var">MS<sub class="sub">1</sub></i></code> than in <code><i class="var">MS<sub class="sub">2</sub></i></code>.
____
From the [PLanCompS Project] | [CBS-beta issues...] | [Suggest an improvement...]
[Multisets.cbs]: Multisets.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/Multisets/Multisets.cbs%0A%0AComment/Query/Issue/Suggestion%3A%0A%0A%0ASignature%3A%0A
"GENERATE AN EMAIL TEMPLATE"

81
IBAF-cbs/Funcons-beta/Values/Composite/Objects/Objects.cbs Normal file
View File

@@ -0,0 +1,81 @@
### Objects
[
Datatype objects
Funcon object
Funcon object-identity
Funcon object-class-name
Funcon object-feature-map
Funcon object-subobject-sequence
Funcon object-tree
Funcon object-single-inheritance-feature-map
]
Datatype
objects ::= object(_:atoms, _:identifiers, _:environments, _:objects*)
/*
`object( A, C, Env, O*)` is an object:
* distinguished by an atom `A`,
* of a class named `C`,
* with an environment `Env` with the features of the object, and
* a sequence `O*` of subobjects of the direct superclasses of `C`.
`object( A, C, Env)` is an object of a base class.
`object( A, C, Env, O')` is an object of a class with a single superclass.
With multiple inheritance, subobjects due to repeated inheritance of the
same class may be shared.
Implementations of objects generally represent an object as a vector of
fields, and use pointers and offsets for efficient access to individual
fields. The representation of objects used in this specification is
independent of such implementation concerns.
*/
Funcon
object-identity(_:objects) : =>atoms
Rule
object-identity
object(A:atoms, _:identifiers, _:environments, _*:objects*) ~> A
Funcon
object-class-name(_:objects) : =>identifiers
Rule
object-class-name
object(_:atoms, C:identifiers, _:environments, _*:objects*) ~> C
Funcon
object-feature-map(_:objects) : =>environments
Rule
object-feature-map
object(_:atoms, _:identifiers, Env:environments, _*:objects*) ~> Env
Funcon
object-subobject-sequence(_:objects) : =>objects*
Rule
object-subobject-sequence
object(_:atoms, _:identifiers, _:environments, O*:objects*) ~> O*
Funcon
object-tree(_:objects) : =>trees(objects)
/*
`object-tree O` forms a tree where the branches are the object trees for
the direct subobjects of `O`.
*/
Rule
object-tree(O:objects)
~> tree(O,
interleave-map (
object-tree given,
object-subobject-sequence O))
Funcon
object-single-inheritance-feature-map(O:objects) : =>environments
~> map-override left-to-right-map(
object-feature-map given,
single-branching-sequence object-tree O)
/*
For multiple inheritance, different resolution orders can be specified
by using difference linearisations of the object tree.
*/

119
IBAF-cbs/Funcons-beta/Values/Composite/Objects/index.md Normal file
View File

@@ -0,0 +1,119 @@
---
layout: default
title: "Objects"
parent: Composite
ancestor: Funcons-beta
---
[Funcons-beta] : [Objects.cbs]
-----------------------------
### Objects
<div class="highlighter-rouge"><pre class="highlight"><code>[
<i class="keyword">Datatype</i> <span class="name"><a href="#Name_objects">objects</a></span>
<i class="keyword">Funcon</i> <span class="name"><a href="#Name_object">object</a></span>
<i class="keyword">Funcon</i> <span class="name"><a href="#Name_object-identity">object-identity</a></span>
<i class="keyword">Funcon</i> <span class="name"><a href="#Name_object-class-name">object-class-name</a></span>
<i class="keyword">Funcon</i> <span class="name"><a href="#Name_object-feature-map">object-feature-map</a></span>
<i class="keyword">Funcon</i> <span class="name"><a href="#Name_object-subobject-sequence">object-subobject-sequence</a></span>
<i class="keyword">Funcon</i> <span class="name"><a href="#Name_object-tree">object-tree</a></span>
<i class="keyword">Funcon</i> <span class="name"><a href="#Name_object-single-inheritance-feature-map">object-single-inheritance-feature-map</a></span>
]</code></pre></div>
<div class="highlighter-rouge"><pre class="highlight"><code><i class="keyword">Datatype</i>
<span class="name"><span id="Name_objects">objects</span></span> ::= <span id="Name_object">object</span>(_:<span class="name"><a href="../../../Computations/Normal/Generating/index.html#Name_atoms">atoms</a></span>, _:<span class="name"><a href="../../../Computations/Normal/Binding/index.html#Name_identifiers">identifiers</a></span>, _:<span class="name"><a href="../../../Computations/Normal/Binding/index.html#Name_environments">environments</a></span>, _:<span class="name"><a href="#Name_objects">objects</a></span><sup class="sup">*</sup>)</code></pre></div>
<code><span class="name"><a href="#Name_object">object</a></span>( <i class="var">A</i>, <i class="var">C</i>, <i class="var">Env</i>, <i class="var">O<sup class="sup">*</sup></i>)</code> is an object:
* distinguished by an atom <code><i class="var">A</i></code>,
* of a class named <code><i class="var">C</i></code>,
* with an environment <code><i class="var">Env</i></code> with the features of the object, and
* a sequence <code><i class="var">O<sup class="sup">*</sup></i></code> of subobjects of the direct superclasses of <code><i class="var">C</i></code>.
<code><span class="name"><a href="#Name_object">object</a></span>( <i class="var">A</i>, <i class="var">C</i>, <i class="var">Env</i>)</code> is an object of a base class.
<code><span class="name"><a href="#Name_object">object</a></span>( <i class="var">A</i>, <i class="var">C</i>, <i class="var">Env</i>, <i class="var">O&prime;</i>)</code> is an object of a class with a single superclass.
With multiple inheritance, subobjects due to repeated inheritance of the
same class may be shared.
Implementations of objects generally represent an object as a vector of
fields, and use pointers and offsets for efficient access to individual
fields. The representation of objects used in this specification is
independent of such implementation concerns.
<div class="highlighter-rouge"><pre class="highlight"><code><i class="keyword">Funcon</i>
<span class="name"><span id="Name_object-identity">object-identity</span></span>(_:<span class="name"><a href="#Name_objects">objects</a></span>) : =><span class="name"><a href="../../../Computations/Normal/Generating/index.html#Name_atoms">atoms</a></span>
<i class="keyword">Rule</i>
<span class="name"><a href="#Name_object-identity">object-identity</a></span>
<span class="name"><a href="#Name_object">object</a></span>(<span id="Variable326_A"><i class="var">A</i></span>:<span class="name"><a href="../../../Computations/Normal/Generating/index.html#Name_atoms">atoms</a></span>, _:<span class="name"><a href="../../../Computations/Normal/Binding/index.html#Name_identifiers">identifiers</a></span>, _:<span class="name"><a href="../../../Computations/Normal/Binding/index.html#Name_environments">environments</a></span>, _*:<span class="name"><a href="#Name_objects">objects</a></span><sup class="sup">*</sup>) ~> <a href="#Variable326_A"><i class="var">A</i></a></code></pre></div>
<div class="highlighter-rouge"><pre class="highlight"><code><i class="keyword">Funcon</i>
<span class="name"><span id="Name_object-class-name">object-class-name</span></span>(_:<span class="name"><a href="#Name_objects">objects</a></span>) : =><span class="name"><a href="../../../Computations/Normal/Binding/index.html#Name_identifiers">identifiers</a></span>
<i class="keyword">Rule</i>
<span class="name"><a href="#Name_object-class-name">object-class-name</a></span>
<span class="name"><a href="#Name_object">object</a></span>(_:<span class="name"><a href="../../../Computations/Normal/Generating/index.html#Name_atoms">atoms</a></span>, <span id="Variable405_C"><i class="var">C</i></span>:<span class="name"><a href="../../../Computations/Normal/Binding/index.html#Name_identifiers">identifiers</a></span>, _:<span class="name"><a href="../../../Computations/Normal/Binding/index.html#Name_environments">environments</a></span>, _*:<span class="name"><a href="#Name_objects">objects</a></span><sup class="sup">*</sup>) ~> <a href="#Variable405_C"><i class="var">C</i></a></code></pre></div>
<div class="highlighter-rouge"><pre class="highlight"><code><i class="keyword">Funcon</i>
<span class="name"><span id="Name_object-feature-map">object-feature-map</span></span>(_:<span class="name"><a href="#Name_objects">objects</a></span>) : =><span class="name"><a href="../../../Computations/Normal/Binding/index.html#Name_environments">environments</a></span>
<i class="keyword">Rule</i>
<span class="name"><a href="#Name_object-feature-map">object-feature-map</a></span>
<span class="name"><a href="#Name_object">object</a></span>(_:<span class="name"><a href="../../../Computations/Normal/Generating/index.html#Name_atoms">atoms</a></span>, _:<span class="name"><a href="../../../Computations/Normal/Binding/index.html#Name_identifiers">identifiers</a></span>, <span id="Variable484_Env"><i class="var">Env</i></span>:<span class="name"><a href="../../../Computations/Normal/Binding/index.html#Name_environments">environments</a></span>, _*:<span class="name"><a href="#Name_objects">objects</a></span><sup class="sup">*</sup>) ~> <a href="#Variable484_Env"><i class="var">Env</i></a></code></pre></div>
<div class="highlighter-rouge"><pre class="highlight"><code><i class="keyword">Funcon</i>
<span class="name"><span id="Name_object-subobject-sequence">object-subobject-sequence</span></span>(_:<span class="name"><a href="#Name_objects">objects</a></span>) : =><span class="name"><a href="#Name_objects">objects</a></span><sup class="sup">*</sup>
<i class="keyword">Rule</i>
<span class="name"><a href="#Name_object-subobject-sequence">object-subobject-sequence</a></span>
<span class="name"><a href="#Name_object">object</a></span>(_:<span class="name"><a href="../../../Computations/Normal/Generating/index.html#Name_atoms">atoms</a></span>, _:<span class="name"><a href="../../../Computations/Normal/Binding/index.html#Name_identifiers">identifiers</a></span>, _:<span class="name"><a href="../../../Computations/Normal/Binding/index.html#Name_environments">environments</a></span>, <span id="Variable566_O*"><i class="var">O<sup class="sup">*</sup></i></span>:<span class="name"><a href="#Name_objects">objects</a></span><sup class="sup">*</sup>) ~> <a href="#Variable566_O*"><i class="var">O<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_object-tree">object-tree</span></span>(_:<span class="name"><a href="#Name_objects">objects</a></span>) : =><span class="name"><a href="../Trees/index.html#Name_trees">trees</a></span>(<span class="name"><a href="#Name_objects">objects</a></span>)</code></pre></div>
<code><span class="name"><a href="#Name_object-tree">object-tree</a></span> <i class="var">O</i></code> forms a tree where the branches are the object trees for
the direct subobjects of <code><i class="var">O</i></code>.
<div class="highlighter-rouge"><pre class="highlight"><code><i class="keyword">Rule</i>
<span class="name"><a href="#Name_object-tree">object-tree</a></span>(<span id="Variable657_O"><i class="var">O</i></span>:<span class="name"><a href="#Name_objects">objects</a></span>)
~> <span class="name"><a href="../Trees/index.html#Name_tree">tree</a></span>(<a href="#Variable657_O"><i class="var">O</i></a>,
<span class="name"><a href="../../../Computations/Normal/Giving/index.html#Name_interleave-map">interleave-map</a></span> (
<span class="name"><a href="#Name_object-tree">object-tree</a></span> <span class="name"><a href="../../../Computations/Normal/Giving/index.html#Name_given">given</a></span>,
<span class="name"><a href="#Name_object-subobject-sequence">object-subobject-sequence</a></span> <a href="#Variable657_O"><i class="var">O</i></a>))</code></pre></div>
<div class="highlighter-rouge"><pre class="highlight"><code><i class="keyword">Funcon</i>
<span class="name"><span id="Name_object-single-inheritance-feature-map">object-single-inheritance-feature-map</span></span>(<span id="Variable707_O"><i class="var">O</i></span>:<span class="name"><a href="#Name_objects">objects</a></span>) : =><span class="name"><a href="../../../Computations/Normal/Binding/index.html#Name_environments">environments</a></span>
~> <span class="name"><a href="../Maps/index.html#Name_map-override">map-override</a></span> <span class="name"><a href="../../../Computations/Normal/Giving/index.html#Name_left-to-right-map">left-to-right-map</a></span>(
<span class="name"><a href="#Name_object-feature-map">object-feature-map</a></span> <span class="name"><a href="../../../Computations/Normal/Giving/index.html#Name_given">given</a></span>,
<span class="name"><a href="../Trees/index.html#Name_single-branching-sequence">single-branching-sequence</a></span> <span class="name"><a href="#Name_object-tree">object-tree</a></span> <a href="#Variable707_O"><i class="var">O</i></a>)</code></pre></div>
For multiple inheritance, different resolution orders can be specified
by using difference linearisations of the object tree.
____
From the [PLanCompS Project] | [CBS-beta issues...] | [Suggest an improvement...]
[Objects.cbs]: Objects.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/Objects/Objects.cbs%0A%0AComment/Query/Issue/Suggestion%3A%0A%0A%0ASignature%3A%0A
"GENERATE AN EMAIL TEMPLATE"

17
IBAF-cbs/Funcons-beta/Values/Composite/Objects/tests/object-feature-map.config Normal file
View File

@@ -0,0 +1,17 @@
general {
funcon-term:
initialise-giving initialise-generating finalise-failing
sequential (
print object-feature-map object(fresh-atom,"A",map()),
print object-feature-map object(fresh-atom,"B",map(),
object(fresh-atom,"C",map()))
)
;
}
tests {
result-term: null-value;
standard-out: [
map(), map()
];
}

17
IBAF-cbs/Funcons-beta/Values/Composite/Objects/tests/object-identity.config Normal file
View File

@@ -0,0 +1,17 @@
general {
funcon-term:
initialise-giving initialise-generating finalise-failing
sequential (
print object-identity object(fresh-atom,"A",map()),
print object-identity object(fresh-atom,"B",map(),
object(fresh-atom,"C",map()))
)
;
}
tests {
result-term: null-value;
standard-out: [
atom("@1"), atom("@2")
];
}

28
IBAF-cbs/Funcons-beta/Values/Composite/Objects/tests/object-single-inheritance-feature-map.config Normal file
View File

@@ -0,0 +1,28 @@
general {
funcon-term:
initialise-giving initialise-generating finalise-failing
sequential (
print object-single-inheritance-feature-map
object(fresh-atom,"A",{"a"|->"A"}),
print object-single-inheritance-feature-map
object(fresh-atom,"B",{"a"|->"B"},
object(fresh-atom,"C",{"a"|->"C"})),
else(
is-value object-single-inheritance-feature-map
object(fresh-atom,"D",map(),
object(fresh-atom,"E",map(),
object(fresh-atom,"F",map())),
object(fresh-atom,"G",map())),
print "OK")
)
;
}
tests {
result-term: null-value;
standard-out: [
{"a"|->"A"},
{"a"|->"B"},
"OK"
];
}

27
IBAF-cbs/Funcons-beta/Values/Composite/Objects/tests/object-subobject-sequence.config Normal file
View File

@@ -0,0 +1,27 @@
general {
funcon-term:
initialise-giving initialise-generating finalise-failing
sequential (
print [object-subobject-sequence
object(fresh-atom,"A",map())],
print [object-subobject-sequence
object(fresh-atom,"B",map(),
object(fresh-atom,"C",map()))],
print [object-subobject-sequence
object(fresh-atom,"D",map(),
object(fresh-atom,"E",map(),
object(fresh-atom,"F",map())),
object(fresh-atom,"G",map()))]
)
;
}
tests {
result-term: null-value;
standard-out: [
[],
[object(atom("@3"),"C",map-empty)],
[object(atom("@5"),"E",map-empty,object(atom("@6"),"F",map-empty)),
object(atom("@7"),"G",map-empty)]
];
}

32
IBAF-cbs/Funcons-beta/Values/Composite/Objects/tests/object-tree.config Normal file
View File

@@ -0,0 +1,32 @@
general {
funcon-term:
initialise-giving initialise-generating finalise-failing
sequential (
print object-tree
object(fresh-atom,"A",map()),
print object-tree
object(fresh-atom,"B",map(),
object(fresh-atom,"C",map())),
print object-tree
object(fresh-atom,"D",map(),
object(fresh-atom,"E",map(),
object(fresh-atom,"F",map())),
object(fresh-atom,"G",map()))
)
;
}
tests {
result-term: null-value;
standard-out: [
tree (object(atom("@1"),"A",map-empty)),
tree (object(atom("@2"),"B",map-empty,object(atom("@3"),"C",map-empty)),
tree (object(atom("@3"),"C",map-empty))),
tree (object(atom("@4"),"D",map-empty,
object(atom("@5"),"E",map-empty,object(atom("@6"),"F",map-empty)),
object(atom("@7"),"G",map-empty)),
tree (object(atom("@5"),"E",map-empty,object(atom("@6"),"F",map-empty)),
tree (object(atom("@6"),"F",map-empty))),
tree (object(atom("@7"),"G",map-empty)))
];
}

25
IBAF-cbs/Funcons-beta/Values/Composite/Objects/tests/object.config Normal file
View File

@@ -0,0 +1,25 @@
general {
funcon-term:
initialise-giving initialise-generating finalise-failing
sequential (
print object(fresh-atom,"A",map()),
print object(fresh-atom,"B",map(),
object(fresh-atom,"C",map())),
print object(fresh-atom,"D",map(),
object(fresh-atom,"E",map(),
object(fresh-atom,"F",map())),
object(fresh-atom,"G",map()))
)
;
}
tests {
result-term: null-value;
standard-out: [
object(atom("@1"),"A",map-empty),
object(atom("@2"),"B",map-empty,object(atom("@3"),"C",map-empty)),
object(atom("@4"),"D",map-empty,
object(atom("@5"),"E",map-empty,object(atom("@6"),"F",map-empty)),
object(atom("@7"),"G",map-empty))
];
}

32
IBAF-cbs/Funcons-beta/Values/Composite/Records/Records.cbs Normal file
View File

@@ -0,0 +1,32 @@
### Records
[
Datatype records
Funcon record
Funcon record-map
Funcon record-select
]
Meta-variables
T <: values
Datatype
records(T) ::= record(_:maps(identifiers,T))
/*
A value of type `records(T)` contains a map from identifiers to values of
type `T`.
*/
Funcon
record-map(_:records(T)) : =>maps(identifiers,T)
Rule
record-map(record(M:maps(_,_))) ~> M
Funcon
record-select(R:records(T), I:identifiers) : =>T?
~> map-lookup(record-map(R), I)

68
IBAF-cbs/Funcons-beta/Values/Composite/Records/index.md Normal file
View File

@@ -0,0 +1,68 @@
---
layout: default
title: "Records"
parent: Composite
ancestor: Funcons-beta
---
[Funcons-beta] : [Records.cbs]
-----------------------------
### Records
<div class="highlighter-rouge"><pre class="highlight"><code>[
<i class="keyword">Datatype</i> <span class="name"><a href="#Name_records">records</a></span>
<i class="keyword">Funcon</i> <span class="name"><a href="#Name_record">record</a></span>
<i class="keyword">Funcon</i> <span class="name"><a href="#Name_record-map">record-map</a></span>
<i class="keyword">Funcon</i> <span class="name"><a href="#Name_record-select">record-select</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="../../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_records">records</span></span>(<span id="Variable44_T"><i class="var">T</i></span>) ::= <span id="Name_record">record</span>(_:<span class="name"><a href="../Maps/index.html#Name_maps">maps</a></span>(<span class="name"><a href="../../../Computations/Normal/Binding/index.html#Name_identifiers">identifiers</a></span>,<span id="Variable63_T"><i class="var">T</i></span>))</code></pre></div>
A value of type <code><span class="name"><a href="#Name_records">records</a></span>(<i class="var">T</i>)</code> contains a map from identifiers to values of
type <code><i class="var">T</i></code>.
<div class="highlighter-rouge"><pre class="highlight"><code><i class="keyword">Funcon</i>
<span class="name"><span id="Name_record-map">record-map</span></span>(_:<span class="name"><a href="#Name_records">records</a></span>(<span id="Variable134_T"><i class="var">T</i></span>)) : =><span class="name"><a href="../Maps/index.html#Name_maps">maps</a></span>(<span class="name"><a href="../../../Computations/Normal/Binding/index.html#Name_identifiers">identifiers</a></span>,<span id="Variable157_T"><i class="var">T</i></span>)
<i class="keyword">Rule</i>
<span class="name"><a href="#Name_record-map">record-map</a></span>(<span class="name"><a href="#Name_record">record</a></span>(<span id="Variable174_M"><i class="var">M</i></span>:<span class="name"><a href="../Maps/index.html#Name_maps">maps</a></span>(_,_))) ~> <a href="#Variable174_M"><i class="var">M</i></a></code></pre></div>
<div class="highlighter-rouge"><pre class="highlight"><code><i class="keyword">Funcon</i>
<span class="name"><span id="Name_record-select">record-select</span></span>(<span id="Variable217_R"><i class="var">R</i></span>:<span class="name"><a href="#Name_records">records</a></span>(<span id="Variable222_T"><i class="var">T</i></span>), <span id="Variable236_I"><i class="var">I</i></span>:<span class="name"><a href="../../../Computations/Normal/Binding/index.html#Name_identifiers">identifiers</a></span>) : =><span id="Variable253_T?"><i class="var">T<sup class="sup">?</sup></i></span>
~> <span class="name"><a href="../Maps/index.html#Name_map-lookup">map-lookup</a></span>(<span class="name"><a href="#Name_record-map">record-map</a></span>(<a href="#Variable217_R"><i class="var">R</i></a>), <a href="#Variable236_I"><i class="var">I</i></a>)</code></pre></div>
____
From the [PLanCompS Project] | [CBS-beta issues...] | [Suggest an improvement...]
[Records.cbs]: Records.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/Records/Records.cbs%0A%0AComment/Query/Issue/Suggestion%3A%0A%0A%0ASignature%3A%0A
"GENERATE AN EMAIL TEMPLATE"

29
IBAF-cbs/Funcons-beta/Values/Composite/References/References.cbs Normal file
View File

@@ -0,0 +1,29 @@
### References and pointers
[
Datatype references
Funcon reference
Type pointers
Funcon pointer-null
Funcon dereference
]
Meta-variables
T <: values
Datatype
references(T) ::= reference(_:T)
Datatype
pointers(T) ::= pointer-null | { _:references(T) }
Funcon
dereference(_:pointers(T)) : =>(T)?
Rule
dereference(reference(V:T)) ~> V
Rule
dereference(pointer-null) ~> ( )

66
IBAF-cbs/Funcons-beta/Values/Composite/References/index.md Normal file
View File

@@ -0,0 +1,66 @@
---
layout: default
title: "References"
parent: Composite
ancestor: Funcons-beta
---
[Funcons-beta] : [References.cbs]
-----------------------------
### References and pointers
<div class="highlighter-rouge"><pre class="highlight"><code>[
<i class="keyword">Datatype</i> <span class="name"><a href="#Name_references">references</a></span>
<i class="keyword">Funcon</i> <span class="name"><a href="#Name_reference">reference</a></span>
<i class="keyword">Type</i> <span class="name"><a href="#Name_pointers">pointers</a></span>
<i class="keyword">Funcon</i> <span class="name"><a href="#Name_pointer-null">pointer-null</a></span>
<i class="keyword">Funcon</i> <span class="name"><a href="#Name_dereference">dereference</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="../../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_references">references</span></span>(<span id="Variable48_T"><i class="var">T</i></span>) ::= <span id="Name_reference">reference</span>(_:<span id="Variable64_T"><i class="var">T</i></span>)</code></pre></div>
<div class="highlighter-rouge"><pre class="highlight"><code><i class="keyword">Datatype</i>
<span class="name"><span id="Name_pointers">pointers</span></span>(<span id="Variable86_T"><i class="var">T</i></span>) ::= <span id="Name_pointer-null">pointer-null</span> | { _:<span class="name"><a href="#Name_references">references</a></span>(<a href="#Variable86_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_dereference">dereference</span></span>(_:<span class="name"><a href="#Name_pointers">pointers</a></span>(<span id="Variable129_T"><i class="var">T</i></span>)) : =>(<span id="Variable149_T"><i class="var">T</i></span>)<sup class="sup">?</sup>
<i class="keyword">Rule</i>
<span class="name"><a href="#Name_dereference">dereference</a></span>(<span class="name"><a href="#Name_reference">reference</a></span>(<span id="Variable166_V"><i class="var">V</i></span>:<i class="var">T</i>)) ~> <a href="#Variable166_V"><i class="var">V</i></a>
<i class="keyword">Rule</i>
<span class="name"><a href="#Name_dereference">dereference</a></span>(<span class="name"><a href="#Name_pointer-null">pointer-null</a></span>) ~> ( )</code></pre></div>
____
From the [PLanCompS Project] | [CBS-beta issues...] | [Suggest an improvement...]
[References.cbs]: References.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/References/References.cbs%0A%0AComment/Query/Issue/Suggestion%3A%0A%0A%0ASignature%3A%0A
"GENERATE AN EMAIL TEMPLATE"

157
IBAF-cbs/Funcons-beta/Values/Composite/Sequences/Sequences.cbs Normal file
View File

@@ -0,0 +1,157 @@
### Sequences of values
[
Funcon length
Funcon index
Funcon is-in
Funcon first
Funcon second
Funcon third
Funcon first-n
Funcon drop-first-n
Funcon reverse
Funcon n-of
Funcon intersperse
]
/*
Sequences of two or more values are not themselves values, nor is the empty
sequence a value. However, sequences can be provided to funcons as arguments,
and returned as results. Many operations on composite values can be expressed
by extracting their components as sequences, operating on the sequences, then
forming the required composite values from the resulting sequences.
A sequence with elements `X1`, ..., `Xn` is written `X1,...,Xn`.
A sequence with a single element `X` is identified with (and written) `X`.
An empty sequence is indicated by the absence of a term.
Any sequence `X*` can be enclosed in parentheses `(X*)`, e.g.:
`( )`, `(1)`, `(1,2,3)`. Superfluous commas are ignored.
The elements of a type sequence `T1,...,Tn` are the value sequences `V1,...,Vn`
where `V1:T1`, ..., `Vn:Tn`. The only element of the empty type sequence `( )`
is the empty value sequence `( )`.
`(T)^N` is equivalent to `T,...,T` with `N` occurrences of `T`.
`(T)*` is equivalent to the union of all `(T)^N` for `N`>=0,
`(T)+` is equivalent to the union of all `(T)^N` for `N`>=1, and
`(T)?` is equivalent to `T | ( )`.
The parentheses around `T` above can be omitted when they are not needed for
disambiguation.
(Non-trivial) sequence types are not values, so not included in `types`.
*/
Meta-variables
T, T' <: values
Funcon
length(_:values*) : =>natural-numbers
/*
`length(V*)` gives the number of elements in `V*`.
*/
Rule
length( ) ~> 0
Rule
length(V:values, V*:values*) ~> natural-successor(length(V*))
Funcon
is-in(_:values, _:values*) : =>booleans
Rule
is-in(V:values ,V':values, V*:values*) ~> or(is-equal(V, V'), is-in(V, V*))
Rule
is-in(V:values, ( )) ~> false
#### Sequence indexing
Funcon
index(_:natural-numbers, _:values*) : =>values?
/*
`index(N, V*)` gives the `N`th element of `V*`, if it exists, otherwise `( )`.
*/
Rule
index(1, V:values, V*:values*) ~> V
Rule
natural-predecessor(N) ~> N'
-----------------------------------------------------------------
index(N:positive-integers, _:values, V*:values*) ~> index(N', V*)
Rule
index(0, V*:values*) ~> ( )
Rule
index(_:positive-integers, ( )) ~> ( )
/* Total indexing funcons: */
Funcon
first(_:T, _:values*) : =>T
Rule
first(V:T, V*:values*) ~> V
Funcon
second(_:values, _:T, _:values*) : =>T
Rule
second(_:values, V:T, V*:values*) ~> V
Funcon
third(_:values, _:values, _:T, _:values*) : =>T
Rule
third(_:values, _:values, V:T, V*:values*) ~> V
#### Homogeneous sequences
Funcon
first-n(_:natural-numbers, _:(T)*) : =>(T)*
Rule
first-n(0, V*:(T)*) ~> ( )
Rule
natural-predecessor(N) ~> N'
-----------------------------------------------------------------
first-n(N:positive-integers, V:T, V*:(T)*) ~> (V,first-n(N', V*))
Rule
first-n(N:positive-integers, ( )) ~> ( )
Funcon
drop-first-n(_:natural-numbers, _:(T)*) : =>(T)*
Rule
drop-first-n(0, V*:(T)*) ~> V*
Rule
natural-predecessor(N) ~> N'
-----------------------------------------------------------------------
drop-first-n(N:positive-integers, _:T, V*:(T)*) ~> drop-first-n(N', V*)
Rule
drop-first-n(N:positive-integers, ( )) ~> ( )
Funcon
reverse(_:(T)*) : =>(T)*
Rule
reverse( ) ~> ( )
Rule
reverse(V:T, V*:(T)*) ~> (reverse(V*), V)
Funcon
n-of(N:natural-numbers, V:T) : =>(T)*
Rule
n-of(0, _:T) ~> ( )
Rule
natural-predecessor(N) ~> N'
--------------------------------------------------
n-of(N:positive-integers, V:T) ~> (V, n-of(N', V))
Funcon
intersperse(_:T', _:(T)*) : =>(T, (T', T)*)?
Rule
intersperse(_:T', ( )) ~> ( )
Rule
intersperse(_:T', V) ~> V
Rule
intersperse(V':T', V1:T, V2:T, V*:(T)*) ~> (V1, V', intersperse(V', V2, V*))

192
IBAF-cbs/Funcons-beta/Values/Composite/Sequences/index.md Normal file
View File

@@ -0,0 +1,192 @@
---
layout: default
title: "Sequences"
parent: Composite
ancestor: Funcons-beta
---
[Funcons-beta] : [Sequences.cbs]
-----------------------------
### Sequences of values
<div class="highlighter-rouge"><pre class="highlight"><code>[
<i class="keyword">Funcon</i> <span class="name"><a href="#Name_length">length</a></span>
<i class="keyword">Funcon</i> <span class="name"><a href="#Name_index">index</a></span>
<i class="keyword">Funcon</i> <span class="name"><a href="#Name_is-in">is-in</a></span>
<i class="keyword">Funcon</i> <span class="name"><a href="#Name_first">first</a></span>
<i class="keyword">Funcon</i> <span class="name"><a href="#Name_second">second</a></span>
<i class="keyword">Funcon</i> <span class="name"><a href="#Name_third">third</a></span>
<i class="keyword">Funcon</i> <span class="name"><a href="#Name_first-n">first-n</a></span>
<i class="keyword">Funcon</i> <span class="name"><a href="#Name_drop-first-n">drop-first-n</a></span>
<i class="keyword">Funcon</i> <span class="name"><a href="#Name_reverse">reverse</a></span>
<i class="keyword">Funcon</i> <span class="name"><a href="#Name_n-of">n-of</a></span>
<i class="keyword">Funcon</i> <span class="name"><a href="#Name_intersperse">intersperse</a></span>
]</code></pre></div>
Sequences of two or more values are not themselves values, nor is the empty
sequence a value. However, sequences can be provided to funcons as arguments,
and returned as results. Many operations on composite values can be expressed
by extracting their components as sequences, operating on the sequences, then
forming the required composite values from the resulting sequences.
A sequence with elements <code><i class="var">X<sub class="sub">1</sub></i></code>, ..., <code><i class="var">Xn</i></code> is written <code><i class="var">X<sub class="sub">1</sub></i>,...,<i class="var">Xn</i></code>.
A sequence with a single element <code><i class="var">X</i></code> is identified with (and written) <code><i class="var">X</i></code>.
An empty sequence is indicated by the absence of a term.
Any sequence <code><i class="var">X<sup class="sup">*</sup></i></code> can be enclosed in parentheses <code>(<i class="var">X<sup class="sup">*</sup></i>)</code>, e.g.:
<code>( )</code>, <code>(1)</code>, <code>(1,2,3)</code>. Superfluous commas are ignored.
The elements of a type sequence <code><i class="var">T<sub class="sub">1</sub></i>,...,<i class="var">Tn</i></code> are the value sequences <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">T<sub class="sub">1</sub></i></code>, ..., <code><i class="var">Vn</i>:<i class="var">Tn</i></code>. The only element of the empty type sequence <code>( )</code>
is the empty value sequence <code>( )</code>.
<code>(<i class="var">T</i>)^<i class="var">N</i></code> is equivalent to <code><i class="var">T</i>,...,<i class="var">T</i></code> with <code><i class="var">N</i></code> occurrences of <code><i class="var">T</i></code>.
<code>(<i class="var">T</i>)<sup class="sup">*</sup></code> is equivalent to the union of all <code>(<i class="var">T</i>)^<i class="var">N</i></code> for <code><i class="var">N</i></code>>=0,
<code>(<i class="var">T</i>)<sup class="sup">+</sup></code> is equivalent to the union of all <code>(<i class="var">T</i>)^<i class="var">N</i></code> for <code><i class="var">N</i></code>>=1, and
<code>(<i class="var">T</i>)<sup class="sup">?</sup></code> is equivalent to <code><i class="var">T</i> | ( )</code>.
The parentheses around <code><i class="var">T</i></code> above can be omitted when they are not needed for
disambiguation.
(Non-trivial) sequence types are not values, so not included in <code><span class="name"><a href="../../Value-Types/index.html#Name_types">types</a></span></code>.
<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="../../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_length">length</span></span>(_:<span class="name"><a href="../../Value-Types/index.html#Name_values">values</a></span><sup class="sup">*</sup>) : =><span class="name"><a href="../../Primitive/Integers/index.html#Name_natural-numbers">natural-numbers</a></span></code></pre></div>
<code><span class="name"><a href="#Name_length">length</a></span>(<i class="var">V<sup class="sup">*</sup></i>)</code> gives the number of elements in <code><i class="var">V<sup class="sup">*</sup></i></code>.
<div class="highlighter-rouge"><pre class="highlight"><code><i class="keyword">Rule</i>
<span class="name"><a href="#Name_length">length</a></span>( ) ~> 0
<i class="keyword">Rule</i>
<span class="name"><a href="#Name_length">length</a></span>(<span id="Variable675_V"><i class="var">V</i></span>:<span class="name"><a href="../../Value-Types/index.html#Name_values">values</a></span>, <span id="Variable684_V*"><i class="var">V<sup class="sup">*</sup></i></span>:<span class="name"><a href="../../Value-Types/index.html#Name_values">values</a></span><sup class="sup">*</sup>) ~> <span class="name"><a href="../../Primitive/Integers/index.html#Name_natural-successor">natural-successor</a></span>(<span class="name"><a href="#Name_length">length</a></span>(<a href="#Variable684_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_is-in">is-in</span></span>(_:<span class="name"><a href="../../Value-Types/index.html#Name_values">values</a></span>, _:<span class="name"><a href="../../Value-Types/index.html#Name_values">values</a></span><sup class="sup">*</sup>) : =><span class="name"><a href="../../Primitive/Booleans/index.html#Name_booleans">booleans</a></span>
<i class="keyword">Rule</i>
<span class="name"><a href="#Name_is-in">is-in</a></span>(<span id="Variable756_V"><i class="var">V</i></span>:<span class="name"><a href="../../Value-Types/index.html#Name_values">values</a></span> ,<span id="Variable765_V'"><i class="var">V&prime;</i></span>:<span class="name"><a href="../../Value-Types/index.html#Name_values">values</a></span>, <span id="Variable774_V*"><i class="var">V<sup class="sup">*</sup></i></span>:<span class="name"><a href="../../Value-Types/index.html#Name_values">values</a></span><sup class="sup">*</sup>) ~> <span class="name"><a href="../../Primitive/Booleans/index.html#Name_or">or</a></span>(<span class="name"><a href="../../Value-Types/index.html#Name_is-equal">is-equal</a></span>(<a href="#Variable756_V"><i class="var">V</i></a>, <a href="#Variable765_V'"><i class="var">V&prime;</i></a>), <span class="name"><a href="#Name_is-in">is-in</a></span>(<a href="#Variable756_V"><i class="var">V</i></a>, <a href="#Variable774_V*"><i class="var">V<sup class="sup">*</sup></i></a>))
<i class="keyword">Rule</i>
<span class="name"><a href="#Name_is-in">is-in</a></span>(<span id="Variable842_V"><i class="var">V</i></span>:<span class="name"><a href="../../Value-Types/index.html#Name_values">values</a></span>, ( )) ~> <span class="name"><a href="../../Primitive/Booleans/index.html#Name_false">false</a></span></code></pre></div>
#### Sequence indexing
<div class="highlighter-rouge"><pre class="highlight"><code><i class="keyword">Funcon</i>
<span class="name"><span id="Name_index">index</span></span>(_:<span class="name"><a href="../../Primitive/Integers/index.html#Name_natural-numbers">natural-numbers</a></span>, _:<span class="name"><a href="../../Value-Types/index.html#Name_values">values</a></span><sup class="sup">*</sup>) : =><span class="name"><a href="../../Value-Types/index.html#Name_values">values</a></span><sup class="sup">?</sup></code></pre></div>
<code><span class="name"><a href="#Name_index">index</a></span>(<i class="var">N</i>, <i class="var">V<sup class="sup">*</sup></i>)</code> gives the <code><i class="var">N</i></code>th element of <code><i class="var">V<sup class="sup">*</sup></i></code>, if it exists, otherwise <code>( )</code>.
<div class="highlighter-rouge"><pre class="highlight"><code><i class="keyword">Rule</i>
<span class="name"><a href="#Name_index">index</a></span>(1, <span id="Variable988_V"><i class="var">V</i></span>:<span class="name"><a href="../../Value-Types/index.html#Name_values">values</a></span>, <span id="Variable997_V*"><i class="var">V<sup class="sup">*</sup></i></span>:<span class="name"><a href="../../Value-Types/index.html#Name_values">values</a></span><sup class="sup">*</sup>) ~> <a href="#Variable988_V"><i class="var">V</i></a>
<i class="keyword">Rule</i>
<span class="name"><a href="../../Primitive/Integers/index.html#Name_natural-predecessor">natural-predecessor</a></span>(<a href="#Variable1047_N"><i class="var">N</i></a>) ~> <span id="Variable1036_N'"><i class="var">N&prime;</i></span>
-----------------------------------------------------------------
<span class="name"><a href="#Name_index">index</a></span>(<span id="Variable1047_N"><i class="var">N</i></span>:<span class="name"><a href="../../Primitive/Integers/index.html#Name_positive-integers">positive-integers</a></span>, _:<span class="name"><a href="../../Value-Types/index.html#Name_values">values</a></span>, <span id="Variable1063_V*"><i class="var">V<sup class="sup">*</sup></i></span>:<span class="name"><a href="../../Value-Types/index.html#Name_values">values</a></span><sup class="sup">*</sup>) ~> <span class="name"><a href="#Name_index">index</a></span>(<a href="#Variable1036_N'"><i class="var">N&prime;</i></a>, <a href="#Variable1063_V*"><i class="var">V<sup class="sup">*</sup></i></a>)
<i class="keyword">Rule</i>
<span class="name"><a href="#Name_index">index</a></span>(0, <span id="Variable1108_V*"><i class="var">V<sup class="sup">*</sup></i></span>:<span class="name"><a href="../../Value-Types/index.html#Name_values">values</a></span><sup class="sup">*</sup>) ~> ( )
<i class="keyword">Rule</i>
<span class="name"><a href="#Name_index">index</a></span>(_:<span class="name"><a href="../../Primitive/Integers/index.html#Name_positive-integers">positive-integers</a></span>, ( )) ~> ( )</code></pre></div>
Total indexing funcons:
<div class="highlighter-rouge"><pre class="highlight"><code><i class="keyword">Funcon</i>
<span class="name"><span id="Name_first">first</span></span>(_:<span id="Variable1168_T"><i class="var">T</i></span>, _:<span class="name"><a href="../../Value-Types/index.html#Name_values">values</a></span><sup class="sup">*</sup>) : =><span id="Variable1193_T"><i class="var">T</i></span>
<i class="keyword">Rule</i>
<span class="name"><a href="#Name_first">first</a></span>(<span id="Variable1202_V"><i class="var">V</i></span>:<i class="var">T</i>, <span id="Variable1214_V*"><i class="var">V<sup class="sup">*</sup></i></span>:<span class="name"><a href="../../Value-Types/index.html#Name_values">values</a></span><sup class="sup">*</sup>) ~> <a href="#Variable1202_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_second">second</span></span>(_:<span class="name"><a href="../../Value-Types/index.html#Name_values">values</a></span>, _:<span id="Variable1251_T"><i class="var">T</i></span>, _:<span class="name"><a href="../../Value-Types/index.html#Name_values">values</a></span><sup class="sup">*</sup>) : =><span id="Variable1277_T"><i class="var">T</i></span>
<i class="keyword">Rule</i>
<span class="name"><a href="#Name_second">second</a></span>(_:<span class="name"><a href="../../Value-Types/index.html#Name_values">values</a></span>, <span id="Variable1293_V"><i class="var">V</i></span>:<i class="var">T</i>, <span id="Variable1305_V*"><i class="var">V<sup class="sup">*</sup></i></span>:<span class="name"><a href="../../Value-Types/index.html#Name_values">values</a></span><sup class="sup">*</sup>) ~> <a href="#Variable1293_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_third">third</span></span>(_:<span class="name"><a href="../../Value-Types/index.html#Name_values">values</a></span>, _:<span class="name"><a href="../../Value-Types/index.html#Name_values">values</a></span>, _:<span id="Variable1351_T"><i class="var">T</i></span>, _:<span class="name"><a href="../../Value-Types/index.html#Name_values">values</a></span><sup class="sup">*</sup>) : =><span id="Variable1378_T"><i class="var">T</i></span>
<i class="keyword">Rule</i>
<span class="name"><a href="#Name_third">third</a></span>(_:<span class="name"><a href="../../Value-Types/index.html#Name_values">values</a></span>, _:<span class="name"><a href="../../Value-Types/index.html#Name_values">values</a></span>, <span id="Variable1401_V"><i class="var">V</i></span>:<i class="var">T</i>, <span id="Variable1413_V*"><i class="var">V<sup class="sup">*</sup></i></span>:<span class="name"><a href="../../Value-Types/index.html#Name_values">values</a></span><sup class="sup">*</sup>) ~> <a href="#Variable1401_V"><i class="var">V</i></a></code></pre></div>
#### Homogeneous sequences
<div class="highlighter-rouge"><pre class="highlight"><code><i class="keyword">Funcon</i>
<span class="name"><span id="Name_first-n">first-n</span></span>(_:<span class="name"><a href="../../Primitive/Integers/index.html#Name_natural-numbers">natural-numbers</a></span>, _:(<span id="Variable1473_T"><i class="var">T</i></span>)<sup class="sup">*</sup>) : =>(<span id="Variable1495_T"><i class="var">T</i></span>)<sup class="sup">*</sup>
<i class="keyword">Rule</i>
<span class="name"><a href="#Name_first-n">first-n</a></span>(0, <span id="Variable1514_V*"><i class="var">V<sup class="sup">*</sup></i></span>:(<i class="var">T</i>)<sup class="sup">*</sup>) ~> ( )
<i class="keyword">Rule</i>
<span class="name"><a href="../../Primitive/Integers/index.html#Name_natural-predecessor">natural-predecessor</a></span>(<a href="#Variable1570_N"><i class="var">N</i></a>) ~> <span id="Variable1559_N'"><i class="var">N&prime;</i></span>
-----------------------------------------------------------------
<span class="name"><a href="#Name_first-n">first-n</a></span>(<span id="Variable1570_N"><i class="var">N</i></span>:<span class="name"><a href="../../Primitive/Integers/index.html#Name_positive-integers">positive-integers</a></span>, <span id="Variable1578_V"><i class="var">V</i></span>:<i class="var">T</i>, <span id="Variable1590_V*"><i class="var">V<sup class="sup">*</sup></i></span>:(<i class="var">T</i>)<sup class="sup">*</sup>) ~> (<a href="#Variable1578_V"><i class="var">V</i></a>,<span class="name"><a href="#Name_first-n">first-n</a></span>(<a href="#Variable1559_N'"><i class="var">N&prime;</i></a>, <a href="#Variable1590_V*"><i class="var">V<sup class="sup">*</sup></i></a>))
<i class="keyword">Rule</i>
<span class="name"><a href="#Name_first-n">first-n</a></span>(<span id="Variable1651_N"><i class="var">N</i></span>:<span class="name"><a href="../../Primitive/Integers/index.html#Name_positive-integers">positive-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_drop-first-n">drop-first-n</span></span>(_:<span class="name"><a href="../../Primitive/Integers/index.html#Name_natural-numbers">natural-numbers</a></span>, _:(<span id="Variable1689_T"><i class="var">T</i></span>)<sup class="sup">*</sup>) : =>(<span id="Variable1711_T"><i class="var">T</i></span>)<sup class="sup">*</sup>
<i class="keyword">Rule</i>
<span class="name"><a href="#Name_drop-first-n">drop-first-n</a></span>(0, <span id="Variable1730_V*"><i class="var">V<sup class="sup">*</sup></i></span>:(<i class="var">T</i>)<sup class="sup">*</sup>) ~> <a href="#Variable1730_V*"><i class="var">V<sup class="sup">*</sup></i></a>
<i class="keyword">Rule</i>
<span class="name"><a href="../../Primitive/Integers/index.html#Name_natural-predecessor">natural-predecessor</a></span>(<a href="#Variable1788_N"><i class="var">N</i></a>) ~> <span id="Variable1777_N'"><i class="var">N&prime;</i></span>
-----------------------------------------------------------------------
<span class="name"><a href="#Name_drop-first-n">drop-first-n</a></span>(<span id="Variable1788_N"><i class="var">N</i></span>:<span class="name"><a href="../../Primitive/Integers/index.html#Name_positive-integers">positive-integers</a></span>, _:<i class="var">T</i>, <span id="Variable1807_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_drop-first-n">drop-first-n</a></span>(<a href="#Variable1777_N'"><i class="var">N&prime;</i></a>, <a href="#Variable1807_V*"><i class="var">V<sup class="sup">*</sup></i></a>)
<i class="keyword">Rule</i>
<span class="name"><a href="#Name_drop-first-n">drop-first-n</a></span>(<span id="Variable1857_N"><i class="var">N</i></span>:<span class="name"><a href="../../Primitive/Integers/index.html#Name_positive-integers">positive-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_reverse">reverse</span></span>(_:(<span id="Variable1887_T"><i class="var">T</i></span>)<sup class="sup">*</sup>) : =>(<span id="Variable1908_T"><i class="var">T</i></span>)<sup class="sup">*</sup>
<i class="keyword">Rule</i>
<span class="name"><a href="#Name_reverse">reverse</a></span>( ) ~> ( )
<i class="keyword">Rule</i>
<span class="name"><a href="#Name_reverse">reverse</a></span>(<span id="Variable1937_V"><i class="var">V</i></span>:<i class="var">T</i>, <span id="Variable1949_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_reverse">reverse</a></span>(<a href="#Variable1949_V*"><i class="var">V<sup class="sup">*</sup></i></a>), <a href="#Variable1937_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_n-of">n-of</span></span>(<span id="Variable2002_N"><i class="var">N</i></span>:<span class="name"><a href="../../Primitive/Integers/index.html#Name_natural-numbers">natural-numbers</a></span>, <span id="Variable2011_V"><i class="var">V</i></span>:<span id="Variable2015_T"><i class="var">T</i></span>) : =>(<span id="Variable2030_T"><i class="var">T</i></span>)<sup class="sup">*</sup>
<i class="keyword">Rule</i>
<span class="name"><a href="#Name_n-of">n-of</a></span>(0, _:<i class="var">T</i>) ~> ( )
<i class="keyword">Rule</i>
<span class="name"><a href="../../Primitive/Integers/index.html#Name_natural-predecessor">natural-predecessor</a></span>(<a href="#Variable2096_N"><i class="var">N</i></a>) ~> <span id="Variable2085_N'"><i class="var">N&prime;</i></span>
--------------------------------------------------
<span class="name"><a href="#Name_n-of">n-of</a></span>(<span id="Variable2096_N"><i class="var">N</i></span>:<span class="name"><a href="../../Primitive/Integers/index.html#Name_positive-integers">positive-integers</a></span>, <span id="Variable2104_V"><i class="var">V</i></span>:<i class="var">T</i>) ~> (<a href="#Variable2104_V"><i class="var">V</i></a>, <span class="name"><a href="#Name_n-of">n-of</a></span>(<a href="#Variable2085_N'"><i class="var">N&prime;</i></a>, <a href="#Variable2104_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_intersperse">intersperse</span></span>(_:<span id="Variable2160_T'"><i class="var">T&prime;</i></span>, _:(<span id="Variable2171_T"><i class="var">T</i></span>)<sup class="sup">*</sup>) : =>(<span id="Variable2193_T"><i class="var">T</i></span>, (<span id="Variable2199_T'"><i class="var">T&prime;</i></span>, <span id="Variable2204_T"><i class="var">T</i></span>)<sup class="sup">*</sup>)<sup class="sup">?</sup>
<i class="keyword">Rule</i>
<span class="name"><a href="#Name_intersperse">intersperse</a></span>(_:<i class="var">T&prime;</i>, ( )) ~> ( )
<i class="keyword">Rule</i>
<span class="name"><a href="#Name_intersperse">intersperse</a></span>(_:<i class="var">T&prime;</i>, <span id="Variable2270_V"><i class="var">V</i></span>) ~> <a href="#Variable2270_V"><i class="var">V</i></a>
<i class="keyword">Rule</i>
<span class="name"><a href="#Name_intersperse">intersperse</a></span>(<span id="Variable2292_V'"><i class="var">V&prime;</i></span>:<i class="var">T&prime;</i>, <span id="Variable2305_V1"><i class="var">V<sub class="sub">1</sub></i></span>:<i class="var">T</i>, <span id="Variable2317_V2"><i class="var">V<sub class="sub">2</sub></i></span>:<i class="var">T</i>, <span id="Variable2329_V*"><i class="var">V<sup class="sup">*</sup></i></span>:(<i class="var">T</i>)<sup class="sup">*</sup>) ~> (<a href="#Variable2305_V1"><i class="var">V<sub class="sub">1</sub></i></a>, <a href="#Variable2292_V'"><i class="var">V&prime;</i></a>, <span class="name"><a href="#Name_intersperse">intersperse</a></span>(<a href="#Variable2292_V'"><i class="var">V&prime;</i></a>, <a href="#Variable2317_V2"><i class="var">V<sub class="sub">2</sub></i></a>, <a href="#Variable2329_V*"><i class="var">V<sup class="sup">*</sup></i></a>))</code></pre></div>
____
From the [PLanCompS Project] | [CBS-beta issues...] | [Suggest an improvement...]
[Sequences.cbs]: Sequences.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/Sequences/Sequences.cbs%0A%0AComment/Query/Issue/Suggestion%3A%0A%0A%0ASignature%3A%0A
"GENERATE AN EMAIL TEMPLATE"

14
IBAF-cbs/Funcons-beta/Values/Composite/Sequences/tests/drop-first-n.config Normal file
View File

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

14
IBAF-cbs/Funcons-beta/Values/Composite/Sequences/tests/first-n.config Normal file
View File

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

12
IBAF-cbs/Funcons-beta/Values/Composite/Sequences/tests/first.config Normal file
View File

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

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

@@ -0,0 +1,21 @@
general {
funcon-term: sequential (
check-true(is-equal(index(1,1), 1))
, check-true(is-equal(index(1,1,2), 1))
, check-true(is-equal(index(2,1,2), 2))
, check-true(is-equal(index(2,1,2,3), 2))
, check-true(not is-value(index(0)))
, check-true(not is-value(index(0,1)))
, check-true(not is-value(index(0,1,2)))
, check-true(not is-value(index(1)))
, check-true(not is-value(index(2)))
, check-true(not is-value(index(2,1)))
, check-true(not is-value(index(3,1,2)))
, print "OK"
);
}
tests {
result-term : null-value;
standard-out : ["OK"];
}

14
IBAF-cbs/Funcons-beta/Values/Composite/Sequences/tests/intersperse.config Normal file
View File

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

18
IBAF-cbs/Funcons-beta/Values/Composite/Sequences/tests/is-in.config Normal file
View File

@@ -0,0 +1,18 @@
general {
funcon-term: sequential (
check-true(is-in(1,1))
, check-true(is-in(1,1,2))
, check-true(is-in(2,1,2))
, check-true(is-in(3,1,2,3,4,5))
, check-true(not is-in(0))
, check-true(not is-in(1))
, check-true(not is-in(0,1))
, check-true(not is-in(3,1,2))
, print "OK"
);
}
tests {
result-term : null-value;
standard-out : ["OK"];
}

13
IBAF-cbs/Funcons-beta/Values/Composite/Sequences/tests/length.config Normal file
View File

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

14
IBAF-cbs/Funcons-beta/Values/Composite/Sequences/tests/n-of.config Normal file
View File

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

14
IBAF-cbs/Funcons-beta/Values/Composite/Sequences/tests/reverse.config Normal file
View File

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

12
IBAF-cbs/Funcons-beta/Values/Composite/Sequences/tests/second.config Normal file
View File

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

12
IBAF-cbs/Funcons-beta/Values/Composite/Sequences/tests/third.config Normal file
View File

@@ -0,0 +1,12 @@
general {
funcon-term: sequential (
check-true(is-equal(third(1,2,3), 3))
, check-true(is-equal(third(1,2,3,4), 3))
, print "OK"
);
}
tests {
result-term : null-value;
standard-out : ["OK"];
}

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];
}

36
IBAF-cbs/Funcons-beta/Values/Composite/Strings/Strings.cbs Normal file
View File

@@ -0,0 +1,36 @@
### Strings
[
Type strings
Funcon string
Funcon string-append
Funcon to-string
]
Type
strings ~> lists(characters)
Funcon
string(C*:characters*) : =>strings
~> [C*]
/*
Literal strings are written `"C1...Cn"`.
A double-quote or backslash needs to be escaped: `"...\"..."`, `"...\\..."`.
*/
Funcon
string-append(S*:strings*) : =>strings
~> list-append(S*)
Built-in Funcon
to-string(_:ground-values) : =>strings
/*
The strings returned by `to-string(GV)` are unspecified, except that when
`GV` is already a string, it is returned unchanged.
*/
Assert
to-string(S:strings) == S

75
IBAF-cbs/Funcons-beta/Values/Composite/Strings/index.md Normal file
View File

@@ -0,0 +1,75 @@
---
layout: default
title: "Strings"
parent: Composite
ancestor: Funcons-beta
---
[Funcons-beta] : [Strings.cbs]
-----------------------------
### Strings
<div class="highlighter-rouge"><pre class="highlight"><code>[
<i class="keyword">Type</i> <span class="name"><a href="#Name_strings">strings</a></span>
<i class="keyword">Funcon</i> <span class="name"><a href="#Name_string">string</a></span>
<i class="keyword">Funcon</i> <span class="name"><a href="#Name_string-append">string-append</a></span>
<i class="keyword">Funcon</i> <span class="name"><a href="#Name_to-string">to-string</a></span>
]</code></pre></div>
<div class="highlighter-rouge"><pre class="highlight"><code><i class="keyword">Type</i>
<span class="name"><span id="Name_strings">strings</span></span> ~> <span class="name"><a href="../Lists/index.html#Name_lists">lists</a></span>(<span class="name"><a href="../../Primitive/Characters/index.html#Name_characters">characters</a></span>)</code></pre></div>
<div class="highlighter-rouge"><pre class="highlight"><code><i class="keyword">Funcon</i>
<span class="name"><span id="Name_string">string</span></span>(<span id="Variable47_C*"><i class="var">C<sup class="sup">*</sup></i></span>:<span class="name"><a href="../../Primitive/Characters/index.html#Name_characters">characters</a></span><sup class="sup">*</sup>) : =><span class="name"><a href="#Name_strings">strings</a></span>
~> [<a href="#Variable47_C*"><i class="var">C<sup class="sup">*</sup></i></a>]</code></pre></div>
Literal strings are written <code>"C1...Cn"</code>.
A double-quote or backslash needs to be escaped: <code>"...\"..."</code>, <code>"...\\..."</code>.
<div class="highlighter-rouge"><pre class="highlight"><code><i class="keyword">Funcon</i>
<span class="name"><span id="Name_string-append">string-append</span></span>(<span id="Variable119_S*"><i class="var">S<sup class="sup">*</sup></i></span>:<span class="name"><a href="#Name_strings">strings</a></span><sup class="sup">*</sup>) : =><span class="name"><a href="#Name_strings">strings</a></span>
~> <span class="name"><a href="../Lists/index.html#Name_list-append">list-append</a></span>(<a href="#Variable119_S*"><i class="var">S<sup class="sup">*</sup></i></a>)</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_to-string">to-string</span></span>(_:<span class="name"><a href="../../Value-Types/index.html#Name_ground-values">ground-values</a></span>) : =><span class="name"><a href="#Name_strings">strings</a></span></code></pre></div>
The strings returned by <code><span class="name"><a href="#Name_to-string">to-string</a></span>(<i class="var">GV</i>)</code> are unspecified, except that when
<code><i class="var">GV</i></code> is already a string, it is returned unchanged.
<div class="highlighter-rouge"><pre class="highlight"><code><i class="keyword">Assert</i>
<span class="name"><a href="#Name_to-string">to-string</a></span>(<i class="var">S</i>:<span class="name"><a href="#Name_strings">strings</a></span>) == <i class="var">S</i></code></pre></div>
____
From the [PLanCompS Project] | [CBS-beta issues...] | [Suggest an improvement...]
[Strings.cbs]: Strings.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/Strings/Strings.cbs%0A%0AComment/Query/Issue/Suggestion%3A%0A%0A%0ASignature%3A%0A
"GENERATE AN EMAIL TEMPLATE"

94
IBAF-cbs/Funcons-beta/Values/Composite/Trees/Trees.cbs Normal file
View File

@@ -0,0 +1,94 @@
### Trees
[
Datatype trees
Funcon tree
Funcon tree-root-value
Funcon tree-branch-sequence
Funcon single-branching-sequence
Funcon forest-root-value-sequence
Funcon forest-branch-sequence
Funcon forest-value-sequence
]
Meta-variables
T <: values
Datatype
trees(T) ::= tree( _:T, _:(trees(T))*)
/*
`trees(T)` consists of finitely-branching trees with elements of type `T`.
When `V:T`, `tree(V)` is a leaf, and `tree(V,B1,...,Bn)` is a tree with
branches `B1`, ..., `Bn`.
*/
Funcon
tree-root-value(_:trees(T)) : =>(T)?
Rule
tree-root-value tree(V:T, _*:(trees(T))*) ~> V
Funcon
tree-branch-sequence(_:trees(T)) : =>(trees(T))*
Rule
tree-branch-sequence tree(_:T, B*:(trees(T))*) ~> B*
Funcon
single-branching-sequence(_:trees(T)) : =>T+
/*
`single-branching-sequence B ` extracts the values in `B` starting from
the root, provided that `B` is at most single-branching; otherwise it fails.
*/
Rule
single-branching-sequence tree(V:T) ~> V
Rule
single-branching-sequence tree(V:T, B:trees(T))
~> left-to-right( V, single-branching-sequence B)
Rule
single-branching-sequence tree(_:T, _:trees(T), _+:(trees(T))+) ~> fail
/*
A sequence of trees corresponds to a forest, and the selector funcons
on trees `B` extend to forests `B*`:
*/
Funcon
forest-root-value-sequence(_:(trees(T))*) : =>T*
Rule
forest-root-value-sequence(B:trees(T), B*:(trees(T))*)
~>(tree-root-value B , forest-root-value-sequence B*)
Rule
forest-root-value-sequence( ) ~>( )
Funcon
forest-branch-sequence(_:(trees(T))*) : =>T*
Rule
forest-branch-sequence(B:trees(T), B*:(trees(T))*)
~>(tree-branch-sequence B , forest-branch-sequence B*)
Rule
forest-branch-sequence( ) ~>( )
Funcon
forest-value-sequence(_:(trees(T))*) : =>T*
/*
`forest-value-sequence B*` provides the values from a left-to-right pre-order
depth-first traversal.
*/
Rule
forest-value-sequence(tree(V:T, B1*:(trees(T))*), B2*:(trees(T))*)
~>(V , forest-value-sequence B1*, forest-value-sequence B2*)
Rule
forest-value-sequence( ) ~>( )
/*
Other linearizations of trees can be added: breadth-first, right-to-left,
C3, etc.
*/

130
IBAF-cbs/Funcons-beta/Values/Composite/Trees/index.md Normal file
View File

@@ -0,0 +1,130 @@
---
layout: default
title: "Trees"
parent: Composite
ancestor: Funcons-beta
---
[Funcons-beta] : [Trees.cbs]
-----------------------------
### Trees
<div class="highlighter-rouge"><pre class="highlight"><code>[
<i class="keyword">Datatype</i> <span class="name"><a href="#Name_trees">trees</a></span>
<i class="keyword">Funcon</i> <span class="name"><a href="#Name_tree">tree</a></span>
<i class="keyword">Funcon</i> <span class="name"><a href="#Name_tree-root-value">tree-root-value</a></span>
<i class="keyword">Funcon</i> <span class="name"><a href="#Name_tree-branch-sequence">tree-branch-sequence</a></span>
<i class="keyword">Funcon</i> <span class="name"><a href="#Name_single-branching-sequence">single-branching-sequence</a></span>
<i class="keyword">Funcon</i> <span class="name"><a href="#Name_forest-root-value-sequence">forest-root-value-sequence</a></span>
<i class="keyword">Funcon</i> <span class="name"><a href="#Name_forest-branch-sequence">forest-branch-sequence</a></span>
<i class="keyword">Funcon</i> <span class="name"><a href="#Name_forest-value-sequence">forest-value-sequence</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="../../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_trees">trees</span></span>(<span id="Variable60_T"><i class="var">T</i></span>) ::= <span id="Name_tree">tree</span>( _:<span id="Variable76_T"><i class="var">T</i></span>, _:(<span class="name"><a href="#Name_trees">trees</a></span>(<span id="Variable88_T"><i class="var">T</i></span>))<sup class="sup">*</sup>)</code></pre></div>
<code><span class="name"><a href="#Name_trees">trees</a></span>(<i class="var">T</i>)</code> consists of finitely-branching trees with elements of type <code><i class="var">T</i></code>.
When <code><i class="var">V</i>:<i class="var">T</i></code>, <code><span class="name"><a href="#Name_tree">tree</a></span>(<i class="var">V</i>)</code> is a leaf, and <code><span class="name"><a href="#Name_tree">tree</a></span>(<i class="var">V</i>,<i class="var">B<sub class="sub">1</sub></i>,...,<i class="var">Bn</i>)</code> is a tree with
branches <code><i class="var">B<sub class="sub">1</sub></i></code>, ..., <code><i class="var">Bn</i></code>.
<div class="highlighter-rouge"><pre class="highlight"><code><i class="keyword">Funcon</i>
<span class="name"><span id="Name_tree-root-value">tree-root-value</span></span>(_:<span class="name"><a href="#Name_trees">trees</a></span>(<span id="Variable269_T"><i class="var">T</i></span>)) : =>(<span id="Variable289_T"><i class="var">T</i></span>)<sup class="sup">?</sup>
<i class="keyword">Rule</i>
<span class="name"><a href="#Name_tree-root-value">tree-root-value</a></span> <span class="name"><a href="#Name_tree">tree</a></span>(<span id="Variable306_V"><i class="var">V</i></span>:<i class="var">T</i>, _*:(<span class="name"><a href="#Name_trees">trees</a></span>(<i class="var">T</i>))<sup class="sup">*</sup>) ~> <a href="#Variable306_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_tree-branch-sequence">tree-branch-sequence</span></span>(_:<span class="name"><a href="#Name_trees">trees</a></span>(<span id="Variable363_T"><i class="var">T</i></span>)) : =>(<span class="name"><a href="#Name_trees">trees</a></span>(<span id="Variable384_T"><i class="var">T</i></span>))<sup class="sup">*</sup>
<i class="keyword">Rule</i>
<span class="name"><a href="#Name_tree-branch-sequence">tree-branch-sequence</a></span> <span class="name"><a href="#Name_tree">tree</a></span>(_:<i class="var">T</i>, <span id="Variable418_B*"><i class="var">B<sup class="sup">*</sup></i></span>:(<span class="name"><a href="#Name_trees">trees</a></span>(<i class="var">T</i>))<sup class="sup">*</sup>) ~> <a href="#Variable418_B*"><i class="var">B<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_single-branching-sequence">single-branching-sequence</span></span>(_:<span class="name"><a href="#Name_trees">trees</a></span>(<span id="Variable465_T"><i class="var">T</i></span>)) : =><span id="Variable486_T+"><i class="var">T<sup class="sup">+</sup></i></span></code></pre></div>
<code><span class="name"><a href="#Name_single-branching-sequence">single-branching-sequence</a></span> <i class="var">B</i></code> extracts the values in <code><i class="var">B</i></code> starting from
the root, provided that <code><i class="var">B</i></code> is at most single-branching; otherwise it fails.
<div class="highlighter-rouge"><pre class="highlight"><code><i class="keyword">Rule</i>
<span class="name"><a href="#Name_single-branching-sequence">single-branching-sequence</a></span> <span class="name"><a href="#Name_tree">tree</a></span>(<span id="Variable543_V"><i class="var">V</i></span>:<i class="var">T</i>) ~> <a href="#Variable543_V"><i class="var">V</i></a>
<i class="keyword">Rule</i>
<span class="name"><a href="#Name_single-branching-sequence">single-branching-sequence</a></span> <span class="name"><a href="#Name_tree">tree</a></span>(<span id="Variable571_V"><i class="var">V</i></span>:<i class="var">T</i>, <span id="Variable582_B"><i class="var">B</i></span>:<span class="name"><a href="#Name_trees">trees</a></span>(<i class="var">T</i>))
~> <span class="name"><a href="../../../Computations/Normal/Flowing/index.html#Name_left-to-right">left-to-right</a></span>( <a href="#Variable571_V"><i class="var">V</i></a>, <span class="name"><a href="#Name_single-branching-sequence">single-branching-sequence</a></span> <a href="#Variable582_B"><i class="var">B</i></a>)
<i class="keyword">Rule</i>
<span class="name"><a href="#Name_single-branching-sequence">single-branching-sequence</a></span> <span class="name"><a href="#Name_tree">tree</a></span>(_:<i class="var">T</i>, _:<span class="name"><a href="#Name_trees">trees</a></span>(<i class="var">T</i>), _+:(<span class="name"><a href="#Name_trees">trees</a></span>(<i class="var">T</i>))<sup class="sup">+</sup>) ~> <span class="name"><a href="../../../Computations/Abnormal/Failing/index.html#Name_fail">fail</a></span></code></pre></div>
A sequence of trees corresponds to a forest, and the selector funcons
on trees <code><i class="var">B</i></code> extend to forests <code><i class="var">B<sup class="sup">*</sup></i></code>:
<div class="highlighter-rouge"><pre class="highlight"><code><i class="keyword">Funcon</i>
<span class="name"><span id="Name_forest-root-value-sequence">forest-root-value-sequence</span></span>(_:(<span class="name"><a href="#Name_trees">trees</a></span>(<span id="Variable737_T"><i class="var">T</i></span>))<sup class="sup">*</sup>) : =><span id="Variable765_T*"><i class="var">T<sup class="sup">*</sup></i></span>
<i class="keyword">Rule</i>
<span class="name"><a href="#Name_forest-root-value-sequence">forest-root-value-sequence</a></span>(<span id="Variable774_B"><i class="var">B</i></span>:<span class="name"><a href="#Name_trees">trees</a></span>(<i class="var">T</i>), <span id="Variable793_B*"><i class="var">B<sup class="sup">*</sup></i></span>:(<span class="name"><a href="#Name_trees">trees</a></span>(<i class="var">T</i>))<sup class="sup">*</sup>)
~>(<span class="name"><a href="#Name_tree-root-value">tree-root-value</a></span> <a href="#Variable774_B"><i class="var">B</i></a> , <span class="name"><a href="#Name_forest-root-value-sequence">forest-root-value-sequence</a></span> <a href="#Variable793_B*"><i class="var">B<sup class="sup">*</sup></i></a>)
<i class="keyword">Rule</i>
<span class="name"><a href="#Name_forest-root-value-sequence">forest-root-value-sequence</a></span>( ) ~>( )</code></pre></div>
<div class="highlighter-rouge"><pre class="highlight"><code><i class="keyword">Funcon</i>
<span class="name"><span id="Name_forest-branch-sequence">forest-branch-sequence</span></span>(_:(<span class="name"><a href="#Name_trees">trees</a></span>(<span id="Variable867_T"><i class="var">T</i></span>))<sup class="sup">*</sup>) : =><span id="Variable895_T*"><i class="var">T<sup class="sup">*</sup></i></span>
<i class="keyword">Rule</i>
<span class="name"><a href="#Name_forest-branch-sequence">forest-branch-sequence</a></span>(<span id="Variable904_B"><i class="var">B</i></span>:<span class="name"><a href="#Name_trees">trees</a></span>(<i class="var">T</i>), <span id="Variable923_B*"><i class="var">B<sup class="sup">*</sup></i></span>:(<span class="name"><a href="#Name_trees">trees</a></span>(<i class="var">T</i>))<sup class="sup">*</sup>)
~>(<span class="name"><a href="#Name_tree-branch-sequence">tree-branch-sequence</a></span> <a href="#Variable904_B"><i class="var">B</i></a> , <span class="name"><a href="#Name_forest-branch-sequence">forest-branch-sequence</a></span> <a href="#Variable923_B*"><i class="var">B<sup class="sup">*</sup></i></a>)
<i class="keyword">Rule</i>
<span class="name"><a href="#Name_forest-branch-sequence">forest-branch-sequence</a></span>( ) ~>( )</code></pre></div>
<div class="highlighter-rouge"><pre class="highlight"><code><i class="keyword">Funcon</i>
<span class="name"><span id="Name_forest-value-sequence">forest-value-sequence</span></span>(_:(<span class="name"><a href="#Name_trees">trees</a></span>(<span id="Variable997_T"><i class="var">T</i></span>))<sup class="sup">*</sup>) : =><span id="Variable1025_T*"><i class="var">T<sup class="sup">*</sup></i></span></code></pre></div>
<code><span class="name"><a href="#Name_forest-value-sequence">forest-value-sequence</a></span> <i class="var">B<sup class="sup">*</sup></i></code> provides the values from a left-to-right pre-order
depth-first traversal.
<div class="highlighter-rouge"><pre class="highlight"><code><i class="keyword">Rule</i>
<span class="name"><a href="#Name_forest-value-sequence">forest-value-sequence</a></span>(<span class="name"><a href="#Name_tree">tree</a></span>(<span id="Variable1057_V"><i class="var">V</i></span>:<i class="var">T</i>, <span id="Variable1070_B1*"><i class="var">B<sub class="sub">1</sub><sup class="sup">*</sup></i></span>:(<span class="name"><a href="#Name_trees">trees</a></span>(<i class="var">T</i>))<sup class="sup">*</sup>), <span id="Variable1104_B2*"><i class="var">B<sub class="sub">2</sub><sup class="sup">*</sup></i></span>:(<span class="name"><a href="#Name_trees">trees</a></span>(<i class="var">T</i>))<sup class="sup">*</sup>)
~>(<a href="#Variable1057_V"><i class="var">V</i></a> , <span class="name"><a href="#Name_forest-value-sequence">forest-value-sequence</a></span> <a href="#Variable1070_B1*"><i class="var">B<sub class="sub">1</sub><sup class="sup">*</sup></i></a>, <span class="name"><a href="#Name_forest-value-sequence">forest-value-sequence</a></span> <a href="#Variable1104_B2*"><i class="var">B<sub class="sub">2</sub><sup class="sup">*</sup></i></a>)
<i class="keyword">Rule</i>
<span class="name"><a href="#Name_forest-value-sequence">forest-value-sequence</a></span>( ) ~>( )</code></pre></div>
Other linearizations of trees can be added: breadth-first, right-to-left,
C3, etc.
____
From the [PLanCompS Project] | [CBS-beta issues...] | [Suggest an improvement...]
[Trees.cbs]: Trees.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/Trees/Trees.cbs%0A%0AComment/Query/Issue/Suggestion%3A%0A%0A%0ASignature%3A%0A
"GENERATE AN EMAIL TEMPLATE"

20
IBAF-cbs/Funcons-beta/Values/Composite/Trees/tests/forest-branch-sequence.config Normal file
View File

@@ -0,0 +1,20 @@
general {
funcon-term:
initialise-giving finalise-failing
sequential (
print [forest-branch-sequence
(tree(1),
tree(2,tree(3)),
tree(4),
tree(5,tree(6),tree(7)))
]
)
;
}
tests {
result-term: null-value;
standard-out: [
[tree(3),tree(6),tree(7)]
];
}

20
IBAF-cbs/Funcons-beta/Values/Composite/Trees/tests/forest-root-value-sequence.config Normal file
View File

@@ -0,0 +1,20 @@
general {
funcon-term:
initialise-giving finalise-failing
sequential (
print [forest-root-value-sequence
(tree(1),
tree(2,tree(3)),
tree(4),
tree(5,tree(6),tree(7)))
]
)
;
}
tests {
result-term: null-value;
standard-out: [
[1,2,4,5]
];
}

20
IBAF-cbs/Funcons-beta/Values/Composite/Trees/tests/forest-value-sequence.config Normal file
View File

@@ -0,0 +1,20 @@
general {
funcon-term:
initialise-giving finalise-failing
sequential (
print [forest-value-sequence
(tree(1),
tree(2,tree(3)),
tree(4),
tree(5,tree(6),tree(7)))
]
)
;
}
tests {
result-term: null-value;
standard-out: [
[1,2,3,4,5,6,7]
];
}

22
IBAF-cbs/Funcons-beta/Values/Composite/Trees/tests/single-branching-sequence.config Normal file
View File

@@ -0,0 +1,22 @@
general {
funcon-term:
initialise-giving finalise-failing
sequential (
print [single-branching-sequence tree(1)],
print [single-branching-sequence tree(1,tree(2,tree(3)))],
else(
print [single-branching-sequence tree(1,tree(2),tree(3))],
print [single-branching-sequence tree(1,tree(2,tree(3,tree(4),tree(5))))],
print "OK")
)
;
}
tests {
result-term: null-value;
standard-out: [
[1],
[1,2,3],
"OK"
];
}

16
IBAF-cbs/Funcons-beta/Values/Composite/Trees/tests/tree-branch-sequence.config Normal file
View File

@@ -0,0 +1,16 @@
general {
funcon-term:
initialise-giving finalise-failing
sequential (
print tree-branch-sequence
tree(1,tree(2,tree(3)),tree(4),tree(5,tree(6),tree(7)))
)
;
}
tests {
result-term: null-value;
standard-out: [
tree(2,tree(3)), tree(4), tree(5,tree(6),tree(7))
];
}

16
IBAF-cbs/Funcons-beta/Values/Composite/Trees/tests/tree-root-value.config Normal file
View File

@@ -0,0 +1,16 @@
general {
funcon-term:
initialise-giving finalise-failing
sequential (
print tree-root-value
tree(1,tree(2,tree(3)),tree(4),tree(5,tree(6),tree(7)))
)
;
}
tests {
result-term: null-value;
standard-out: [
1
];
}

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

@@ -0,0 +1,21 @@
general {
funcon-term:
initialise-giving finalise-failing
sequential (
print tree(1),
print tree(1,tree(2,tree(3))),
print tree(1,tree(2),tree(3)),
print tree(1,tree(2,tree(3)),tree(4),tree(5,tree(6),tree(7)))
)
;
}
tests {
result-term: null-value;
standard-out: [
tree(1),
tree(1,tree(2,tree(3))),
tree(1,tree(2),tree(3)),
tree(1,tree(2,tree(3)),tree(4),tree(5,tree(6),tree(7)))
];
}

47
IBAF-cbs/Funcons-beta/Values/Composite/Tuples/Tuples.cbs Normal file
View File

@@ -0,0 +1,47 @@
### Tuples
[
Datatype tuples
Funcon tuple-elements
Funcon tuple-zip
]
Meta-variables
T1, T2 <: values
T1+, T2+ <: values+
T*, T1*, T2* <: values*
Datatype
tuples(T*) ::= tuple(_:T*)
/*
`T*` can be any sequence of types, including `( )` and `values*`.
The values of type `tuples(T1, ..., Tn)` are of the form `tuple(V1, ..., Vn)`
with `V1:T1`, ..., `Vn:Tn`.
*/
Funcon
tuple-elements(_:tuples(T*)) : =>(T*)
Rule
tuple-elements(tuple(V*:T*)) ~> V*
Funcon
tuple-zip(_:tuples(values*), _:tuples(values*)) : =>(tuples(values,values))*
/*
`tuple-zip(TV1, TV2)` takes two tuples, and returns the sequence of pairs of
their elements, provided that they have the same length. If they have
different lengths, the last elements of the longer sequence are ignored.
*/
Rule
tuple-zip(tuple(V1:T1, V1*:T1*), tuple(V2:T2, V2*:T2*))
~> (tuple(V1, V2), tuple-zip(tuple(V1*), tuple(V2*)))
Rule
tuple-zip(tuple( ), tuple( )) ~> ( )
Rule
tuple-zip(tuple(V1+:T1+), tuple( )) ~> ( )
Rule
tuple-zip(tuple( ), tuple(V2+:T2+)) ~> ( )

84
IBAF-cbs/Funcons-beta/Values/Composite/Tuples/index.md Normal file
View File

@@ -0,0 +1,84 @@
---
layout: default
title: "Tuples"
parent: Composite
ancestor: Funcons-beta
---
[Funcons-beta] : [Tuples.cbs]
-----------------------------
### Tuples
<div class="highlighter-rouge"><pre class="highlight"><code>[
<i class="keyword">Datatype</i> <span class="name"><a href="#Name_tuples">tuples</a></span>
<i class="keyword">Funcon</i> <span class="name"><a href="#Name_tuple-elements">tuple-elements</a></span>
<i class="keyword">Funcon</i> <span class="name"><a href="#Name_tuple-zip">tuple-zip</a></span>
]</code></pre></div>
<div class="highlighter-rouge"><pre class="highlight"><code><i class="keyword">Meta-variables</i>
<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="../../Value-Types/index.html#Name_values">values</a></span>
<span id="PartVariable_T1+"><i class="var">T<sub class="sub">1</sub><sup class="sup">+</sup></i></span>, <span id="PartVariable_T2+"><i class="var">T<sub class="sub">2</sub><sup class="sup">+</sup></i></span> <: <span class="name"><a href="../../Value-Types/index.html#Name_values">values</a></span><sup class="sup">+</sup>
<span id="PartVariable_T*"><i class="var">T<sup class="sup">*</sup></i></span>, <span id="PartVariable_T1*"><i class="var">T<sub class="sub">1</sub><sup class="sup">*</sup></i></span>, <span id="PartVariable_T2*"><i class="var">T<sub class="sub">2</sub><sup class="sup">*</sup></i></span> <: <span class="name"><a href="../../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">Datatype</i>
<span class="name"><span id="Name_tuples">tuples</span></span>(<span id="Variable98_T*"><i class="var">T<sup class="sup">*</sup></i></span>) ::= <span id="Name_tuple">tuple</span>(_:<span id="Variable115_T*"><i class="var">T<sup class="sup">*</sup></i></span>)</code></pre></div>
<code><i class="var">T<sup class="sup">*</sup></i></code> can be any sequence of types, including <code>( )</code> and <code><span class="name"><a href="../../Value-Types/index.html#Name_values">values</a></span><sup class="sup">*</sup></code>.
The values of type <code><span class="name"><a href="#Name_tuples">tuples</a></span>(<i class="var">T<sub class="sub">1</sub></i>, ..., <i class="var">Tn</i>)</code> are of the form <code><span class="name"><a href="#Name_tuple">tuple</a></span>(<i class="var">V<sub class="sub">1</sub></i>, ..., <i class="var">Vn</i>)</code>
with <code><i class="var">V<sub class="sub">1</sub></i>:<i class="var">T<sub class="sub">1</sub></i></code>, ..., <code><i class="var">Vn</i>:<i class="var">Tn</i></code>.
<div class="highlighter-rouge"><pre class="highlight"><code><i class="keyword">Funcon</i>
<span class="name"><span id="Name_tuple-elements">tuple-elements</span></span>(_:<span class="name"><a href="#Name_tuples">tuples</a></span>(<span id="Variable287_T*"><i class="var">T<sup class="sup">*</sup></i></span>)) : =>(<span id="Variable308_T*"><i class="var">T<sup class="sup">*</sup></i></span>)
<i class="keyword">Rule</i>
<span class="name"><a href="#Name_tuple-elements">tuple-elements</a></span>(<span class="name"><a href="#Name_tuple">tuple</a></span>(<span id="Variable324_V*"><i class="var">V<sup class="sup">*</sup></i></span>:<i class="var">T<sup class="sup">*</sup></i>)) ~> <a href="#Variable324_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_tuple-zip">tuple-zip</span></span>(_:<span class="name"><a href="#Name_tuples">tuples</a></span>(<span class="name"><a href="../../Value-Types/index.html#Name_values">values</a></span><sup class="sup">*</sup>), _:<span class="name"><a href="#Name_tuples">tuples</a></span>(<span class="name"><a href="../../Value-Types/index.html#Name_values">values</a></span><sup class="sup">*</sup>)) : =>(<span class="name"><a href="#Name_tuples">tuples</a></span>(<span class="name"><a href="../../Value-Types/index.html#Name_values">values</a></span>,<span class="name"><a href="../../Value-Types/index.html#Name_values">values</a></span>))<sup class="sup">*</sup></code></pre></div>
<code><span class="name"><a href="#Name_tuple-zip">tuple-zip</a></span>(<i class="var">TV<sub class="sub">1</sub></i>, <i class="var">TV<sub class="sub">2</sub></i>)</code> takes two tuples, and returns the sequence of pairs of
their elements, provided that they have the same length. If they have
different lengths, the last elements of the longer sequence are ignored.
<div class="highlighter-rouge"><pre class="highlight"><code><i class="keyword">Rule</i>
<span class="name"><a href="#Name_tuple-zip">tuple-zip</a></span>(<span class="name"><a href="#Name_tuple">tuple</a></span>(<span id="Variable458_V1"><i class="var">V<sub class="sub">1</sub></i></span>:<i class="var">T<sub class="sub">1</sub></i>, <span id="Variable472_V1*"><i class="var">V<sub class="sub">1</sub><sup class="sup">*</sup></i></span>:<i class="var">T<sub class="sub">1</sub><sup class="sup">*</sup></i>), <span class="name"><a href="#Name_tuple">tuple</a></span>(<span id="Variable494_V2"><i class="var">V<sub class="sub">2</sub></i></span>:<i class="var">T<sub class="sub">2</sub></i>, <span id="Variable508_V2*"><i class="var">V<sub class="sub">2</sub><sup class="sup">*</sup></i></span>:<i class="var">T<sub class="sub">2</sub><sup class="sup">*</sup></i>))
~> (<span class="name"><a href="#Name_tuple">tuple</a></span>(<a href="#Variable458_V1"><i class="var">V<sub class="sub">1</sub></i></a>, <a href="#Variable494_V2"><i class="var">V<sub class="sub">2</sub></i></a>), <span class="name"><a href="#Name_tuple-zip">tuple-zip</a></span>(<span class="name"><a href="#Name_tuple">tuple</a></span>(<a href="#Variable472_V1*"><i class="var">V<sub class="sub">1</sub><sup class="sup">*</sup></i></a>), <span class="name"><a href="#Name_tuple">tuple</a></span>(<a href="#Variable508_V2*"><i class="var">V<sub class="sub">2</sub><sup class="sup">*</sup></i></a>)))
<i class="keyword">Rule</i>
<span class="name"><a href="#Name_tuple-zip">tuple-zip</a></span>(<span class="name"><a href="#Name_tuple">tuple</a></span>( ), <span class="name"><a href="#Name_tuple">tuple</a></span>( )) ~> ( )
<i class="keyword">Rule</i>
<span class="name"><a href="#Name_tuple-zip">tuple-zip</a></span>(<span class="name"><a href="#Name_tuple">tuple</a></span>(<span id="Variable631_V1+"><i class="var">V<sub class="sub">1</sub><sup class="sup">+</sup></i></span>:<i class="var">T<sub class="sub">1</sub><sup class="sup">+</sup></i>), <span class="name"><a href="#Name_tuple">tuple</a></span>( )) ~> ( )
<i class="keyword">Rule</i>
<span class="name"><a href="#Name_tuple-zip">tuple-zip</a></span>(<span class="name"><a href="#Name_tuple">tuple</a></span>( ), <span class="name"><a href="#Name_tuple">tuple</a></span>(<span id="Variable680_V2+"><i class="var">V<sub class="sub">2</sub><sup class="sup">+</sup></i></span>:<i class="var">T<sub class="sub">2</sub><sup class="sup">+</sup></i>)) ~> ( )</code></pre></div>
____
From the [PLanCompS Project] | [CBS-beta issues...] | [Suggest an improvement...]
[Tuples.cbs]: Tuples.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/Tuples/Tuples.cbs%0A%0AComment/Query/Issue/Suggestion%3A%0A%0A%0ASignature%3A%0A
"GENERATE AN EMAIL TEMPLATE"

18
IBAF-cbs/Funcons-beta/Values/Composite/Tuples/tests/tuple-zip.config Normal file
View File

@@ -0,0 +1,18 @@
general {
funcon-term: sequential (
check-true(is-equal(tuple tuple-zip(tuple( ),tuple( )), tuple( )))
, check-true(is-equal(tuple tuple-zip(tuple(1),tuple(2)), tuple(tuple(1,2))))
, check-true(is-equal(tuple tuple-zip(tuple(1,3),tuple(2,4)),
tuple(tuple(1,2),tuple(3,4))))
, check-true(is-equal(tuple tuple-zip(tuple(1,3,5),tuple(2,4,6)),
tuple(tuple(1,2),tuple(3,4),tuple(5,6))))
, check-true(is-equal(tuple tuple-zip(tuple(1),tuple( )), tuple( )))
, check-true(is-equal(tuple tuple-zip(tuple( ),tuple(1)), tuple( )))
, print "OK"
);
}
tests {
result-term : null-value;
standard-out : ["OK"];
}

32
IBAF-cbs/Funcons-beta/Values/Composite/Variants/Variants.cbs Normal file
View File

@@ -0,0 +1,32 @@
### Variants
[
Datatype variants
Funcon variant
Funcon variant-id
Funcon variant-value
]
Meta-variables
T <: values
Datatype
variants(T) ::= variant(_:identifiers, _:T)
/*
A value of type `variants(T)` is a pair formed from an identifier and
a value of type `T`.
*/
Funcon
variant-id(_:variants(T)) : =>identifiers
Rule
variant-id(variant(I:identifiers, _:T)) ~> I
Funcon
variant-value(_:variants(T)) : =>T
Rule
variant-value(variant(_:identifiers, V:T)) ~> V

67
IBAF-cbs/Funcons-beta/Values/Composite/Variants/index.md Normal file
View File

@@ -0,0 +1,67 @@
---
layout: default
title: "Variants"
parent: Composite
ancestor: Funcons-beta
---
[Funcons-beta] : [Variants.cbs]
-----------------------------
### Variants
<div class="highlighter-rouge"><pre class="highlight"><code>[
<i class="keyword">Datatype</i> <span class="name"><a href="#Name_variants">variants</a></span>
<i class="keyword">Funcon</i> <span class="name"><a href="#Name_variant">variant</a></span>
<i class="keyword">Funcon</i> <span class="name"><a href="#Name_variant-id">variant-id</a></span>
<i class="keyword">Funcon</i> <span class="name"><a href="#Name_variant-value">variant-value</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="../../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_variants">variants</span></span>(<span id="Variable44_T"><i class="var">T</i></span>) ::= <span id="Name_variant">variant</span>(_:<span class="name"><a href="../../../Computations/Normal/Binding/index.html#Name_identifiers">identifiers</a></span>, _:<span id="Variable68_T"><i class="var">T</i></span>)</code></pre></div>
A value of type <code><span class="name"><a href="#Name_variants">variants</a></span>(<i class="var">T</i>)</code> is a pair formed from an identifier and
a value of type <code><i class="var">T</i></code>.
<div class="highlighter-rouge"><pre class="highlight"><code><i class="keyword">Funcon</i>
<span class="name"><span id="Name_variant-id">variant-id</span></span>(_:<span class="name"><a href="#Name_variants">variants</a></span>(<span id="Variable133_T"><i class="var">T</i></span>)) : =><span class="name"><a href="../../../Computations/Normal/Binding/index.html#Name_identifiers">identifiers</a></span>
<i class="keyword">Rule</i>
<span class="name"><a href="#Name_variant-id">variant-id</a></span>(<span class="name"><a href="#Name_variant">variant</a></span>(<span id="Variable160_I"><i class="var">I</i></span>:<span class="name"><a href="../../../Computations/Normal/Binding/index.html#Name_identifiers">identifiers</a></span>, _:<i class="var">T</i>)) ~> <a href="#Variable160_I"><i class="var">I</i></a></code></pre></div>
<div class="highlighter-rouge"><pre class="highlight"><code><i class="keyword">Funcon</i>
<span class="name"><span id="Name_variant-value">variant-value</span></span>(_:<span class="name"><a href="#Name_variants">variants</a></span>(<span id="Variable204_T"><i class="var">T</i></span>)) : =><span id="Variable224_T"><i class="var">T</i></span>
<i class="keyword">Rule</i>
<span class="name"><a href="#Name_variant-value">variant-value</a></span>(<span class="name"><a href="#Name_variant">variant</a></span>(_:<span class="name"><a href="../../../Computations/Normal/Binding/index.html#Name_identifiers">identifiers</a></span>, <span id="Variable241_V"><i class="var">V</i></span>:<i class="var">T</i>)) ~> <a href="#Variable241_V"><i class="var">V</i></a></code></pre></div>
____
From the [PLanCompS Project] | [CBS-beta issues...] | [Suggest an improvement...]
[Variants.cbs]: Variants.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/Variants/Variants.cbs%0A%0AComment/Query/Issue/Suggestion%3A%0A%0A%0ASignature%3A%0A
"GENERATE AN EMAIL TEMPLATE"

21
IBAF-cbs/Funcons-beta/Values/Composite/Vectors/Vectors.cbs Normal file
View File

@@ -0,0 +1,21 @@
### Vectors
[
Datatype vectors
Funcon vector
Funcon vector-elements
]
Meta-variables
T <: values
Datatype
vectors(T) ::= vector(_:(T)*)
Funcon
vector-elements(_:vectors(T)) : =>(T)*
Rule
vector-elements(vector(V*:(T)*)) ~> V*

57
IBAF-cbs/Funcons-beta/Values/Composite/Vectors/index.md Normal file
View File

@@ -0,0 +1,57 @@
---
layout: default
title: "Vectors"
parent: Composite
ancestor: Funcons-beta
---
[Funcons-beta] : [Vectors.cbs]
-----------------------------
### Vectors
<div class="highlighter-rouge"><pre class="highlight"><code>[
<i class="keyword">Datatype</i> <span class="name"><a href="#Name_vectors">vectors</a></span>
<i class="keyword">Funcon</i> <span class="name"><a href="#Name_vector">vector</a></span>
<i class="keyword">Funcon</i> <span class="name"><a href="#Name_vector-elements">vector-elements</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="../../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_vectors">vectors</span></span>(<span id="Variable40_T"><i class="var">T</i></span>) ::= <span id="Name_vector">vector</span>(_:(<span id="Variable56_T"><i class="var">T</i></span>)<sup class="sup">*</sup>)</code></pre></div>
<div class="highlighter-rouge"><pre class="highlight"><code><i class="keyword">Funcon</i>
<span class="name"><span id="Name_vector-elements">vector-elements</span></span>(_:<span class="name"><a href="#Name_vectors">vectors</a></span>(<span id="Variable88_T"><i class="var">T</i></span>)) : =>(<span id="Variable108_T"><i class="var">T</i></span>)<sup class="sup">*</sup>
<i class="keyword">Rule</i>
<span class="name"><a href="#Name_vector-elements">vector-elements</a></span>(<span class="name"><a href="#Name_vector">vector</a></span>(<span id="Variable126_V*"><i class="var">V<sup class="sup">*</sup></i></span>:(<i class="var">T</i>)<sup class="sup">*</sup>)) ~> <a href="#Variable126_V*"><i class="var">V<sup class="sup">*</sup></i></a></code></pre></div>
____
From the [PLanCompS Project] | [CBS-beta issues...] | [Suggest an improvement...]
[Vectors.cbs]: Vectors.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/Vectors/Vectors.cbs%0A%0AComment/Query/Issue/Suggestion%3A%0A%0A%0ASignature%3A%0A
"GENERATE AN EMAIL TEMPLATE"

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

@@ -0,0 +1,21 @@
general {
funcon-term:
initialise-giving finalise-failing
sequential (
print vector(),
print vector(1,2),
print is-in-type(vector(), vectors(integers)),
print is-in-type(vector(1,2), vectors(integers))
)
;
}
tests {
result-term: null-value;
standard-out: [
vector(),
vector(1,2),
true,
true
];
}