[basics/ranges] Improve page

Add basic definition at the top.
Tweak wording.
Add section for array range.
Mention UFCS.
Describe range pipelines.
Show `import` when using new functions for the first time.
Add links.

Author: ntrel

basics/ranges.md

@@ -1,6 +1,9 @@
 # Ranges
 
-If a `foreach` is encountered by the compiler
+A range produces a series of elements (values) of the same type.
+
+If a [`foreach` statement](basics/foreach) is encountered by the compiler
+with an expression recognised as a *range*:
 
 ```
 foreach (element; range)
@@ -15,48 +18,81 @@ it's internally rewritten similar to the following:
 for (auto __rangeCopy = range;
      !__rangeCopy.empty;
      __rangeCopy.popFront())
- {
+{
     auto element = __rangeCopy.front;
     // Loop body...
 }
 ```
 
-Any object which fulfills the following interface is called a **range**
-(or more specific `InputRange`) and is thus a type that can be iterated over:
+The remainder of range behaviour is defined in the standard library.
+
+## Range Interface
+
+Any object which has defined the following methods is called an *input range*
+and is thus a type that can be iterated over:
 
 ```
-    interface InputRange(E)
+    interface InputRange(E)
     {
         bool empty();
         E front();
         void popFront();
     }
 ```
 
+`E` is the element type of the range.
+
+A [dynamic array](basics/arrays) can be a range by importing `std.range`.
+This module defines range primitives on arrays, which can be called by
+[UFCS](gems/uniform-function-call-syntax-ufcs):
+
+```
+import std.range;
+
+int[] a = [1, 2, 3];
+assert(!a.empty);
+assert(a.front == 1);
+a.popFront();
+assert(a == [2, 3]);
+```
+
 Have a look at the example on the right to inspect the implementation and usage
-of an input range closer.
+of a custom input range.
 
 ## Laziness
 
 Ranges are __lazy__. They won't be evaluated until requested.
-Hence, a range from an infinite range can be taken:
+Hence, a range can produce infinite elements.
+
+Below a range is created by calling `repeat`, which produces infinite
+elements, each the same as its initial argument. That range is
+processed by `take`, which will select the first N elements.
+Range functions are often called in a 'pipeline' style using
+[UFCS](gems/uniform-function-call-syntax-ufcs) chains:
 
 ```d
+import std.range;
+
 42.repeat.take(3).writeln; // [42, 42, 42]
 ```
 
 ## Value vs. Reference types
 
-If the range object is a value type, then range will be copied and only the copy
-will be consumed:
+If the range object is a [value type](basis/structs), then the range will be
+copied when passing it as a value parameter to a function, and only the copy
+will be consumed.
+
+Below `iota` produces a struct value instance, and `drop` accepts it by value:
 
 ```d
+import std.range;
+
 auto r = 5.iota;
 r.drop(5).writeln; // []
 r.writeln; // [0, 1, 2, 3, 4]
 ```
 
-If the range object is a reference type (e.g. `class` or [`std.range.refRange`](https://dlang.org/phobos/std_range.html#refRange)),
+If the range object is a reference type (e.g. [`class`](basics/classes) or [`std.range.refRange`](https://dlang.org/phobos/std_range.html#refRange)),
 then the range will be consumed and won't be reset:
 
 ```d