index<--

Bee Syntax

Bookmarks:

This article is an overview of fundamenta concepts that are required to grasp before we can explain in details every aspect of Bee syntax. If this overview looks complicated do not warry, you will understend more in next articles.

• Comments
• Expressions
• Keywords
• Operators

Legend:

We use examples and sometimes a simplified version of BNF notation to explain the syntax rules. If you do not know anything about BNF don't warry, here is a short introduction to this weard notation:

• We use suggestive descriptors for language elements,
• We use "::=" to explain a descriptor,
• We use "..." for repetitive sequences of symbols,
• We use notes to explain the semantics,
• Optional keyword is enclosed in square brackets [];

Comments

#!/bin/bee
+------------------------------------------------------------------
| At the beginning of program you can have  several comments,     | 
| to explain how the program works. This notation is preferred.   |
+-----------------------------------------------------------------+

#Section Title

##Rule subtitle 
/** This is a second comment notation used for:
    Notes before a rule begins, or ...
   /* Expression comments */
   /* Debug-code comments */   
*/
rule main():
  ** This is a single line comment
  pass; // end of line comment
  ... 
   
  ** In expression comments use /*...*/  
  print ("comment in expression \n", /*first line*/
         "is working \n",            /*second line*/
         "this is a test \n"         /*last line*/ 
        ); // end of expression
  
return;
*******************************************************************
** This is the old style boxed comment, used for matrix printers **
** In Bee you can add comments/notes at the end of your code     **
*******************************************************************

Expressions

Expressions are created using identifiers, operators, rules and constant literals.

• can use () to establish order of operations,
• can be enumerated using comma separator ","
• can be combined to create more complex expressions,
• have a result that can be assigned to variables,
• have a result that can be printed to console,
• result type is given automatically using logical inference;

Examples

** demo some print statements
10
10 + 10 + 15
"this is a test"

** complex expressions 
(10 > 5) ∨ (2 < 3) 
-b + sqr(b² - 4·a·b)/(2·a)

** enumeration of expressions
(1,2,3)
(1,',',2,',',3)

Naming:

Bee uses diverse identifiers names to data types. It uses ASCII characters and numbers or Unicode symbols. Most predefined data types have a longer name and a code. You can use both to represent a type. Lonf names are synonyms (alias) to the short name.

Eamples:

Z64      // primitive type: long integer
Integer  // same as Z64
Rational // same as Q(50.12)
File     // composite type: text file
List     // composite type: list of values

Subscript:

Bee has support for subscript to make identifiers. This is useful especialy in mathematical formulas for geometry and geography. You can use a limited number of characters offered by Unicode:

x₀ x₁ x₂ x₃ x₄ x₅ x₆ x₇ x₈ x₉ x₁₀
yₐ yₑ yₕ yᵢ yⱼ yₖ yₗ yₘ yₙ yₒ yₚ yᵣ yₛ yₜ yᵤ yᵥ yₓ

Superscript:

Bee has support for exponent using superscript. You can make any numeric exponent or variable exponent. Notice the variable is mapped to normal variables. The limitation is only lowercase variable names can be used as exponents. That makes constants impossible to use as exponents.

x⁺ x⁻ x¹ x² x³ x⁴ x⁵ x⁶ x⁷ x⁸ x⁹ x¹⁰
y° y′ y″ yᵃ yᵇ yᶜ yᵈ yᵉ yᶠ yᵍ yʰ yⁱ yʲ yᵏ 
yᶩ yᵐ yⁿ yᵒ yᵖ yʳ yˢ yᵗ yᵘ yᵛ yʷ yˣ yʸ yᶻ 

Operations:

Bee has support for fractions. Bee is using regular slash "/" for all fractions. You can use superscript for left and subscript for right: These two are equivalent (1/2 = ¹/₂). Unfortunately we can not support fractional power due to lower readability.

¹/₂ ¹/₃ ¹/₄ ¹/₅ ¹/₆ ¹/₇ ¹/₈ ¹/₉  ¹/₁₀ ¹/₁₀₀ 
x⁻¹ = 1/x, x⁻² = 1/x², x⁻³ = 1/x³ ...

Power operations have priority but we have support only for (+, -) no other opperations are possible in exponent. In next expressions, (n-1) is done first before making the power operation.

//equivalent notations
xⁿ⁻¹ = powr(x,n-1)
xˣ⁺¹ = powr(x,n+1)

//supported  notations
x^(¹/₂) = sqrt(x,2)  //Symbol ^ is for power
x^(¹/₃) = sqrt(x,3)  //This will also work

Unicode Identifiers:

In mathematics is very popular notation for angles to use Greek leters. We support in Bee a limited number of Greek letters to make variable names. Also several Kirilik characters are permited.

Λ Γ Δ Ξ Π Σ Φ Ψ Ω α β ɣ δ ζ 
Б Г Д Ж И Л Ф Ц Ч Ш Щ Э Я 
η θ λ μ ν ξ ο π ρ σ ς τ υ φ ω

Lambda expressions

A lambda expressions is a named expression with parameters and specified result type:

Syntax:

** declaration of Lambda expression
make name := λ(param ∈ Type,...) ∈ ResultType => (expression);

** you can define a lambda signature first
type SigName: (Type,...) ∈ Type <: Lambda;
** then you can declare a λ variable
make name ∈ SigName; // Null Expression
** then you can modify assign expression to variable
alter name := λ(param ∈ Type,...) ∈ Type => (expression);

Example:

** define "exp" as Lambda expression
make exp: λ(x,y ∈ Z) ∈ Z => (xʸ);
** use introspection to chek what is "exp"?
print type(exp); // Lambda
** use the lambda expression
make z := 2·exp(2,3); 
print z; // 16

Properties:

Lambda Expressions...

• are similar to mathematical functions;
• are binding external states in context;
• can be used in other expressions;
• can be used as parameter in rules;
• can be created from a rule as a result;
• can be assigned to a variable of type: Lambda

restrictions:

• can have one single result;
• can not be interrupted from execution;
• can not call any rule that is downgraded;
• do not have internal states;
• do not have side-effects;
• do not depend on external states;

result:

• result can be primitive or native type but not a collection;
• result can be temporary and can be used in other expressions;

Lambda signature

** declare a rule signature
type CMP:(Z,Z) ∈ L <: Lambda;
** instantiate 3 Lambda expressions like "CMP"
make gt := (x, y ∈ Z) ∈ L => (x > y);
make lt := (x, y ∈ Z) ∈ L => (x < y);
make eq := (x, y ∈ Z) ∈ L => (x = y);
** define a dictionary of rules
type Dic: {(S(2) : CMP)} <: Hash;
 
** define a hash map of expressions
make dic := {('gt':gt),('lt':lt),('eq':eq)} ∈ Dic;
** call 3 rules in very unusual way
print dic['gt'](3,1); //1
print dic['lt'](3,1); //0
print dic['eq'](3,1); //0

Bee Keywords

Semantic keywords

Definition statements

Next statements are used to declare new elements in a module.

Execution statements

Next keywords are simple statements. These represents actions called imperative statements.

Control statements

Control statements are also known as selection statements.

Transfer statements

These statements execute a jump or make an interruption of current thread.

Operators

 x != y; //equivalent to: ¬(x = y)
 x !≡ y; //equivalent to: ¬(x ≡ y)
 x !∈ y; //equivalent to: ¬(x ∈ y)
 x !≈ y; //equivalent to: ¬(x ≈ y)
 x !~ y; //equivalent to: ¬(x ~ y)

Read next: Structure