Add BBE for byte and expression equality

examples/binary-data/binary_data.md

@@ -8,6 +8,5 @@ Binary data is represented by arrays of byte values. It is a special syntax for
 
 ## Related links
 - [Arrays](/learn/by-example/arrays)
+- [Byte type](/learn/by-example/byte-type)
 - [Integers](/learn/by-example/integers)
-
-[comment]: # (Add byte type BBE link)

examples/byte-type/byte_type.bal

@@ -0,0 +1,12 @@
+import ballerina/io;
+
+public function main() {
+    // The `byte` type consists of integers ranging from `0` to `255`.
+    byte b = 255;
+    io:println(b);
+
+    // Since the set of possible `byte` values is a subset of `int` values,
+    // the `byte` type is a subtype of the `int` type.
+    int i = b;
+    io:println(i);
+}

examples/byte-type/byte_type.md

@@ -0,0 +1,7 @@
+# Byte type
+
+The byte type in Ballerina represents an 8-bit unsigned integer, with values ranging from 0 to 255.
+
+::: code byte_type.bal :::
+
+::: out byte_type.out :::

examples/byte-type/byte_type.metatags

@@ -0,0 +1,2 @@
+description: This BBE introduces the Ballerina byte type.
+keywords:  ballerina, ballerina by example, bbe, bytes, byte, byte type

examples/byte-type/byte_type.out

@@ -0,0 +1,3 @@
+$ bal run byte_type.bal
+255
+255

examples/expression-equality/expression_equality.bal

@@ -0,0 +1,51 @@
+import ballerina/io;
+
+public function main() {
+    map<string> student = {"name": "John", "age": "25"};
+    map<anydata> student2 = {"name": "John", "age": "25"};
+
+    // The `==` check evaluates to `true` since the values are considered equal based on the
+    // equality of members.
+    io:println(student == student2);
+
+    // The `!=` check evaluates to `false` since the values are considered equal based on the
+    // equality of members.
+    io:println(student != student2);
+
+    // The `===` check evaluates to `false` since references are different.
+    io:println(student === student2);
+
+    // Assign the value assigned to the `student` variable to the `student3` variable.
+    map<string> student3 = student;
+
+    // The `===` check evaluates to `true` since references are same.
+    io:println(student3 === student);
+
+    // The `!==` check evaluates to `false` since references are same.
+    io:println(student3 !== student);
+
+    // Since values of simple types do not have storage identity 
+    // `===` and `==` return the same result, except for floating point values.
+    int a = 1;
+    anydata b = 1;
+
+    // The `==` and `===` checks evaluates to `true` since the values are equal.
+    io:println(a == b);
+    io:println(a === b);
+
+    decimal c = 1.0;
+    decimal d = 1.00;
+
+    // The `==` check evaluates to `true` since the values are equal.
+    io:println(c == d);
+    // The `===` check evaluates to `false` since `c` and `d` are distinct values with different precision.
+    io:println(c === d);
+
+    string s1 = "Hello";
+    string s2 = "Hello";
+
+    // String values also do not have storage identity, and `===` checks are
+    // the same as `==` checks for string values also.
+    io:println(s1 == s2);
+    io:println(s1 === s2);
+}

examples/expression-equality/expression_equality.md

@@ -0,0 +1,12 @@
+# Expression equality
+
+Expression equality is determined using two operators: `==` for value equality and `===` for reference equality. The `==` operator checks for deep equality between two values by comparing the actual data. In contrast, the `===` operator checks whether two values share the same storage identity, meaning it checks if the values reference the same memory location. 
+
+Values with storage identity, such as structured types like maps and arrays, have an identity that comes from the location where the value is stored. For such values, the `===` check determines if two references point to the same location. For simple types such as integers and booleans, which do not have storage identity, `===` behaves the same as `==` except for floating point values.
+
+::: code expression_equality.bal :::
+
+::: out expression_equality.out :::
+
+## Related links
+- [Maps](/learn/by-example/maps)

examples/expression-equality/expression_equality.metatags

@@ -0,0 +1,2 @@
+description: This BBE demonstrates expression equality checks in Ballerina.
+keywords: ballerina, ballerina by example, bbe, ==, !=, ===, !==, equality

examples/expression-equality/expression_equality.out

@@ -0,0 +1,12 @@
+$ bal run expression_equality.bal
+true
+false
+false
+true
+false
+true
+true
+true
+false
+true
+true

examples/index.json

@@ -103,6 +103,13 @@
         "verifyBuild": true,
         "verifyOutput": true,
         "isLearnByExample": true
+      },
+      {
+        "name": "Byte type",
+        "url": "byte-type",
+        "verifyBuild": true,
+        "verifyOutput": true,
+        "isLearnByExample": true
       }
     ]
   },
@@ -415,6 +422,20 @@
       }
     ]
   },
+  {
+    "title": "Equality",
+    "column": 0,
+    "category": "Language concepts",
+    "samples": [ 
+      {
+        "name": "Expression equality",
+        "url": "expression-equality",
+        "verifyBuild": true,
+        "verifyOutput": true,
+        "isLearnByExample": true
+      }
+    ]
+  },
   {
     "title": "Lists",
     "column": 1,

examples/list-equality/list_equality.md

@@ -9,6 +9,5 @@ You can use `==` and `!=` on lists to check the deep equality of two lists: two
 ## Related links
 - [Tuples](/learn/by-example/tuples)
 - [Arrays](/learn/by-example/arrays)
+- [Expression equality](/learn/by-example/expression-equality)
 - [List sub typing](/learn/by-example/list-subtyping)
-
-[comment]: # (Add equality expression link)