Data-oriented programming with Ballerina

import ballerina/io;

type Circle record {|
   float radius;
|};

type Rectangle record {|
   float width;
   float height;
|};

type Shape Circle|Rectangle;

function calculateArea (Shape shape) returns float {
   if shape is Circle {
       return float:PI * shape.radius * shape.radius;
   }
   return shape.width * shape.height;
};

public function main() {
   io:println(calculateArea({radius: 10}));
}

import ballerina/io;

// closed record
type PersonalDetails record {|
    string name;
    int age;
|};

// open record
type EmployeeDetails record {
    string designation;
    float salary;
};

public function main() {
    // Create a new employee record with closed fields
    PersonalDetails personalDetails = {name: "John Doe", age: 30};

    // Access and modify closed record fields using dot notation
    personalDetails.name = "Jane Smith";
    personalDetails.age = personalDetails.age + 1;

    // Create a new employee record with open and closed fields
    EmployeeDetails employeeInfo = {designation: "n/a", salary: 3000.0, ...personalDetails};

    // Access and modify open record fields using dot notation
    employeeInfo.designation = "Software Engineer";
    employeeInfo.salary = 5000.0;

    // Access and modify record fields using bracket notation
    employeeInfo["name"] = "John Smith";

    // Add a new field to the employee record
    employeeInfo["address"] = "123 Main St";

    // Print the updated employee information
    io:println(personalDetails);
    io:println(employeeInfo);
}

import ballerina/io;

const switchStatus = "ON";

function matchValue(anydata value, boolean isObstructed,
                float powerPercentage) returns string {
    // The value of the `val` variable is matched against the given value match patterns.
    match value {
        1 if !isObstructed => {
            // This block will execute if `value` is 1 and `isObstructed` is false.
            return "Move forward";
        }
        // `|` is used to match more than one value.
        2|3 => {
            // This block will execute if `value` is either 2 or 3.
            return "Turn";
        }
        4 if 25.0 < powerPercentage => {
            // This block will execute if `value` is 4 and `25.0 < powerPercentage` is true.
            return "Increase speed";
        }
        "STOP" => {
            // This block will execute if `value` is "STOP".
            return "STOP";
        }
        switchStatus => {
            // This block will execute if `value` is equal 
            // to the value of the `switchStatus` constant.
            return "Switch ON";
        }
        // Destructuring a tuple with type checking
        [var x, var y] if x is decimal && y is decimal => {
            return string `Maneuvering to x: ${x.toString()} and y: ${y.toString()
                            } coordinates`;
        }
        // Destructuring a map and recursively matching with optional argument
        {x: var a, y: var b, ...var rest} => {
            string optionalArg = matchValue(rest, isObstructed, powerPercentage);
            return string `Maneuvering to x: ${a.toString()} and y: ${b.toString()
                            } coordinates with ${optionalArg}`;
        }
        _ => {
            // This block will execute for any other unmatched value.
            return "Invalid instruction";
        }
    }
}

public function main() {
    string output = matchValue([-2.516d, 51.409d], false, 0.0);
    io:println(output);
}

type Student record {|
    int grade;
    string name;
    map<int> marks;
|};

public function main() {
    Student & readonly student = {
        grade: 12,
        name: "John",
        // The applicable contextually-expected type for marks now is `map<int> & readonly`.
        // Thus, the value for marks will be constructed as an immutable map.
        marks: {
            "Maths": 75,
            "English": 90
        }
    };

    // student.grade = 11; // Compile time error

    // student.marks["Maths"] = 80; // Compile time error
}

import ballerina/io;

type InvoiceItem record {
    string id;
    decimal price;
    boolean taxable;
};

type Customer record {
    string id;
    string name;
};

type Invoice record {
    string id;
    Customer customer;
    InvoiceItem[] items;
};

public function main() returns error?{
    json invoiceData = check io:fileReadJson("./invoice.json");

    // Enjoy lax static typing here!
    // Fails at runtime if the key is not present or the value is not a string.
    string id = check invoiceData.id;
    io:println("Invoice id: ", id);

    // Fails at runtime if the key is not present.
    json items = check invoiceData.items;
    io:println("Invoice items: ", items);

    // Fails at runtime if the convertion is not possible.
    json[] itemArr = check items.cloneWithType();

    // Results in a nil value if the accessed field is not present.
    decimal? discountAmount = check itemArr[1]?.discount?.amount;
    io:println("Discount amount: ", discountAmount);

    // Converts to the domain type.
    // Fails at runtime if the json value does not match the type.
    Invoice invoice = check invoiceData.fromJsonWithType();

    // Enjoy type-safe handling of json values.
    id = invoice.id;
    InvoiceItem[] invoiceItems = invoice.items;
    io:println("Invoice items: ", invoiceItems);
}

import ballerina/io;

// Define a type for tabular data
type Employee record {|
    readonly int id;
    string name;
    readonly string department;
    int salary;
|};

// Create an in-memory table with compound keys
table<Employee> key(id, department) employeeTable = table [
    {id: 1, name: "John Doe", department: "Engineering", salary: 5000},
    {id: 2, name: "Jane Smith", department: "Sales", salary: 4000}
];

public function main() {
    // Add an employee to the table
    employeeTable.add({id: 3, name: "William Smith", department: "Engineering", salary: 4500});

    // Adding duplicate record, throws KeyAlreadyExist error
    // employeeTable.add({id: 2, name: "Jane Smith", department: "Sales", salary: 5000});

    // Putting duplicate record, overrides the existing value
    employeeTable.put({id: 2, name: "Jane Smith", department: "Sales", salary: 5000});

    // Retrieve an employee using the compound key
    Employee? employee = employeeTable[1, "Engineering"];
    if (employee is Employee) {
        io:println("Employee Found: " + employee.name);
    } else {
        io:println("Employee Not Found");
    }

    // Calculate the total salary in the Engineering department
    int totalSalary = from var {department, salary} in employeeTable
        where department == "Engineering"
        collect int:sum(salary);
    io:println(string `Total Salary in Engineering Department: ${totalSalary}`);
}