Update check expression

examples/check-expression/check_expression.bal

@@ -1,18 +1,46 @@
 import ballerina/io;
 
-// Convert `bytes` to a `string` value and then to an `int` value.
-function intFromBytes(byte[] bytes) returns int|error {
-
-    // Use `check` with an expression that may return `error`.
-    // If `string:fromBytes(bytes)` returns an `error` value, `check`
-    // makes the function return the `error` value here.
-    // If not, the returned `string` value is used as the value of the `str` variable.
+function intFromBytesWithCheck(byte[] bytes) returns int|error {
     string str = check string:fromBytes(bytes);
-
     return int:fromString(str);
 }
 
+// Same as `intFromBytesWithCheck` but with explicit error handling.
+function intFromBytesExplicit(byte[] bytes) returns int|error {
+    string|error res = string:fromBytes(bytes);
+    // Handling the error explicitly.
+    if res is error {
+        return res;
+    }
+    return int:fromString(res);
+}
+
+function intFromBytesWithCheckPanic(byte[] bytes) returns int {
+    string str = checkpanic string:fromBytes(bytes);
+    return checkpanic int:fromString(str);
+}
+
+// Same as intFromBytesWithCheckPanic but with explicit panic statements.
+function intFromByteWithExplictPanic(byte[] bytes) returns int {
+    string|error res = string:fromBytes(bytes);
+    // Panic in case of error explicitly.
+    if res is error {
+        panic res;
+    }
+    int|error val = int:fromString(res);
+    if val is error {
+        panic val;
+    }
+    return val;
+}
+
 public function main() {
-    int|error res = intFromBytes([104, 101, 108, 108, 111]);
-    io:println(res);
+    int|error res1 = intFromBytesWithCheck([104, 101, 108, 108, 111]);
+    io:println(res1);
+    int|error res2 = intFromBytesExplicit([104, 101, 108, 108, 111]);
+    io:println(res2);
+    int|error res3 = trap intFromBytesWithCheckPanic([104, 101, 108, 108, 111]);
+    io:println(res3);
+    int|error res4 = trap intFromByteWithExplictPanic([104, 101, 108, 108, 111]);
+    io:println(res4);
 }

examples/check-expression/check_expression.md

@@ -1,9 +1,12 @@
 # Check expression
 
-`check E` is used with an expression `E` that might result in an `error` value. If `E` results in an `error` value , then, `check` makes the function return that `error` value immediately.
+In Ballerina, it is common to write an expression that may result in an error, such as calling a function that could return an error value, checking if the result belongs to the `error` type and immediately returning that value. You can use the `check` expression to simplify this pattern.
 
-The type of `check E` does not include `error`. The control flow remains explicit.
+Similarly, by the context of your code, you may know that a certain expression should not result in an error, in such cases, you can use `checkpanic` expression to immediately panic if the result is an error.
 
 ::: code check_expression.bal :::
 
-::: out check_expression.out :::
+::: out check_expression.out :::
+
+## Related links
+- [Panics](https://ballerina.io/learn/by-example/panics/)

examples/check-expression/check_expression.out

@@ -1,2 +1,5 @@
 $ bal run check_expression.bal
 error("{ballerina/lang.int}NumberParsingError",message="'string' value 'hello' cannot be converted to 'int'")
+error("{ballerina/lang.int}NumberParsingError",message="'string' value 'hello' cannot be converted to 'int'")
+error("{ballerina/lang.int}NumberParsingError",message="'string' value 'hello' cannot be converted to 'int'")
+error("{ballerina/lang.int}NumberParsingError",message="'string' value 'hello' cannot be converted to 'int'")