Change list -> sequence, expression list -> value sequence

Also fix tupleof: it's a symbol sequence, not a value sequence.

Author: ntrel

articles/ctarguments.dd

@@ -6,17 +6,17 @@ $(HEADERNAV_TOC)
 
     $(H2 $(LNAME2 Background, Background))
 
-    $(P Compile-time lists are an important metaprogramming concept that comes naturally
+    $(P Compile-time sequences are an important metaprogramming concept that comes naturally
         from D support for $(LINK2 variadic-function-templates.html, variadic templates). They
-        allow a programmer to operate on types, symbols and expressions, enabling the ability to define
-        compile-time algorithms that operate on types, symbols and expressions.
+        allow a programmer to operate on types, symbols and values, enabling the ability to define
+        compile-time algorithms that operate on types, symbols and values.
     )
 
-    $(P $(B Note:) For historical reasons these lists can sometimes be called tuples in documentation or compiler
+    $(P $(B Note:) For historical reasons these sequences can sometimes be called tuples in documentation or compiler
         internals, but don't get confused - they don't have much in common with tuples that
         commonly exist in other languages. Sequences of values of different types that can be
         returned from functions are provided by $(PHOBOS typecons, .Tuple, std.typecons.Tuple).
-        Using term "tuple" to mean compile-time lists is discouraged to avoid confusion, and if encountered
+        Using term "tuple" to mean compile-time sequences is discouraged to avoid confusion, and if encountered
         should result in a $(LINK2 https://issues.dlang.org, documentation bug report).
     )
 
@@ -29,7 +29,7 @@ $(HEADERNAV_TOC)
     $(P `T` here is a $(DDSUBLINK spec/template, variadic-templates, TemplateParameterSequence),
         which is a core language feature. It has its own special semantics,
         and, from the programmer's point of view, is most similar to an array of compile-time entities - types,
-        symbols (names) and expressions (values). One can check the length of this list
+        symbols (names) and values. One can check the length of this sequence
         and access any individual element:
     )
 
@@ -49,7 +49,7 @@ $(HEADERNAV_TOC)
 
     $(H2 $(LNAME2 AliasSeq, AliasSeq))
 
-    $(P The language itself does not provide any means to define such lists outside of
+    $(P The language itself does not provide any means to define such sequences outside of
         a template parameter declaration. Instead, there is a
         $(MREF_ALTTEXT simple utility, std, meta) provided by the standard
         library:
@@ -59,7 +59,7 @@ $(HEADERNAV_TOC)
     alias AliasSeq(T...) = T;
     ---
 
-    $(P All it does is give a specific variadic argument list an externally accessible name so
+    $(P All it does is give a specific variadic argument sequence an externally accessible name so
         that it can be worked with in any other context:
     )
 
@@ -69,7 +69,7 @@ $(HEADERNAV_TOC)
     alias Name = AliasSeq!(int, 42);
     pragma(msg, Name[0]);   // int
     pragma(msg, Name[1]);   // 42
-    // or work with a list directly
+    // or work with a sequence directly
     pragma(msg, AliasSeq!("aaa", 0, double)[2]);    // double
     ---
 
@@ -96,27 +96,27 @@ $(H2 $(LNAME2 available-operations, Available operations))
 
     $(H3 $(LNAME2 assignment, Assignment))
 
-        $(P Works only if the list element is a symbol that refers to a mutable variable)
+        $(P Works only if the sequence element is a symbol that refers to a mutable variable)
 
         ---
         import std.meta;
 
         void main()
         {
             int x;
-            alias List = AliasSeq!(10, x);
-            List[1] = 42;
+            alias seq = AliasSeq!(10, x);
+            seq[1] = 42;
             assert (x == 42);
-            // List[0] = 42; // won't compile, can't assign to a constant
+            // seq[0] = 42; // won't compile, can't assign to a constant
         }
         ---
 
     $(H3 $(LNAME2 loops, Loops))
 
         $(P D's $(LINK2 spec/statement.html#ForeachStatement, foreach statement) has special
-            semantics when iterating over compile-time lists. It repeats the body of the loop
-            for each of the list elements, with the loop iteration "variable" becoming an alias
-            for each compile-time list element in turn.
+            semantics when iterating over compile-time sequences. It repeats the body of the loop
+            for each of the sequence elements, with the loop iteration "variable" becoming an alias
+            for each compile-time sequence element in turn.
         )
 
         ---
@@ -146,8 +146,8 @@ $(H2 $(LNAME2 available-operations, Available operations))
 
 $(H2 $(LNAME2 auto-expansion, Auto-expansion))
 
-    $(P One less obvious property of compile-time argument lists is that when used
-        as an argument to a function or template, they are automatically treated as a list
+    $(P One less obvious property of compile-time argument sequences is that when used
+        as an argument to a function or template, they are automatically treated as a sequence
         of comma-separated arguments:
     )
 
@@ -165,29 +165,29 @@ $(H2 $(LNAME2 auto-expansion, Auto-expansion))
     $(P This will only print `int` during compilation because the last line gets rewritten
         as `alias Dummy = Print0!(int, double)`. If auto-expansion didn't happen,
         `AliasSeq!(int, double)` would be printed instead. This is an inherent part of
-        the language semantics for variadic lists, and thus also preserved by `AliasSeq`.
+        the language semantics for variadic sequences, and thus also preserved by `AliasSeq`.
     )
 
-$(H2 $(LNAME2 homogenous-lists, Homogenous lists))
+$(H2 $(LNAME2 homogenous-sequences, Homogenous sequences))
 
-    $(P An $(ALOCAL AliasSeq, AliasSeq) that consists of only type or expression (value) elements are
-        commonly called "type lists" or "expression lists" respectively. The concept of
-        a "symbol list" is rarely mentioned explicitly but fits the same pattern.
+    $(P An $(ALOCAL AliasSeq, AliasSeq) that consists of only type or value elements are
+        commonly called "type sequences" or "value sequences" respectively. The concept of
+        a "symbol sequence" is rarely mentioned explicitly but fits the same pattern.
     )
 
-$(H3 $(LNAME2 type-seq, Type lists))
+$(H3 $(LNAME2 type-seq, Type sequences))
 
-    $(P It is possible to use homogenous type lists in declarations:)
+    $(P It is possible to use homogenous type sequences in declarations:)
 
     ---
     import std.meta;
     alias Params = AliasSeq!(int, double, string);
     void foo(Params); // void foo(int, double, string);
     ---
 
-$(H4 $(LNAME2 type-seq-instantiation, Type list instantiation))
+$(H4 $(LNAME2 type-seq-instantiation, Type sequence instantiation))
 
-    $(P D supports a special variable declaration syntax where a type list acts as a type:)
+    $(P D supports a special variable declaration syntax where a type sequence acts as a type:)
 
     ---
     import std.meta;
@@ -208,38 +208,38 @@ $(H4 $(LNAME2 type-seq-instantiation, Type list instantiation))
     alias variables = AliasSeq!(__var1, __var2, __var3);
     ---
 
-    $(P So a type list instance acts as a symbol list that only aliases
+    $(P So a type sequence instance acts as a symbol sequence that only aliases
     variables.)
 
     $(P $(DDSUBLINK spec/template, variadic-templates, Variadic template functions)
-    use a type list instance for a function parameter:)
+    use a type sequence instance for a function parameter:)
 
     ---
     void foo(T...)(T args)
     {
-        // 'T' is a type list of argument types.
+        // 'T' is a type sequence of argument types.
         // 'args' is an instance of T whose elements are the function parameters
         static assert(is(typeof(args) == T));
         args[0] = T[0].init;
     }
     ---
 
-    $(P $(B Note:) $(PHOBOS typecons, .Tuple, std.typecons.Tuple) wraps a type list instance,
+    $(P $(B Note:) $(PHOBOS typecons, .Tuple, std.typecons.Tuple) wraps a type sequence instance,
     preventing auto-expansion, and allowing it to be returned from functions.)
 
-$(H3 $(LNAME2 value-seq, Expression lists))
+$(H3 $(LNAME2 value-seq, Value sequences))
 
-    $(P It is possible to use expression lists with values of the same type to declare array literals:)
+    $(P It is possible to use value sequences with values of the same type to declare array literals:)
 
     ---
     import std.meta;
     static assert ([ AliasSeq!(1, 2, 3) ] == [ 1, 2, 3 ]);
     ---
 
-$(H4 $(LNAME2 tupleof, Aggregate field lists))
+$(H3 $(LNAME2 symbol-seq, Symbol sequences))
 
     $(P $(DDSUBLINK spec/class, class_properties, `.tupleof`) is a
-    class/struct instance property that provides an expression list
+    class/struct instance property that provides a symbol sequence
     of fields.)
 
 )