Bee Syntax

Comments are very important part of Bee code. We have multiple conventions for making good comments for any project. Bee comments are tailored by architectural principle: "if there are no comments in the code the code is wrong."

Example:

In next example we are using various comments into a demo program.

#!/bin/bee
+------------------------------------------------------------------
| At the beginning of program you can have  several comments,     |
| to explain how the program works. This notation is preferred.   |
+-----------------------------------------------------------------+
rule main:
  continue; -- this statement does nothing

  ** this is a single line comment
  print ("end of line comments",    -- first argument
         "can be used to explain",  -- second argument
         "diverse arguments"        -- third argument
        );
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     **
*******************************************************************

Title comment

For single line title comments we use one "#" symbol. This can be used in combination with "!" to create "shebang" comment known in scripting languages on Linux to specify interpreter location. You can use two "##" for subtitles for large code sections.

Single line

For single line comments we use two stars like this: "**";

• This comment can be extended to multiple stars to create a separator,
• You can use single line comment at beginning of new line,
• You can use two spaces to indent the comment and align with the code.

End of line

Before new line of code: (EOL) you can use comments starting with: "-- "

• notice one line may be or not a full statement. the end of statement is not (EOL),
• you can use "-- " in the middle of an expression, if expression is on multiple lines,
• you can have multiple statements separated by ";" in a line but only one comment.

Box comment

Bee has a specific notation for block comments not used in any other language so far. It is a multi-line comment starting with "+-" and end with "-+". The upper right corner is missing. I guess you will notice this defect later. However you can use old-style C comments.

Notes:

• Bee comments are inspired from Ada language and Wiki markdown
• Bee comments are designed for better syntax coloring

Bee is an expressive language but it's core has about 72 reserved keywords so far:

Notes:

• You can not use these keywords as identifiers;
• Some of these keywords are reserved but not implemented;
• New keywords are going to be created for new features;

Statements can start with imperative keyword or a declarative keyword:

Examples:

Notes:

• One statement is usually indented 2 space,
• One statement is usually described in a single line,
• Multiple statements on a single line are separated with ";",
• One expression in a statement can extend on multiple lines.

Statements can be contained in blocks of code.

Notes:

• Block ending keyword can be one of: { done, cycle },
• Statements in nested blocks are using indentation.

In Bee, all variables must be declared using an imperative statement. Variables can be dynamic or static and can have a data type. Data type can be custom or pre-defined.

A condition is a logic expression used to control statement execution. For this we use {"if", "else"} keywords at end of statements.

** conditional statement execution
statement if condition;

Note: Previous statement is executed only if the condition is True.

** alternative statement 
  expect condition else statement;

** alternative expression
  expect condition else expression;

Note: Previous statement is executed only if the condition is False.

restrictions:

1. Can not use "if" with set statement;
2. Can not use "if" with new statement;
3. Can not use "if" after done;

Example:

rule main:
  ** generate a random number
  new a := random(Z);

  ** conditional execution
  new b := a;
  let b := -a if a < 0;

  ** print result
  print "|b| = ", a;
return;

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 operations are possible in exponent. In next expressions, (n-1) is done first before making the power operation.

-- equivalent notation
xⁿ⁻¹ = x^(n-1)
xˣ⁺¹ = x^(n+1)

-- equivalent  notation
x^(¹/₂) = √2(x)  
x^(¹/₃) = √3(x) 

Pattern Matching

Instead of ternary operator we use conditional expressions. Conditional expressions enable many choices unlike ternary operator that enable only 2 choices. Conditional expressions are also known as pattern matching expressions.

Syntax:

rule main:
  ** define a local variable
  new var ∈ type;

  ** single condition matching
  let var := (xp1 if cnd1 else xp);

  ** multiple matching with default value
  let var := (xp1 if cnd1, xp2 if cnd2,..., xp);

  ** alternative code alignment
  let var := ( xp1 if cnd1 else
               xp2 if con2 else
               xp3 if cnd3 else
               xp
              );
return;

Example:

rule main:
   new x := '0'; -- symbol
   write "x:"
   read   x;

   new kind := ("digit"  if x ∈ ['0'..'9'] else
                "letter" if x ∈ ['a'..'z'] else
                "unknown");

   print ("x is " + kind); -- expect: "x is digit"
return;

Bee operators are ASCII or Unicode symbols. One operator can be created using one or two characters. This is why Bee language is considered experimental, esoteric & disruptive.

Delimiters

Strings

Single Symbols

Numeric operators

Listed in the order of precedence top down.

Double Symbols

Double symbols is a group of two ASCII symbols considered as one. Some of these symbols have an Unicode equivalent, some do not. When available, Unicode equivalent is preferred choice.

Modifiers

Each modifier is created with pattern "x=" where x is a single symbol:

Relation Operators

Relation operators are used to compare expressions.

negation:

Operator: "!" can be used in combination with other 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)

Collection operators

Logic Operators

Bee is using enumeration symbols: True = 1 and False = 0

The table of truth

p	q	¬ p	p ⊕ q	p ∧ q	p ∨ q
1	1	0	0	1	1
1	0	0	1	0	1
0	1	1	1	0	1
0	0	1	0	0	0

Bitwise operators

Bitwise operators are processing numbers not Boolean values.

Arity = 1

Arity = 2

String operators