txt: ## win32.md
  class IO::Spec::Win32
  
  Platform specific operations on file and directory paths for Windows
  
  ```raku
  class IO::Spec::Win32 is IO::Spec::Unix { }
  ```
  
  An object of this type is available via the variable `$*SPEC` if the Raku interpreter is running on a Windows-like platform.
  
  About this class and its related classes also see [`IO::Spec`](/type/IO/Spec).
  
  # [Methods](#class_IO::Spec::Win32 "go to top of document")[§](#Methods "direct link")
  
  ## [method basename](#class_IO::Spec::Win32 "go to top of document")[§](#method_basename "direct link")
  
  ```raku
  method basename(Str:D $path --> Str:D)
  ```
  
  Takes a path as a string and returns a possibly-empty portion after the last slash or backslash:
  
  ```raku
  IO::Spec::Win32.basename("foo/bar/") .raku.say; # OUTPUT: «""␤»
  IO::Spec::Win32.basename("foo/bar\\").raku.say; # OUTPUT: «""␤»
  IO::Spec::Win32.basename("foo/bar/.").raku.say; # OUTPUT: «"."␤»
  IO::Spec::Win32.basename("foo/bar")  .raku.say; # OUTPUT: «"bar"␤»
  ```
  
  ## [method canonpath](#class_IO::Spec::Win32 "go to top of document")[§](#method_canonpath "direct link")
  
  ```raku
  method canonpath(Str() $path, :$parent --> Str:D)
  ```
  
  Returns a string that is a canonical representation of `$path`. If `:$parent` is set to true, will also clean up references to parent directories. **NOTE:** the routine does not access the filesystem.
  
  ```raku
  IO::Spec::Win32.canonpath("C:/foo//../bar/../ber").say;
  # OUTPUT: «C:\foo\..\bar\..\ber␤»
  
  IO::Spec::Win32.canonpath("C:/foo///./../bar/../ber").say;
  # OUTPUT: «C:\foo\..\bar\..\ber␤»
  
  IO::Spec::Win32.canonpath("C:/foo///./../bar/../ber", :parent).say;
  # OUTPUT: «C:\ber␤»
  ```
  
  ## [method catdir](#class_IO::Spec::Win32 "go to top of document")[§](#method_catdir "direct link")
  
  ```raku
  method catdir (*@parts --> Str:D)
  ```
  
  Concatenates multiple path fragments and returns the canonical representation of the resultant path as a string. The `@parts` are [`Str`](/type/Str) objects and are allowed to contain path separators.
  
  ```raku
  IO::Spec::Win32.catdir(<foo/bar ber raku>).say;
  # OUTPUT: «foo\bar\ber\raku␤»
  ```
  
  ## [method catfile](#class_IO::Spec::Win32 "go to top of document")[§](#method_catfile "direct link")
  
  Alias for [`catdir`](/routine/catdir).
  
  ## [method catpath](#class_IO::Spec::Win32 "go to top of document")[§](#method_catpath "direct link")
  
  ```raku
  method catpath (Str:D $volume, Str:D $dir, Str:D $file --> Str:D)
  ```
  
  Concatenates a path from given volume, a chain of directories, and file. An empty string can be given for any of the three arguments. No attempt to make the path canonical is made. Use [`canonpath`](/routine/canonpath) for that purpose.
  
  ```raku
  IO::Spec::Win32.catpath('C:', '/some/dir', 'foo.txt').say;
  # OUTPUT: «C:/some/dir\foo.txt␤»
  
  IO::Spec::Win32.catpath('C:', '/some/dir', '').say;
  # OUTPUT: «C:/some/dir␤»
  
  IO::Spec::Win32.catpath('', '/some/dir', 'foo.txt').say;
  # OUTPUT: «/some/dir\foo.txt␤»
  
  IO::Spec::Win32.catpath('E:', '', 'foo.txt').say;
  # OUTPUT: «E:foo.txt␤»
  ```
  
  ## [method devnull](#class_IO::Spec::Win32 "go to top of document")[§](#method_devnull "direct link")
  
  ```raku
  method devnull(--> Str:D)
  ```
  
  Returns the string `"nul"` representing the ["Null device"](https://en.wikipedia.org/wiki/Null_device):
  
  ```raku
  $*SPEC.devnull.IO.spurt: "foo bar baz";
  
  ```
  
  ## [method dir-sep](#class_IO::Spec::Win32 "go to top of document")[§](#method_dir-sep "direct link")
  
  ```raku
  method dir-sep(--> Str:D)
  ```
  
  Returns the string `｢\｣` representing canonical directory separator character.
  
  ```raku
  IO::Spec::Win32.dir-sep.say; # OUTPUT: «\␤»
  
  ```
  
  ## [method is-absolute](#class_IO::Spec::Win32 "go to top of document")[§](#method_is-absolute "direct link")
  
  ```raku
  method is-absolute(Str:D $path --> Bool:D)
  ```
  
  Returns `True` if the `$path` starts with a slash (`"/"`) or backslash (`"\"`), even if they have combining character on them, optionally preceded by a volume:
  
  ```raku
  say IO::Spec::Win32.is-absolute: "/foo";        # OUTPUT: «True␤»
  say IO::Spec::Win32.is-absolute: "/\x[308]foo"; # OUTPUT: «True␤»
  say IO::Spec::Win32.is-absolute: ｢C:\foo｣;      # OUTPUT: «True␤»
  say IO::Spec::Win32.is-absolute: "bar";         # OUTPUT: «False␤»
  ```
  
  ## [method join](#class_IO::Spec::Win32 "go to top of document")[§](#method_join "direct link")
  
  ```raku
  method join (Str:D $volume, Str:D $dir, Str:D $file --> Str:D)
  ```
  
  Similar to [`catpath`](/routine/catpath), takes two path fragments and concatenates them, adding or removing a path separator, if necessary, except it will return just `$file` if both `$dir` and `$file` are string `'/'` or if `$dir` is the string `'.'`. The first argument is ignored (it exists to maintain consistent interface with other [`IO::Spec`](/type/IO/Spec) types for systems that have volumes).
  
  ```raku
  IO::Spec::Win32.join('C:', '/some/dir', 'foo.txt').say;
  # OUTPUT: «C:/some/dir\and/more␤»
  
  IO::Spec::Win32.join('C:', '.', 'foo.txt').say;
  # OUTPUT: «C:foo.txt␤»
  
  IO::Spec::Win32.join('C:', ｢\｣, '/').say;
  # OUTPUT: «C:\␤»
  
  IO::Spec::Win32.join('//server/share', ｢\｣, '/').say;
  # OUTPUT: «//server/share␤»
  
  IO::Spec::Win32.join('E:', '', 'foo.txt').say;
  # OUTPUT: «E:foo.txt␤»
  ```
  
  ## [method path](#class_IO::Spec::Win32 "go to top of document")[§](#method_path "direct link")
  
  ```raku
  method path(--> Seq:D)
  ```
  
  Splits the value of `%*ENV<PATH>` (or `%*ENV<Path>` if the former is not set) on semicolons (`";"`) and returns a [`Seq`](/type/Seq) with each of the resultant parts, always adding element `"."` to the head. Removes all double quotes (`"`) it finds.
  
  ```raku
  %*ENV<PATH> = 'foo;"bar"/"ber"';
  IO::Spec::Win32.path.raku.say; # OUTPUT: «(".", "foo", "bar/ber").Seq␤»
  ```
  
  ## [method rel2abs](#class_IO::Spec::Win32 "go to top of document")[§](#method_rel2abs "direct link")
  
  ```raku
  method rel2abs(Str() $path, $base = $*CWD --> Str:D)
  ```
  
  Returns a string representing `$path` converted to absolute path, based at `$base`, which defaults to `$*CWD`. If `$base` is not an absolute path, it will be made absolute relative to `$*CWD`, unless `$*CWD` and `$base` are the same.
  
  ```raku
  say $*CWD;                                   # OUTPUT: «"C:\Users\camelia".IO␤»
  
  say IO::Spec::Win32.rel2abs: 'foo';          # OUTPUT: «C:\Users\camelia\foo␤»
  say IO::Spec::Win32.rel2abs: './';           # OUTPUT: «C:\Users\camelia␤»
  say IO::Spec::Win32.rel2abs: 'foo/../../';   # OUTPUT: «C:\Users\camelia\foo\..\..␤»
  say IO::Spec::Win32.rel2abs: '/foo/';        # OUTPUT: «C:\foo␤»
  
  say IO::Spec::Win32.rel2abs: 'foo', 'bar';   # OUTPUT: «C:\Users\camelia\bar\foo␤»
  say IO::Spec::Win32.rel2abs: './', '/bar';   # OUTPUT: «\bar␤»
  say IO::Spec::Win32.rel2abs: '/foo/', 'bar'; # OUTPUT: «C:\foo␤»
  
  say IO::Spec::Win32.rel2abs: 'foo/../../', 'bar';
  # OUTPUT: «C:\Users\camelia\bar\foo\..\..␤»
  
  ```
  
  ## [method rootdir](#class_IO::Spec::Win32 "go to top of document")[§](#method_rootdir "direct link")
  
  ```raku
  method rootdir(--> Str:D)
  ```
  
  Returns string `｢\｣`, representing root directory.
  
  ## [method split](#class_IO::Spec::Win32 "go to top of document")[§](#method_split "direct link")
  
  ```raku
  method split(IO::Spec::Win32: Cool:D $path)
  ```
  
  Creates an [`IO::Path::Parts`](/type/IO/Path/Parts) for `$path`.
  
  ```raku
  IO::Spec::Win32.split('C:/foo/bar.txt').raku.say;
  # OUTPUT: «IO::Path::Parts.new("C:","/foo","bar.txt")␤»
  
  IO::Spec::Win32.split('/foo/').raku.say;
  # OUTPUT: «IO::Path::Parts.new("","/","foo")␤»
  
  IO::Spec::Win32.split('///').raku.say;
  # OUTPUT: «IO::Path::Parts.new("","/","\\")␤»
  
  IO::Spec::Win32.split('./').raku.say;
  # OUTPUT: «IO::Path::Parts.new("",".",".")␤»
  
  IO::Spec::Win32.split('.').raku.say;
  # OUTPUT: «IO::Path::Parts.new("",".",".")␤»
  
  IO::Spec::Win32.split('').raku.say;
  # OUTPUT: «IO::Path::Parts.new("","","")␤»
  
  ```
  
  **Note**: Before Rakudo version 2020.06 this method split the given `$path` into "volume", "dirname", and "basename" and returned the result as a [`List`](/type/List) of three [`Pair`](/type/Pair)s, in that order.
  
  ## [method splitdir](#class_IO::Spec::Win32 "go to top of document")[§](#method_splitdir "direct link")
  
  ```raku
  method splitdir(Cool:D $path --> List:D)
  ```
  
  Splits the given `$path` on slashes and backslashes.
  
  ```raku
  IO::Spec::Win32.splitdir('C:\foo/bar.txt').raku.say;
  # OUTPUT: «("C:", "foo", "bar.txt")␤»
  
  IO::Spec::Win32.splitdir('/foo/').raku.say;
  # OUTPUT: «("", "foo", "")␤»
  
  IO::Spec::Win32.splitdir('///').raku.say;
  # OUTPUT: «("", "", "", "")␤»
  
  IO::Spec::Win32.splitdir('./').raku.say;
  # OUTPUT: «(".", "")␤»
  
  IO::Spec::Win32.splitdir('.').raku.say;
  # OUTPUT: «(".",)␤»
  
  IO::Spec::Win32.splitdir('').raku.say;
  # OUTPUT: «("",)␤»
  
  ```
  
  ## [method splitpath](#class_IO::Spec::Win32 "go to top of document")[§](#method_splitpath "direct link")
  
  ```raku
  method splitpath(Cool:D $path, :$nofile --> List:D)
  ```
  
  Splits the given `$path` into a list of 3 strings: volume, dirname, and file. The volume is always an empty string, returned for API compatibility with other [`IO::Spec`](/type/IO/Spec) types. If `:$nofile` named argument is set to `True`, the content of the file string is undefined and should be ignored; this is a means to get a performance boost, as implementations may use faster code path when file is not needed.
  
  ```raku
  IO::Spec::Win32.splitpath('C:\foo/bar.txt').raku.say;
  # OUTPUT: «("C:", "\\foo/", "bar.txt")␤»
  
  IO::Spec::Win32.splitpath('C:\foo/bar.txt', :nofile).raku.say;
  # OUTPUT: «("C:", "\\foo/bar.txt", "")␤»
  
  IO::Spec::Win32.splitpath('/foo/').raku.say;
  # OUTPUT: «("", "/foo/", "")␤»
  
  IO::Spec::Win32.splitpath('/foo/', :nofile).raku.say;
  # OUTPUT: «("", "/foo/", "")␤»
  
  IO::Spec::Win32.splitpath('///').raku.say;
  # OUTPUT: «("", "///", "")␤»
  
  IO::Spec::Win32.splitpath('./').raku.say;
  # OUTPUT: «("", "./", "")␤»
  
  IO::Spec::Win32.splitpath('.').raku.say;
  # OUTPUT: «("", "", ".")␤»
  
  IO::Spec::Win32.splitpath('').raku.say;
  # OUTPUT: «("", "", "")␤»
  
  ```
  
  ## [method tmpdir](#class_IO::Spec::Win32 "go to top of document")[§](#method_tmpdir "direct link")
  
  ```raku
  method tmpdir(--> IO::Path:D)
  ```
  
  Attempts to locate a system's temporary directory by checking several typical directories and environment variables. Uses current directory if no suitable directories are found.
  