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": 0,

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)

examples/security-crypto/security_crypto.md

@@ -13,4 +13,4 @@ Run the program by executing the command below.
 ::: out security_crypto.out :::
 
 ## Related links
-- [Binary data](/learn/by-example/binary-data/)
+- [Binary data](/learn/by-example/binary-data/)