txt: ## version.md
  class Version
  
  Module version descriptor
  
  ```raku
  class Version { }
  ```
  
  Version objects identify version of software components (and potentially other entities). Raku uses them internally for versioning modules.
  
  A version consists of several parts, which are visually represented by joining them with a dot. A version part is usually an integer, a string like `alpha`, or a [`Whatever`](/type/Whatever)-star `*`. The latter is used to indicate that any version part is acceptable in another version that is compared to the current one.
  
  ```raku
  say v1.0.1 ~~ v1.*;     # OUTPUT: «True␤»
  say v1.0.1 ~~ v1.*.1;   # OUTPUT: «True␤»
  ```
  
  The first part of version literals contains `v` and a number; this might be followed by alphanumeric and [`Whatever`](/type/Whatever) parts and trailed by `+`. Multiple parts are separate with a dot `.`. A trailing `+` indicates that higher versions are OK in comparisons:
  
  ```raku
  say v1.2 ~~ v1.0;                 # OUTPUT: «False␤»
  say v1.2 ~~ v1.0+;                # OUTPUT: «True␤»
  say v0.and.anything.else ~~ v0+;  # OUTPUT: «True␤»
  ```
  
  In comparisons, order matters, and every part is compared in turn.
  
  ```raku
  say v1.2 cmp v2.1;      # OUTPUT: «Less␤»
  ```
  
  The `+` suffix is always taken into account in comparisons:
  
  ```raku
  say v1.0.1+ <=> v1.0.1; # OUTPUT: «More␤»
  ```
  
  And `*` ([`Whatever`](/type/Whatever)) is too, and considered always `Less` than whatever digit is in the corresponding part, even if `*` is trailed by `+`:
  
  ```raku
  say v1.* <=> v1.0;      # OUTPUT: «Less␤»
  say v1.* <= v1.0;       # OUTPUT: «True␤»
  say v1.*+ <= v1.0;      # OUTPUT: «True␤»
  ```
  
  Please note that method calls, including pseudo methods like `WHAT`, require version literals either to be enclosed with parentheses or use some other method to separate them from the dot that denotes a method call, like in these examples:
  
  ```raku
  say (v0.and.some.*.stuff).parts;  # OUTPUT: «(0 and some * stuff)␤»
  say v0.and.some.*.stuff .parts;   # OUTPUT: «(0 and some * stuff)␤»
  ```
  
  # [Methods](#class_Version "go to top of document")[§](#Methods "direct link")
  
  ## [method new](#class_Version "go to top of document")[§](#method_new "direct link")
  
  ```raku
  method new(Str:D $s)
  ```
  
  Creates a `Version` from a string `$s`. The string is combed for the numeric, alphabetic, and wildcard components of the version object. Any characters other than alphanumerics and asterisks are assumed to be equivalent to a dot. A dot is also assumed between any adjacent numeric and alphabetic characters.
  
  ## [method parts](#class_Version "go to top of document")[§](#method_parts "direct link")
  
  ```raku
  method parts(Version:D: --> List:D)
  ```
  
  Returns the list of parts that make up this `Version` object
  
  ```raku
  my $v1 = v1.0.1;
  my $v2 = v1.0.1+;
  say $v1.parts;                                    # OUTPUT: «(1 0 1)␤»
  say $v2.parts;                                    # OUTPUT: «(1 0 1)␤»
  ```
  
  The `+` suffix is not considered a *part* of the `Version` object, and thus not returned by this method, as shown above in the `$v2` variable.
  
  ## [method plus](#class_Version "go to top of document")[§](#method_plus "direct link")
  
  ```raku
  method plus(Version:D: --> Bool:D)
  ```
  
  Returns `True` if comparisons against this version allow larger versions too.
  
  ```raku
  my $v1 = v1.0.1;
  my $v2 = v1.0.1+;
  say $v1.plus;                                     # OUTPUT: «False␤»
  say $v2.plus;                                     # OUTPUT: «True␤»
  ```
  
  ## [method Str](#class_Version "go to top of document")[§](#method_Str "direct link")
  
  ```raku
  method Str(Version:D: --> Str:D)
  ```
  
  Returns a string representation of the invocant.
  
  ```raku
  my $v1 = v1.0.1;
  my $v2 = Version.new('1.0.1');
  say $v1.Str;                                      # OUTPUT: «1.0.1␤»
  say $v2.Str;                                      # OUTPUT: «1.0.1␤»
  ```
  
  ## [method gist](#class_Version "go to top of document")[§](#method_gist "direct link")
  
  ```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␤»
  ```
  
  ## [method Capture](#class_Version "go to top of document")[§](#method_Capture "direct link")
  
  ```raku
  method Capture()
  ```
  
  Throws [`X::Cannot::Capture`](/type/X/Cannot/Capture).
  
  # [Typegraph](# "go to top of document")[§](#typegraphrelations "direct link")
  
  Type relations for `Version`
  
  
  
  raku-type-graph
  
  
  
  Version
  Version
  
  
  Any
  Any
  
  
  Version->Any
  
  
  
  Mu
  Mu
  
  
  Any->Mu
  
  [Expand chart above](/assets/typegraphs/Version.svg)
  