txt: ## say.md
  say
  
  Combined from primary sources listed below.
  
  # [In IO::Handle](#___top "go to top of document")[§](#(IO::Handle)_method_say "direct link")
  
  See primary documentation
  [in context](/type/IO/Handle#method_say)
  for **method say**.
  
  ```raku
  multi method say(IO::Handle:D: **@text --> True)
  ```
  
  This method is identical to [put](/type/IO/Handle#method_put) except that it stringifies its arguments by calling [`.gist`](/routine/gist) instead of [`.Str`](/routine/Str).
  
  Attempting to call this method when the handle is [in binary mode](/type/IO/Handle#method_encoding) will result in [`X::IO::BinaryMode`](/type/X/IO/BinaryMode) exception being thrown.
  
  ```raku
  my $fh = open 'path/to/file', :w;
  $fh.say(Complex.new(3, 4));        # OUTPUT: «3+4i␤»
  $fh.close;
  
  ```
  
  # [In Proc::Async](#___top "go to top of document")[§](#(Proc::Async)_method_say "direct link")
  
  See primary documentation
  [in context](/type/Proc/Async#method_say)
  for **method say**.
  
  ```raku
  method say(Proc::Async:D: $output, :$scheduler = $*SCHEDULER)
  ```
  
  Calls method `gist` on the `$output`, adds a newline, encodes it as UTF-8, and sends it to the standard input stream of the external program, encoding it as UTF-8.
  
  Returns a [`Promise`](/type/Promise) that will be kept once the data has fully landed in the input buffer of the external program.
  
  The `Proc::Async` object must be created for writing (with `Proc::Async.new(:w, $path, @args)`). Otherwise an [`X::Proc::Async::OpenForWriting`](/type/X/Proc/Async/OpenForWriting) exception will the thrown.
  
  `start` must have been called before calling method say, otherwise an [`X::Proc::Async::MustBeStarted`](/type/X/Proc/Async/MustBeStarted) exception is thrown.
  
  # [In Mu](#___top "go to top of document")[§](#(Mu)_method_say "direct link")
  
  See primary documentation
  [in context](/type/Mu#method_say)
  for **method say**.
  
  ```raku
  multi method say()
  ```
  
  Will [`say`](/type/IO/Handle#method_say) to [standard output](/language/variables#index-entry-$*OUT).
  
  ```raku
  say 42;                 # OUTPUT: «42␤»
  ```
  
  What `say` actually does is, thus, deferred to the actual subclass. In [most cases](/routine/say) it calls [`.gist`](/routine/gist) on the object, returning a compact string representation.
  
  In non-sink context, `say` will always return `True`.
  
  ```raku
  say (1,[1,2],"foo",Mu).map: so *.say ;
  # OUTPUT: «1␤[1 2]␤foo␤(Mu)␤(True True True True)␤»
  ```
  
  However, this behavior is just conventional and you shouldn't trust it for your code. It's useful, however, to explain certain behaviors.
  
  `say` is first printing out in `*.say`, but the outermost `say` is printing the `True` values returned by the `so` operation.
  
  # [In Independent routines](#___top "go to top of document")[§](#(Independent_routines)_sub_say "direct link")
  
  See primary documentation
  [in context](/type/independent-routines#sub_say)
  for **sub say**.
  
  ```raku
  multi say(**@args --> True)
  ```
  
  Prints the "gist" of given objects; it will always invoke `.gist` in the case the object is a subclass of [`Str`](/type/Str). Same as [`put`](/type/independent-routines#sub_put), except it uses [`.gist`](/routine/gist) method to obtain string representation of the object; as in the case of `put`, it will also autothread for [`Junction`](/type/Junction)s.
  
  **NOTE:** the [`.gist`](/routine/gist) method of some objects, such as [Lists](/type/List#method_gist), returns only **partial** information about the object (hence the "gist"). If you mean to print textual information, you most likely want to use [`put`](/type/independent-routines#sub_put) instead.
  
  ```raku
  say Range;        # OUTPUT: «(Range)␤»
  say class Foo {}; # OUTPUT: «(Foo)␤»
  say 'I ♥ Raku';   # OUTPUT: «I ♥ Raku␤»
  say 1..Inf;       # OUTPUT: «1..Inf␤»
  ```
  