Bee Types

These are symbolic representations for primitive data types:

note

• primitive types are ordered and can be compared,
• primitive literals are identical to themselves,
• primitive variables are identical to themselves.

Special types have an alias starting with capital letter. These types are embeded in the language and contribute to language coherence. All these types are actually references to memory structures:

User can define type alias using operators ":" and sub-types using operator "<:" (inheritance). Usr can specify type of variables explicit usin operator ∈

** declare new type alias
type Type_Identifier: type_descriptor <: super_type;

** declare variables using type alias
new var_name ∈ Type_Identifier;

** declare many variables using type alias
new var_name, var_name ... ∈ Type_Identifier;

Notes:

• User defined types are starting with capital letter;
• User defined super-types are usually composite types;
• User defined sub-types are usually domains of values;

A range is a notation that designate a sub-set of consecutive integer numbers between two limits: lower limit and upper limit included in round parenthesis and separated by two dots (..) or (!).

Syntax:

range ::= (min..max);
range ::= (min.!max); -- exclude upper limit
range ::= (min!.max); -- exclude lower limit

Notes:

• Both limits are included in range by default
• Upper or lower limits can be excluded using "!"
• Range notation can be open at one end or both ends
• Open lower limit is symbolic (-) with no number
• Open upper limit is symbolic (+) with no number

Example:

#integer domain
rule main:
  print (0..5); -- 0,1,2,3,4,5
  print (0.!5); -- 0,1,2,3,4
  print (0!.5); -- 1,2,3,4,5

  pass if  32667 ∈ (0..+); -- expect to pass
  pass if -32668 ∈ (-..0); -- expect to pass
return;

Ranges can use symbols that are ASCII or Unicode. In this case the symbols must be included in single quotes: 'X' or use U+ notation:

Example:

** sub-type declarations
type  .Digit:    ('0'..'9')       <: Z;
type  .Capital:  ('A'..'Z')       <: A;
type  .Lowercase:('a'..'z')       <: A;
type  .Latin:    (U+0041..U+FB02) <: U;

rule main:
  ** following statements should pass
  pass if '0' ∈ Digit;
  fail if 'x' ∈ Capital;
  pass if 'X' ∈ Capital;
  pass if 'e' ∈ Latin;
return;

Domain is very similar to range except a domain has a ratio. This is the difference, the numbers are not integers, can be fractional or Q umber.

type Domain: (min..max:ratio)  <: Super_Type;

Examples:

** generate rational numbers
print (0..1:1&\4); -- 0&\4, 1&\4, 2&\4, 3&\4, 1

** generate float numbers
print (0..1:0.25); -- 0.00, 0.25, 0.50, 0.75, 1.00

Variables are defined using type inference and these operators:

Notes:

• Symbol ":" can be used to define a type or set initial value or type for a variable or parameter.
• Symbol ":" can be used as pair-up operator for arguments and map pairs.
• Symbol ":=" can can be used to define or mutate the value of variables or parameters.
• Symbol "<:" used in declarations is used to indicate a supertype,

** primitive variable declarations with type
new var_name ∈  type_name; -- declaration only type without initial value
new var_name: value ∈  type_name; -- declaration with initial value and type

** Variable declaration using type inference
new var_name := expression; -- expression ":=" do not require type hint ("∈").

** Multiple variables can be define in one single line using comma separator:
new var1, var2 ... ∈  TypeName;   -- default initial values
new var1, var2 ... := Expression; -- use type inference for all initial values

** Initialize multiple variables, of the same type (type is required)
new var1:con1, var2:con2 ... ∈ TypeName;

One can modify variables using alter statement.

Example:

#fragment of code

new a:10, b:0 ∈ Z; -- initialize two variables
let b := a + 1;   -- modify b using binding operator :=
let b += 1;       -- modify b using modifier +=
expect b = 12;    -- check if b has proper value

Notes:

• Multiple variables can be modified all at once when separated by comma;
• Following operators are called modifiers and can change value of a variable:
• {":=","::"}
• {"+=","-=","&\=","*=","^=","%=", "*=", "/=", "√="}

Examples:

** declare a public constant
set .PI: 3.14 ∈ R;

rule main:
  ** declare a single variable
  new a   ∈ Z; -- Integer

  ** declare multiple variables
  new (x,y):0 ∈ R; -- Double
  new (q,p):0 ∈ L; -- Logic

  ** using modifiers
  let a := 10; -- modify value of: a == 10
  let a += 1;  -- increment value of: a == 11
  let a -= 1;  -- decrement value of: a == 10

  ** modify two variables using one single constant
  let x, y := 10.5;

  ** modify two variables using two constants
  let q, p := True, False;

  ** swapping two variables
  let p, q := q, p;
return;

When data type mismatch you must perform explicit conversion.

• Explicit conversion is using a symbolic operator: ":>"
• This is unsafe operation. A range check is recommended before conversion;
• Data precision may suffer. Some decimals may be lost;
• If data do not fit in the new type, the overflow exception is raised.

Example:

** data conversion
rule main:
   new a:0, b:20 ∈ Z;
   new v:10.5, x:0.0 ∈ R;
** explicit conversion
   let a:=v :> N;
   print a; -- truncated to 10
** explicit conversion
   let x := b :> R;
   print x; -- expect 20.00
return;

Notes:

• making conversion will copy value not reference
• conversion to same data type is equivalent to copy "::"

Bee define A as single UTF-8 code point with representation: U+HH

rule main:
  new a, b ∈ A; -- ASCII
  new x, y ∈ B; -- Binary integer
  let a :='0';     -- ASCII symbol '0'
  let x := a :> B; -- convert to binary 30
  let y := 30;     -- decimal code for '0'
  let b := y :> A; -- convert to ASCII symbol '0'
