mention the sequence operator

while here document the various way to build a Seq at the
start of the document.

Author: stoned

doc/Type/Seq.pod6

@@ -11,6 +11,19 @@ C<Seq> is born in a state where iterating it will consume the values.
 Calling C<.cache> on a C<Seq> will make it store the generated values
 for later access.
 
+A high-level construct to generate a C<Seq> is L«C<gather/take>|/syntax/gather%20take»,
+as well as many built-in methods like L«C<map>|/routine/map» and
+L«C<grep>|/routine/grep», low-level constructors to create a
+C<Seq> from an iterator or from looping constructs are available too.
+
+A C<Seq> can also be constructed with the
+L«sequence operator C<...>|/language/operators#infix_...» or one of its
+variants.
+
+    my $s = (1...5);
+    say $s;              # OUTPUT: «1 2 3 4 5)␤»
+    say $s.^name;        # OUTPUT: «Seq␤»
+
 Assigning the values of a C<Seq> to an array consumes a C<Seq> that is
 not lazy. Use the C<lazy> statement prefix to avoid a C<Seq> from being
 iterated during the assignment:
@@ -49,9 +62,6 @@ it couldn't throw away old values), so this dies:
     # (you might solve this by adding .cache on usages of the Seq, or
     # by assigning the Seq into an array)»
 
-A high-level construct to generate a C<Seq> is C<gather/take>, as well as many
-built-in methods like C<map> and C<grep>, low-level constructors to create a
-C<Seq> from an iterator or from looping constructs are available too.
 
 B<Caution:> No program should ever assume a C<Seq> may only be iterated once
 even if not cached by the program. Caching is a volatile state exposed to the