Adds complex data structres advances #114

Author: JJ

doc/Language/structures.pod6

@@ -51,9 +51,53 @@ In this case, C<$list> is using the Scalar sigil and thus will be an C<Scalar>.
 
 =head1 Complex data structures
 
-Complex data structures fall in two different broad categories L<Positional|/type/Positional>, or list-like and L<Associative|/type/Associative>, or key-value pair like, according to how you access its first-level elements. In general, complex data structures, including objects, will be a combination of both, with object properties assimilated to key-value pairs.
+Complex data structures fall in two different broad categories
+L<Positional|/type/Positional>, or list-like and
+L<Associative|/type/Associative>, or key-value pair like, according to how you
+access its first-level elements. In general, complex data structures, including
+objects, will be a combination of both, with object properties assimilated to
+key-value pairs. While all objects subclass L<Mu>, in general complex objects are instances of subclasses of L<Any>. While it is theoretically possible to mix in C<Positional> or C<Associative> without doing so, most methods who apply to complex data structures are implemented in C<Any>.
 
+Navigating these complex data structures is a challenge, but Perl 6 provides a couple of functions that can be used on them: L<C<deepmap>|/routine/deepmap> and L<C<duckmap>|/routine/duckmap>. While the former will go to every single element, in order, and do whatever the block passed requires,
 
+    say [[1,2,[3,4]],[[5,6,[7,8]]]].deepmap( *.elems );
+    # OUTPUT: «[[1 1 [1 1]] [1 1 [1 1]]]␤»
+
+which returns 1 because it goes to the deeper level and applies C<elems> to
+them, C<deepmap> can perform more complicated operations:
+
+    say [[1,2,[3,4]],[[5,6,[7,8]]]].duckmap:
+       -> $array where .elems == 2 { $array.elems }
+    # OUTPUT: «[[1 2 2] [5 6 2]]␤»
+
+In this case, it dives into the structure, but returns the element itself if it
+does not meet the condition in the block (C<1,2>), returning the number of
+elements of the array if it does (the two C<2>s at the end of each subarray).
+
+Since C<d(eep|uck)map> are C<Any> methods, they also apply to Associative arrays:
+
+    say %( first => [1,2], second => [3,4]).deepmap( *.elems )
+    # OUTPUT: «{first => [1 1], second => [1 1]}␤»
+
+Only in this case, they will be applied to every list or array that is a value, leaving the keys alone.
+
+C<Positional> and C<Associative> can be turned into each other.
+
+    say %( first => [1,2], second => [3,4]).list[0]# OUTPUT: «second => [3 4]␤»
+
+However, in this case, and for Rakudo >= 2018.05, it will return a different
+value every time you run. A hash will be turned into a list of the key-value
+pairs, but it is guaranteed to be disordered. You can also do the operation in
+the opposite direction, as long as the list has an even number of elements (odd
+number will result in an error):
+
+    say <a b c d>.Hash # OUTPUT: «{a => b, c => d}␤»
+
+But
+
+    say <a b c d>.Hash.kv # OUTPUT: «(c d a b)␤»
+
+will obtain a different value every time you run it; L<C<kv>|/type/Pair#method_kv> turns every C<Pair> into a list.
 
 =head1 Functional structures