txt: ## gist.md
  gist
  
  Combined from primary sources listed below.
  
  # [In Submethod](#___top "go to top of document")[§](#(Submethod)_method_gist "direct link")
  
  See primary documentation
  [in context](/type/Submethod#method_gist)
  for **method gist**.
  
  ```raku
  multi method gist(Submethod:D:)
  ```
  
  Returns the name of the submethod.
  
  # [In Exception](#___top "go to top of document")[§](#(Exception)_method_gist "direct link")
  
  See primary documentation
  [in context](/type/Exception#method_gist)
  for **method gist**.
  
  ```raku
  multi method gist(Exception:D:)
  ```
  
  Returns whatever the exception printer should produce for this exception. The default implementation returns message and backtrace separated by a newline.
  
  ```raku
  my $e = X::AdHoc.new(payload => "This exception is pretty bad");
  try $e.throw;
  if ($!) { say $!.gist; };
  # OUTPUT: «This exception is pretty bad
  #   in block <unit> at <unknown file> line 1␤»
  ```
  
  # [In IO::Handle](#___top "go to top of document")[§](#(IO::Handle)_method_gist "direct link")
  
  See primary documentation
  [in context](/type/IO/Handle#method_gist)
  for **method gist**.
  
  ```raku
  method gist(IO::Handle:D: --> Str:D)
  ```
  
  Returns a string containing information which [`.path`](/type/IO/Handle#method_path), if any, the handle is created for and whether it is [`.opened`](/type/IO/Handle#method_opened).
  
  ```raku
  say IO::Handle.new; # IO::Handle<(Any)>(closed)
  say "foo".IO.open;  # IO::Handle<"foo".IO>(opened)
  
  ```
  
  # [In Mu](#___top "go to top of document")[§](#(Mu)_routine_gist "direct link")
  
  See primary documentation
  [in context](/type/Mu#routine_gist)
  for **routine gist**.
  
  ```raku
  multi        gist(+args --> Str)
  multi method gist(   --> Str)
  ```
  
  Returns a string representation of the invocant, optimized for fast recognition by humans. As such lists will be truncated at 100 elements. Use `.raku` to get all elements.
  
  The default `gist` method in `Mu` re-dispatches to the [raku](/routine/raku) method for defined invocants, and returns the type name in parenthesis for type object invocants. Many built-in classes override the case of instances to something more specific that may truncate output.
  
  `gist` is the method that [say](/routine/say) calls implicitly, so `say $something` and `say $something.gist` generally produce the same output.
  
  ```raku
  say Mu.gist;        # OUTPUT: «(Mu)␤»
  say Mu.new.gist;    # OUTPUT: «Mu.new␤»
  ```
  
  # [In role Blob](#___top "go to top of document")[§](#(role_Blob)_method_gist "direct link")
  
  See primary documentation
  [in context](/type/Blob#method_gist)
  for **method gist**.
  
  ```raku
  method gist(Blob:D: --> Str:D)
  ```
  
  Returns the string containing the "gist" of the `Blob`, **listing up to the first 100** elements, separated by space, appending an ellipsis if the `Blob` has more than 100 elements.
  
  ```raku
  put Blob.new(1, 2, 3).gist; # OUTPUT: «Blob:0x<01 02 03>␤»
  put Blob.new(1..2000).gist;
  # OUTPUT:
  # Blob:0x<01 02 03 04 05 06 07 08 09 0A 0B 0C 0D 0E 0F 10 11 12 13 14 15
  # 16 17 18 19 1A 1B 1C 1D 1E 1F 20 21 22 23 24 25 26 27 28 29 2A 2B 2C
  # 2D 2E 2F 30 31 32 33 34 35 36 37 38 39 3A 3B 3C 3D 3E 3F 40 41 42 43
  # 44 45 46 47 48 49 4A 4B 4C 4D 4E 4F 50 51 52 53 54 55 56 57 58 59 5A
  # 5B 5C 5D 5E 5F 60 61 62 63 64 ...>
  ```
  
  # [In Complex](#___top "go to top of document")[§](#(Complex)_method_gist "direct link")
  
  See primary documentation
  [in context](/type/Complex#method_gist)
  for **method gist**.
  
  ```raku
  method gist(Complex:D: --> Str:D)
  ```
  
  Returns a string representation of the form "1+2i", without internal spaces. (Str coercion also returns this.)
  
  ```raku
  say (1-4i).gist;                # OUTPUT: «1-4i␤»
  ```
  
  # [In Version](#___top "go to top of document")[§](#(Version)_method_gist "direct link")
  
  See primary documentation
  [in context](/type/Version#method_gist)
  for **method gist**.
  
  ```raku
  method gist(Version:D: --> Str:D)
  ```
  
  Returns a string representation of the invocant, just like [`Str`](#method_Str), prepended with a lowercase `v`.
  
  ```raku
  my $v1 = v1.0.1;
  my $v2 = Version.new('1.0.1');
  say $v1.gist;                                      # OUTPUT: «v1.0.1␤»
  say $v2.gist;                                      # OUTPUT: «v1.0.1␤»
  ```
  
  # [In Backtrace](#___top "go to top of document")[§](#(Backtrace)_method_gist "direct link")
  
  See primary documentation
  [in context](/type/Backtrace#method_gist)
  for **method gist**.
  
  ```raku
  multi method gist(Backtrace:D:)
  ```
  
  Returns string `"Backtrace(42 frames)"` where the number indicates the number of frames available via [list](/routine/list) method.
  
  # [In Array](#___top "go to top of document")[§](#(Array)_method_gist "direct link")
  
  See primary documentation
  [in context](/type/Array#method_gist)
  for **method gist**.
  
  Exactly the same as [`List.gist`](/type/List#method_gist), except using square brackets for surrounding delimiters.
  
  # [In List](#___top "go to top of document")[§](#(List)_method_gist "direct link")
  
  See primary documentation
  [in context](/type/List#method_gist)
  for **method gist**.
  
  ```raku
  multi method gist(List:D: --> Str:D)
  ```
  
  Returns the string containing the parenthesized "gist" of the List, **listing up to the first 100** elements, separated by space, appending an ellipsis if the List has more than 100 elements. If List [`is-lazy`](/routine/is-lazy), returns string `'(...)'`
  
  ```raku
  put (1, 2, 3).gist;   # OUTPUT: «(1 2 3)␤»
  put (1..∞).List.gist; # OUTPUT: «(...)␤»
  
  put (1..200).List.gist;
  # OUTPUT:
  # (1 2 3 4 5 6 7 8 9 10 11 12 13 14 15 16 17 18 19 20 21 22 23 24 25 26
  # 27 28 29 30 31 32 33 34 35 36 37 38 39 40 41 42 43 44 45 46 47 48 49
  # 50 51 52 53 54 55 56 57 58 59 60 61 62 63 64 65 66 67 68 69 70 71 72
  # 73 74 75 76 77 78 79 80 81 82 83 84 85 86 87 88 89 90 91 92 93 94 95
  # 96 97 98 99 100 ...)
  
  ```
  
  # [In IO::Notification::Change](#___top "go to top of document")[§](#(IO::Notification::Change)_method_gist "direct link")
  
  See primary documentation
  [in context](/type/IO/Notification/Change#method_gist)
  for **method gist**.
  
  ```raku
  multi method gist(IO::Notification::Change:D:)
  ```
  
  Returns the path and event attributes, separated by semicolon.
  
  # [In Attribute](#___top "go to top of document")[§](#(Attribute)_method_gist "direct link")
  
  See primary documentation
  [in context](/type/Attribute#method_gist)
  for **method gist**.
  
  ```raku
  multi method gist(Attribute:D:)
  ```
  
  Returns the name of the type followed by the name of the attribute.
  
  ```raku
  class Hero {
      has @!inventory;
      has Str $.name;
      submethod BUILD( :$name, :@inventory ) {
          $!name = $name;
          @!inventory = @inventory
      }
  }
  say Hero.^attributes(:local)[0]; # OUTPUT: «Positional @!inventory␤»
  
  ```
  
  Since say implicitly calls `.gist`, that is what produces the output here.
  
  # [In Junction](#___top "go to top of document")[§](#(Junction)_method_gist "direct link")
  
  See primary documentation
  [in context](/type/Junction#method_gist)
  for **method gist**.
  
  ```raku
  multi method gist(Junction:D:)
  ```
  
  Collapses the `Junction` and returns a [`Str`](/type/Str) composed of the type of the junction and the [gists](/routine/gist) of its components:
  
  ```raku
  <a 42 c>.all.say; # OUTPUT: «all(a, 42, c)␤»
  ```
  
  # [In IO::Path](#___top "go to top of document")[§](#(IO::Path)_method_gist "direct link")
  
  See primary documentation
  [in context](/type/IO/Path#method_gist)
  for **method gist**.
  
  ```raku
  method gist(IO::Path:D: --> Str:D)
  ```
  
  Returns a string, part of which contains either the value of [`.absolute`](/type/IO/Path#method_absolute) (if path is absolute) or [`.path`](/type/IO/Path#attribute_path). Note that no escaping of special characters is made, so e.g. `"\b"` means a path contains a backslash and letter "b", not a backspace.
  
  ```raku
  say "foo/bar".IO;                       # OUTPUT: «"foo/bar".IO␤»
  say IO::Path::Win32.new: ｢C:\foo/bar\｣; # OUTPUT: «"C:\foo/bar\".IO␤»
  ```
  
  # [In role Sequence](#___top "go to top of document")[§](#(role_Sequence)_method_gist "direct link")
  
  See primary documentation
  [in context](/type/Sequence#method_gist)
  for **method gist**.
  
  ```raku
  multi method gist(::?CLASS:D:)
  ```
  
  Returns the [gist](/type/List#method_gist) of the [cached](/type/PositionalBindFailover#method_cache) sequence.
  
  # [In Date](#___top "go to top of document")[§](#(Date)_method_gist "direct link")
  
  See primary documentation
  [in context](/type/Date#method_gist)
  for **method gist**.
  
  ```raku
  multi method gist(Date:D: --> Str:D)
  ```
  
  Returns the date in `YYYY-MM-DD` format ([ISO 8601](https://en.wikipedia.org/wiki/ISO_8601))
  
  ```raku
  say Date.new('2015-12-24').gist;                    # OUTPUT: «2015-12-24␤»
  ```
  
  # [In role Systemic](#___top "go to top of document")[§](#(role_Systemic)_method_gist "direct link")
  
  See primary documentation
  [in context](/type/Systemic#method_gist)
  for **method gist**.
  
  ```raku
  method gist( Systemic:D: )
  ```
  
  Instance method returning the name and version of the object.
  
  ```raku
  say $*RAKU.gist; # OUTPUT: «Raku (6.d)␤»
  ```
  
  `$*RAKU` is an object of the [`Raku`](/type/Raku) type, which mixes in this role and thus implements this method.
  
  # [In ForeignCode](#___top "go to top of document")[§](#(ForeignCode)_method_gist "direct link")
  
  See primary documentation
  [in context](/type/ForeignCode#method_gist)
  for **method gist**.
  
  ```raku
  method gist( ForeignCode:D: )
  ```
  
  Returns the name of the code by calling `name`.
  
  # [In Nil](#___top "go to top of document")[§](#(Nil)_method_gist "direct link")
  
  See primary documentation
  [in context](/type/Nil#method_gist)
  for **method gist**.
  
  ```raku
  method gist(--> Str:D)
  ```
  
  Returns `"Nil"`.
  
  # [In Map](#___top "go to top of document")[§](#(Map)_method_gist "direct link")
  
  See primary documentation
  [in context](/type/Map#method_gist)
  for **method gist**.
  
  ```raku
  method gist(Map:D: --> Str:D)
  ```
  
  Returns the string containing the "gist" of the `Map`, sorts the pairs and lists **up to the first 100**, appending an ellipsis if the `Map` has more than 100 pairs.
  