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,11 @@
+import ballerina/io;
+
+public function main() {
+    // Byte values ranging from 0 to 255
+    byte b = 255;
+    io:println(b);
+
+    // Byte values can be assigned to int
+    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 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,33 @@
+import ballerina/io;
+
+public function main() {
+    map<string> student = {"name": "John", "age": "25"};
+    map<anydata> student2 = {"name": "John", "age": "25"};
+
+    // The output will be `true` because the values are the same.
+    io:println(student == student2);
+
+    // The output will be `false` because the values are the same.
+    io:println(student != student2);
+
+    // The output will be `false` because the references are different.
+    io:println(student === student2);
+
+    // This assigns the reference of `student` to `student3`.
+    map<string> student3 = student;
+
+    // The output will be `true` because the references are the same.
+    io:println(student3 === student);
+
+    // The output will be `false` because the references are the same.
+    io:println(student3 !== student);
+
+    int a = 1;
+    anydata b = 1;
+
+    // The output will be `true` because the values are the same.
+    io:println(a == b);
+    // Since simple type values do not have a storage identity,
+    // `===` will return `true` because the values are the same.
+    io:println(a === b);
+}

examples/expression-equality/expression_equality.md

@@ -0,0 +1,11 @@
+# Expression equality
+
+In Ballerina, 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 they store. In contrast, the `===` operator checks whether two values share the same storage identity, meaning it compares whether the values reference the same memory location. 
+Values with storage identity, such as structured types like maps and arrays, are stored as references, so `===` can determine if two references point to the same underlying data. For simple types like, such as integers and booleans, which do not have storage identity, `===` behaves the same as `==`.
+
+::: 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,8 @@
+$ bal run expression_equality.bal
+true
+false
+false
+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
       }
     ]
   },
@@ -475,6 +482,13 @@
         "verifyBuild": true,
         "verifyOutput": true,
         "isLearnByExample": true
+      },
+      {
+        "name": "Expression equality",
+        "url": "expression-equality",
+        "verifyBuild": true,
+        "verifyOutput": true,
+        "isLearnByExample": true
       }
     ]
   },

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)