start "objects" language documentation

Author: moritz

lib/objects.pod

@@ -0,0 +1,89 @@
+=begin pod
+
+=TITLE Object Orientation in Perl 6
+
+Perl 6 is an object oriented language at its core, even though it
+allows you to write programs in other programming styles.
+
+Perl 6 comes with a wealth of predefined types, which can be classified
+in two categories: normal and I<native> types.
+
+Native types are used for low-level types (like C<uint64>). They do not
+have the same capabilities as objects, though if you call methods on them,
+they are I<boxed> into normal objects.
+
+Everything that you can store in a variable is either a native value, or an
+object. That includes literals, types (type objects), code and containers.
+
+=head1 Using Objects
+
+You can use objects by calling methods on them. To call a method on an
+expression, add a dot, followed by the method name, optionally followed by
+its argument list in round parenthesis (note that no whitespace is allowed
+between the method name and the argument list):
+
+    say "abc".uc;                   
+    #        ^^^ method call without arguments
+    my @words = $string.comb(/\w+/);
+    #                  ^^^^^^^^^^^^ method call with one argument
+
+Another method call syntax separates the method name and the argument list
+with a colon:
+
+    say @*INC.join: ':';
+    
+Many operations that don't look like method calls (for example smart
+matching, interpolating an object into a string) results in method
+calls under the hood.
+
+Methods can return mutable containers, in which case you can assign
+to the return value of a method call.
+
+    $*IN.input-line-separator = "\r\n";
+
+All objects support the methods from class L<Mu>, which is the root
+of the type hierarchy.
+
+=head2 Type Objects
+
+Types themselves are objects, and you can get the I<type object> simply
+by writing its name:
+
+    my $int-type-obj = Int;
+
+You can ask any object for its type object by calling the C<WHAT> method
+(which is actually a macro in method form):
+
+    my $int-type-obj = 1.WHAT;
+
+Type objects (other than C<Mu>) can be compared for equality with the
+C<===> identity operator:
+
+    sub f(Int $x) {
+        if $x.WHAT == Int {
+            say 'you passed an Int';
+        }
+        else {
+            say 'you passed a subtype of Int';
+        }
+    }
+
+Subtype checking is done by smart-matching:
+
+    if $type ~~ Real {
+        say '$type contains Real or a subtype thereof';
+    }
+
+=head1 Classes
+
+TODO: attributes, methods, object construction, inheritance
+
+=head1 Roles
+
+TODO: basics, conflicts, parameterized, difference between classes and roles
+
+=head1 Meta-Object Programming and Introspection
+
+TODO: everything :-)
+
+=end pod