Add some docs for constrained deduced parameter/local object types

Author: hsutter

docs/cpp2/common.md

@@ -202,7 +202,7 @@ The operators `.`, `..`, `*`, `&`, `~`, `++`, `--`, `()`, `[]`, `...`, `..=`, an
 
 Postfix notation lets the code read fluidly left-to-right, in the same order in which the operators will be applied, and lets declaration syntax be consistent with usage syntax. For more details, see [Design note: Postfix operators](https://github.com/hsutter/cppfront/wiki/Design-note%3A-Postfix-operators).
 
-> Note: The function call syntax `f(x)` calls a namespace-scope function, or a function object, named `f`. The function call syntax `x.f()` is a unified function call syntax (aka UFCS) that calls a type-scope function in the type of `x` if available, otherwise calls the same as `f(x)`. The function call syntax `x..f()` calls a type-scope function only. For details, see [Design note: UFCS](https://github.com/hsutter/cppfront/wiki/Design-note%3A-UFCS).
+> Note: The function call syntax `f(x)` calls a namespace-scope function only. The function call syntax `x.f()` is a unified function call syntax (aka UFCS) that calls a type-scope function in the type of `x` if available, otherwise calls the same as `f(x)`. The function call syntax `x..f()` calls a type-scope function only. For details, see [Design note: UFCS](https://github.com/hsutter/cppfront/wiki/Design-note%3A-UFCS).
 
 | Unary operator | Cpp2 example | Cpp1 equivalent |
 |---|---|---|
@@ -214,9 +214,9 @@ Postfix notation lets the code read fluidly left-to-right, in the same order in
 | `#!cpp --` | `#!cpp iter--` | `#!cpp --iter` |
 | `(` `)` | `#!cpp f( 1, 2, 3)` | `#!cpp f( 1, 2, 3)` |
 | `[` `]` | `#!cpp vec[123]` | `#!cpp vec[123]` |
-| `...` (half-open range operator) | `#!cpp v.begin()...v.end()` | `#!cpp std::ranges::subrange(v.begin(), v.end())` |
-| `..=` (closed range operator) | `#!cpp 1..=10` | `#!cpp std::views::iota(1, 11)` |
-| `$` (capture operator) | `val$` | _reflection — no Cpp1 equivalent yet_ |
+| `...` | `#!cpp v.begin()...v.end()` | `#!cpp std::ranges::subrange(v.begin(), v.end())` |
+| `..=` | `#!cpp 1..=10` | `#!cpp std::views::iota(1, 11)` |
+| `$` | `val$` | _reflection — no Cpp1 equivalent yet_ |
 
 > Note: The `...` pack expansion syntax is also supported. The above `...` and `..=` are the Cpp2 range operators, which overlap in syntax.
 

docs/cpp2/expressions.md

@@ -11,7 +11,7 @@ A function call like `x.f()` is a unified function call syntax (aka UFCS) call.
 
 An operator notation call like `#!cpp a + b` will call an overloaded operator function if one is available, as usual in C++.
 
-A function call like `x..f()` will consider only member functions.
+A function call like `x..f()` will consider member functions only.
 
 For example:
 
@@ -33,7 +33,7 @@ f: ( v : std::vector<widget> ) = {
 //  safely using string interpolation (instead of type-unsafe format strings)
 hello: (name, height: float) = {
     //  Using UFCS to make direct calls to C functions as if they were members
-    stdout.fprintf( "%s", ("Hello (name)$, your height is (height:.1f)$ inches!\n").c_str() );
+    stdout.fprintf("%s", ("Hi (name)$, your height is (height:.1f)$\"!\n").c_str());
     //  Equivalent using iostreams:
     //        std::cout << "Hello (name)$, your height is (height:.1f)$ inches!\n";
 
@@ -47,9 +47,9 @@ main: () = {
     hello("Polyphemus", 180);
 }
 //  Sample output:
-//      Hello Flimnap, your height is 6.5 inches!
-//      Hello Goliath, your height is 115.0 inches!
-//      Hello Polyphemus, your height is 180.0 inches!
+//      Hi Flimnap, your height is 6.5"!
+//      Hi Goliath, your height is 115.0"!
+//      Hi Polyphemus, your height is 180.0"!
 ```
 
 To explicitly treat an object name passed as an argument as `move` or `out`, write that keyword before the variable name.
@@ -229,7 +229,7 @@ For more examples, see also the examples in the previous two sections on `is` an
 
 For example:
 
-``` cpp title="Using ... and ..= for ranges" hl_lines="4,11"
+``` cpp title="Using ... and ..= for ranges" hl_lines="5 11"
 test: (v: std::vector<std::string>) =
 {
     //  Print strings from "Nonesuch" (if present) onward

docs/cpp2/functions.md

@@ -27,6 +27,17 @@ func: (
 }
 ```
 
+The parameter type can be deduced by writing `_` (the default, so it can be omitted). You can use `is` to declare a type constraint (e.g., a concept) that a deduced type must match, in which case `_` is required. For example:
+
+``` cpp title="Declaring a parameter of constrained deduced type" hl_lines="2 3 6"
+//  ordinary generic function, x's type is deduced
+print: (x: _) = { std::cout << x; }
+print: (x)    = { std::cout << x; } // same, using the _ default
+
+//  number's type is deduced, but must match the std::integral concept
+calc: (number: _ is std::integral) = { /*...*/ }
+```
+
 There are six ways to pass parameters that cover all use cases, that can be written before the parameter name:
 
 | Parameter ***kind*** | "Pass me an `x` I can ______" | Accepts arguments that are | Special semantics | ***kind*** `x: X` Compiles to Cpp1 as |

docs/cpp2/objects.md

@@ -29,6 +29,13 @@ pi: <T: type> T == 3.14159'26535'89793'23846L;
 pi: _ == 3.14159'26535'89793'23846L;    // same, deducing the object's type
 ```
 
+The parameter type can be deduced by writing `_` (the default, so it can be omitted). You can use `is` to declare a type constraint (e.g., a concept) that a deduced type must match, in which case `_` is required. For example:
+
+``` cpp title="Declaring an object of constrained deduced type" hl_lines="2"
+//  number's type is deduced, but must match the std::regular concept
+number: _ is std::regular = some_factory_function();
+```
+
 
 ## <a id="init"></a> Guaranteed initialization