Update docs to reflect = function change and @hashable

Author: hsutter

docs/cpp2/common.md

@@ -68,7 +68,7 @@ All lists use `,` commas between list items, and may be enclosed by
 For example:
 
 ``` cpp title="Lists" hl_lines="1 4 6 7"
-print: <T,U> (t: T, u: U) = std::cout << t << u << "\n";
+print: <T,U> (t: T, u: U) = { std::cout << t << u << "\n"; }
 
 main: () = {
     array: std::array = ('A', 'B', 'C');
@@ -89,7 +89,7 @@ An extra comma at the end of the list, before the closing `)` or `>`, is always
 For example:
 
 ``` cpp title="Lists, using optional trailing commas just because we can" hl_lines="1 4 6 7"
-print: <T,U,> (t: T, u: U,) = std::cout << t << u << "\n";
+print: <T,U,> (t: T, u: U,) = { std::cout << t << u << "\n"; }
 
 main: () = {
     array: std::array = ('A', 'B', 'C',);

docs/cpp2/declarations.md

@@ -46,11 +46,11 @@ We can illustrate this in two directions. First, let's start with a full functio
 ``` cpp title="Start with a full function, and successively omit optional parts if unused" hl_lines="1 5 9 13"
 // Full named function
 f:(x: int = init) = { /*...*/ }     // x is a parameter to the function
-f:(x: int = init) = statement;      // same, { } is implicit
+f:(x: int = init) = statement;      // same, except return type is deduced
 
 // Omit name => anonymous function (aka 'lambda')
  :(x: int = init) = { /*...*/ }     // x is a parameter to the function
- :(x: int = init) = statement;      // same, { } is implicit
+ :(x: int = init) = statement;      // same, except return type is deduced
 
 // Omit declaration => local and immediate (aka 'let' in other languages)
   (x: int = init)   { /*...*/ }     // x is a parameter to this
@@ -74,11 +74,11 @@ Conversely, we can start with an ordinary block or statement, and successively b
 
 // Add declaration => treat the code as a callable object
  :(x: int = init) = { /*...*/ }     // x is a parameter to the function
- :(x: int = init) = statement;      // same, { } is implicit
+ :(x: int = init) = statement;      // same, except return type is deduced
 
 // Add name => full named function
 f:(x: int = init) = { /*...*/ }     // x is a parameter to the function
-f:(x: int = init) = statement;      // same, { } is implicit
+f:(x: int = init) = statement;      // same, except return type is deduced
 
 ```
 
@@ -166,7 +166,7 @@ n: namespace
         //  deduced from its body, defined as a single-expression body
         //  (equivalent to '= { return points.ssize(); }' but omitting
         //  syntax where we're using the language defaults)
-        count: (this) = points.ssize();
+        count: (this) -> _ = points.ssize();
 
         //  ...
     }

docs/cpp2/expressions.md

@@ -18,7 +18,7 @@ For example:
 ``` cpp title="Function calls" hl_lines="3 7 11 16 19 20"
 //  Generic function to log something
 //  This calls operator<< using operator notation
-log: (x) = clog << x;
+log: (x) = { clog << x; }
 
 f: ( v : std::vector<widget> ) = {
     //  This calls log() with the result of std::vector::size()

docs/cpp2/functions.md

@@ -113,7 +113,7 @@ For example:
 //  A function returning no value (void)
 increment_in_place: (inout a: i32) -> void = { a++; }
 //  Or, using syntactic defaults, the following has identical meaning:
-increment_in_place: (inout a: i32) = a++;
+increment_in_place: (inout a: i32) = { a++; }
 
 //  A function returning a single value of type i32
 add_one: (a: i32) -> i32 = { return a+1; }
@@ -127,11 +127,11 @@ add: (a, b) -> forward _ = a+b;
 add: (a, b) a+b;
 
 //  A generic function expression returning a single value of deduced type
-vec.std::ranges::sort( :(x:_, y:_) -> _ = { return y<x; } );
+vec.std::ranges::sort( :(x:_, y:_) -> forward _ = { return y<x; } );
 //  Or, using syntactic defaults, the following has identical meaning:
-vec.std::ranges::sort( :(x,y) y<x );
+vec.std::ranges::sort( :(x,y) = y<x );
 //  Both are identical to this, which uses the most verbose possible syntax:
-vec.std::ranges::sort( :<T:type, U:type> (x:T, y:U) -> _ = { return y<x; } );
+vec.std::ranges::sort( :<X:type, Y:type> (x:X, y:Y) -> forward _ = { return y<x; } );
 ```
 
 #### Return parameter lists: Nameable return value(s)
@@ -466,32 +466,32 @@ Next, `in` is the default [parameter kind](#parameters). So we can use that defa
 equals: (a, b) -> _ = { return a == b; }
 ```
 
-We already saw that `{` `}` is the default for a single-line function that returns nothing. Similarly, `{ return` and `}` is the default for a single-line function that returns something:
+We already saw that `{ return` ... `; }` is the default for a single-expression function body that deduces its return type:
 
 ``` cpp title="equals: Identical meaning, now using the { return ... } default body decoration"
 equals: (a, b) -> _ = a == b;
 ```
 
-Next, `#!cpp -> _ =` (deduced return type) is the default for single-expression functions that return something and so can be omitted:
+Next, `#!cpp -> forward _` (fully deduced return type) is the default for single-expression functions that return something, and in this case will have the same meaning as `#!cpp -> _` :
 
 ``` cpp title="equals: Identical meaning, now using the -> _ = default for functions that return something"
-equals: (a, b) a == b;
+equals: (a, b) = a == b;
 ```
 
 Finally, at expression scope (aka "lambda/temporary") functions/objects aren't named, and the trailing `;` is optional:
 
 ``` cpp title="(not) 'equals': Identical meaning, but without a name as an unnamed function at expression scope"
-:(a, b) a == b
+:(a, b) = a == b
 ```
 
 Here are some additional examples of unnamed function expressions:
 
 ``` cpp title="Some more examples of unnamed function expressions"
 std::ranges::for_each( a, :(x) = std::cout << x );
 
-std::ranges::transform( a, b, :(x) x+1 );
+std::ranges::transform( a, std::back_inserter(b), :(x) = x+1 );
 
-where_is = std::ranges::find_if( a, :(x) x == waldo$ );
+where_is = std::ranges::find_if( b, :(x) = x == waldo$ );
 ```
 
 > Note: Cpp2 doesn't have a separate "lambda" syntax; you just use the regular function syntax at expression scope to write an unnamed function, and the syntactic defaults are chosen to make such function expressions convenient to write. And because in Cpp2 every local variable [capture](expressions.md#captures) (for example, `waldo$` above) is written in the body, it doesn't affect the function syntax.

docs/cpp2/metafunctions.md

@@ -157,6 +157,11 @@ A `struct` is a type with only public bases, objects, and functions, with no vir
 - there is a user-written `operator=`
 
 
+#### `hashable`
+
+A `hashable` type provides a `hash: (this) -> size_t` function that performs a memberwise hash of its data members using `std::hash`.
+
+
 ### For polymorphic types (interfaces, base classes)
 
 

docs/cpp2/types.md

@@ -281,6 +281,8 @@ The above is the same as in Cpp1 because most of Cpp2's `#!cpp operator<=>` feat
 if lo <= requested < hi {
     // ... do something ...
 }
+
+//  Equivalent result to: (lo ..< hi).contains( requested )
 ```
 
 For more details, see [P0515R0 "Consistent comparison" section 3.3](https://wg21.link/p0515r0) and [P0893 "Chaining comparisons"](https://wg21.link/p0893).