more FAQ clarifications

Author: TimToady

doc/Language/faq.pod

@@ -287,11 +287,13 @@ There are several reasons:
 
 =item they make it easy to interpolate variables into strings
 
-=item they form micro-namespaces for different variables, thus avoiding name clashes
+=item they form micro-namespaces for different variables and twigils, thus avoiding name clashes
 
 =item they allow easy single/plural distinction
 
-=item many natural languages use mandatory noun markers, so our brains are built to handle it
+=item they work like natural languages that use mandatory noun markers, so our brains are built to handle it
+
+=item they aren't mandatory, since you can declare sigilless names (if you don't mind the ambiguity)
 
 
 =head2 Does Perl 6 have coroutines? What about C<yield>?
@@ -309,7 +311,7 @@ routines that return lazy lists:
 
     # second method, use .map or similar method
     # on a lazy list
-    my @squares = (1..*).map(-> $x { $x * $x });
+    my @squares = (1..*).map(-> \x { x² });
 
 =head2 Why can't I initialize private attributes from the new method, and how can I fix this?
 
@@ -345,6 +347,10 @@ for more details) with all the named arguments that the user passes to the
 constructor. C<:$!x> is a named parameter with name C<x>, and when called
 with a named argument of name C<x>, its value is bound to the attribute C<$!x>.
 
+But don't do that.  If the name is public, there is no downside to
+declaring it that way with C<$.x> since the external view is readonly
+by default, and you can still access it internally with C<$!x>.
+
 =head2 How and why do C<say> and C<print> differ?
 
 The most obvious difference is that C<say> appends a newline at the
@@ -370,6 +376,7 @@ nothing in that value except the type).
 
 So C<say> is optimized for debugging and display to people, C<print>
 is more suitable for producing output for other programs to consume.
+(Use C<put> if you want C<print> semantics with a newline.)
 
 =head2 What's the difference between C<token> and C<rule> ?
 
@@ -392,15 +399,15 @@ C<regex> declares a plain regex without any implied modifiers.
 
 C<die> throws an exception.
 
-If C<use fatal;> (which is dynamically scoped) is in scope, C<fail> also
-throws an exception. Otherwise it returns a C<Failure> from the routine
-it is called from.
+C<fail> returns a C<Failure> object.  (If the caller has declared C<use fatal;>
+in the calling lexical scope, C<fail> instead throws an exception
+instead of returning.)
 
-A C<Failure> is an "unthrown" or "soft" exception. It is an object that
-contains the exception, and throws the exception when the Failure is used
-as an ordinary object.
+A C<Failure> is an "unthrown" or "lazy" exception. It is an object that
+contains the exception, and throws the exception if you try to use the C<Failure>
+as an ordinary object, or ignore it in sink context.
 
-A Failure returns False from a C<defined> check, and you can extract
+A C<Failure> returns C<False> from a C<defined> check, and you can extract
 the exception with the C<exception> method.
 
 =head2 Why is C<wantarray> or C<want> gone? Can I return different things in different contexts?