Update distinct object examples

examples/distinct-object-types/distinct_object_types.bal

@@ -1,30 +1,53 @@
 import ballerina/io;
 
-// The `Person` object type that contains a string field called `name`.
-type Person distinct object {
+// DistinctPerson is a proper subtype of Person
+class Person {
     public string name;
+
+    function init(string name) {
+        self.name = name;
+    }
 };
 
-// The `Engineer` and `Manager` classes are structurally the same but introducing the
-// `distinct` keyword distinguishes them by considering them as nominal types.
-distinct class Engineer {
-    *Person;
+distinct class DistinctPerson {
+    public string name;
 
     function init(string name) {
         self.name = name;
     }
 }
 
-distinct class Manager {
-    *Person;
+// SomeWhatDistinctPerson is a subtype of DistinctPerson since inherit the same type ID via inclusion
+class SomeWhatDistinctPerson {
+    *DistinctPerson;
+    public string name;
+
+    function init(string name) {
+        self.name = name;
+    }
+}
+
+// EvenMoreDistinctPerson is a proper subtype of DistinctPerson since it has a additional type ID
+distinct class EvenMoreDistinctPerson {
+    *DistinctPerson;
+    public string name;
 
     function init(string name) {
         self.name = name;
     }
 }
 
 public function main() {
-    Person person = new Engineer("Alice");
-    // The `is` operator can be used to distinguish distinct subtypes.
-    io:println(person is Engineer ? "Engineer" : "Manager");
+    Person person = new ("person");
+    io:println(person is DistinctPerson);
+    DistinctPerson distinctPerson = new ("distinctPerson");
+    io:println(distinctPerson is Person);
+
+    SomeWhatDistinctPerson someWhatDistinctPerson = new ("someWhatDistinctPerson");
+    io:println(someWhatDistinctPerson is DistinctPerson);
+    io:println(distinctPerson is SomeWhatDistinctPerson);
+
+    EvenMoreDistinctPerson evenMoreDistinctPerson = new ("evenMoreDistinctPerson");
+    io:println(evenMoreDistinctPerson is DistinctPerson);
+    io:println(distinctPerson is EvenMoreDistinctPerson);
 }

examples/distinct-object-types/distinct_object_types.md

@@ -1,8 +1,7 @@
 # Distinct object types
+For more explicit control over object type relations you can use `distinct` object types. Each distinct object type declaration has a unique type ID. When you include a distinct object type within another object type declaration, the new type's type ID set will include the type ID of the included type. When checking if a given object type `OSub` is a subtype of a distinct object type `OSuper` there is the additional requirement that `OSub` must contain all the type IDs of `OSuper`.
 
-Using the `distinct` keyword in the type definition creates distinct object types. This concept allows defining a type with nominal typing within a structured type system. This is useful when interacting with the external world through API interfaces like `GraphQL`. You may want to leverage nominal typing via this distinct typing feature of Ballerina.
-
-Conceptually, a distinct type including another distinct type results in multiple interface inheritance.
+This way you can achieve the same behavior as a nominal type system within the Ballerina's structured type system, which is useful for things such as GraphQL API interfaces.
 
 ::: code distinct_object_types.bal :::
 

examples/distinct-object-types/distinct_object_types.out

@@ -1,2 +1,7 @@
 $ bal distinct_object_types.bal
-Engineer
+false
+true
+true
+true
+true
+false