return;

You can use symbol ":=" to initialize variables using type inference.

** declare constants
set i := 4;   -- integer constant
set r := 2.5; -- real constant
set q := 1&\8; -- rational constant
** declare variables
new x := 0;   -- integer number
new y := 0.0; -- real number
new z := 0\1; -- rational number

We can use variable type to validate expression type.

** using type inference
rule main:
  new a := 0;   -- integer variable
  new b := 0.0; -- real variable

  let a:= 10.5; -- error: explicit conversion is required
return;

You can use operator "∈" to verify data type:

rule main:
  new a := 0 ∈ Z;

  ** expected: Integer
  expect a ∈ Z;
return;

Logical expression have value { 0 = False, 1 = True }

** define constants based on Boolean values
set f: False;
set t: True;

rule main:
  ** expressions with single operant
  print f; -- 0
  print ¬ t; -- 0

  ** expressions with two operands
  print (f = t); -- 0
  print (f ≡ t); -- 0
  print (f ≠ t); -- 1
  print (f < t); -- 1
  print (f > t); -- 0
  print (f ∧ t); -- 0
  print (f ∨  t); -- 1
  print (f ⊕ t); -- 1
return;

Notes:

• Operators { ¬ } is unary operator;
• Operators { ∧, ∨ } are also bitwise operators;
• Operators { ¬, ⊕ } are also bitwise operators;
• Operators { «, » } are bitwise operators;

coercion Any numeric expression can be converted to a logic value using coercion operator ":>" (easy to memorize if you think is like an arrow).

set (a: 0.0, b: 1.5) ∈ R;
rule main:
  new (x, y) ∈ B;

  let x := a :> B; -- 0
  let y := b :> B; -- 1
return;

Notes:

• Real number is truncated before conversion to Boolean;
• A string: "Yes", "yes", "True", "true", "On","on", "T", "t" or "1" convert to: True = 1
• A string: "No", "no", "False", "false", "Off","off", "F", "f" or "0" convert to: False = 0

design

** logical values are numeric
print True  ≡ 1;  -- 1
print False ≡ 0;  -- 1

** logical values do not compute
print False - True; -- Error
print True  + True; -- Error

** Null value is not True
print Null  ≡ True   -- 0
** Null value is not False
print Null  ≡ False  -- 0

Type inference is a logical deduction of data type from constant literals.

Page bookmarks:

Each literal has associated a default type, induced by operators {":=", "::"}.

** string expressions
new c := 'a'     ;  -- type = A
new s := '∈'    ;  -- type = U
new s := "str"   ;  -- type = S
** numeric expressions
new i := 0;    -- type = Z
new j := 0.50; -- type = R
** define synonyms for logic constants
set f := False; -- type B
set t := True;  -- type B
** multiple variables get same value
new (x, y, z) := 5; -- type = Z for all
** multiple variables get multiple values
new int, rea := -4, 4.44;
print type(int); -- Z
print type(rea); -- R

When we define parameters we can use type inference only for optional parameters. Mandatory parameters must have type declaration using ∈ symbol. If default value is not specified the parameter will have defailt zero initial value.

Optional Parameters:

** in rule foo, parameters a, b are optional.
rule foo(a: 0 ∈ Z, b: 0 ∈ Z) => (r ∈ Z):
  let r := a + b;
rule;

rule main:
  print foo();    -- 0
  print foo(1);   -- 1
  print foo(1,2); -- 3
return;

Multiple parameters:

** parameters: a, b are mandatory, c is optional.
rule foo(a, b, c:0 ∈ Z) => (r ∈ Z):
  let r := a + b + c;
return;

rule main:
  print foo(1,2);   -- 3
  print foo(1,2,3); -- 6
  print foo(1);     -- Error: expected 2 arguments
return;

Pass arguments by name:

We can use parameter name and pair-up symbol ":" for argument value.

** rule with optional parameter (c)
rule bar(a, b, c:0 ∈ Z) => (result ∈ Z):
  let result := a+b+c;
return;
** observe we use pair-up ":" to give value for each argument
rule main:
  print bar( 1, 1 );    -- print 2 because c = 0
  print bar( a:1, b:1, c:1 ); -- print 3 because c = 1
return;  

In mathematics rational number is any number that can be expressed as the fraction p/q of two integer numbers: numerator "p" of type integer and a non-zero denominator "q" of type natural> 0.
Since "q" may be equal to 1, every binary integer is also a rational number.

Note: Q numbers are approximated numbers.

• Default precision for Q numbers is $precision: 10⁻⁵ = 0.00001
• Default precision can be set using: $precision:x; global constant
• Operator "≈" is using the precision if the operator "±" is not used;

Other precision constants:

• $deci := 1d = 10⁻¹
• $centi := 1c = 10⁻²
• $mili := 1m = 10⁻³
• $micro := 1μ = 10⁻⁶

Literal Notation: p\q

It can be used with type inference to create Q numbers:

Example:

new x: 0     ∈ Q; -- 0
new a: 1\2   ∈ Q; -- 0.5
new b: 1\4   ∈ Q; -- 0.25
new c: 1\8   ∈ Q; -- 0.125
new d: 1\16  ∈ Q; -- 0.062
new e: 1\32  ∈ Q; -- 0.031

Note:

• The inch is a unit of length in the British imperial and United States
• It is equal to 1\36 yard or 1\12 of a foot
• One inch is divided in 1\2, 1\4, 1\8, 1\16 and 1\32