Image

head

code

item

root

para

L<Examples| file:../examples/index.podlite>


L<Download |file:../download/index.podlite>


React

=begin React :component<HeaderCol> :id<menu> 
=para L<Documentation|/doc/introduction>
=para L<Modules| /mods>
=para L<Examples| file:../examples/index.podlite>
=para L<Download |file:../download/index.podlite>
=para L<About|file:../about/index.podlite>
=para 🔍 K<⌘K>/K<ctrl-K>
=end React


HEADER

FOOTER

README

use IO::Dir;
use File::Directory::Tree;
class X::Directory::FileExists is Exception {
    has IO::Path $.path;
    method message() {
        "Cannot create a Directory object. A file already exists at '" ~ $!path
                .Str ~ "'.";
    }
}

class X::Directory::NoHome is Exception {
    has IO::Path $.path;
    method message() {
        "The '~' was used in the path but no \$HOME environment variable exists.";
    }
}

class Directory is IO::Dir {
    has IO::Path $.path is required where dir-check($_);

    sub dir-check(IO::Path:D $path is copy) {
        die (X::Directory::FileExists.new(:$path)) if $path.f.Bool;
        return True;
    }

    method exists() {
        $!path.e;
    }

    method mktree(Int:D $mask = 0o777) {
        mktree($!path, :$mask);
    }

    method rmtree() {
        rmtree($!path);
    }

    method empty-directory() {
        empty-directory($!path);
    }

    method read() {
        my @entries;
        self.open: $.path;
        @entries.push: self.dir(:Str).Slip;
        self.close;
        return @entries;
    }

    submethod BUILD(:$path is copy) {
        if ($path.Str eq '~' || $path.Str.substr(0, 2) eq '~/') {
            die (X::Directory::NoHome.new(:$path)) if !%*ENV<HOME>;
            my $home = %*ENV<HOME>;
            $path = $path.Str.subst('~', $home).IO;
        }
        $!path = $path;
    }

    method new(Str:D $path?) {
        if ($path) {
            self.bless(path => $path.IO);
        } else {
            self.bless(path => $*CWD);
        }
    }

}



Directory - an object representing a directory


=begin code :lang<raku>

use Directory;

# OBJECT CONSTRUCTION
my $dir = Directory.new('/home/user/dir');
my $dir = Directory.new('~');
my $dir = Directory.new();   # current working directory, '.'

# METHODS
my $bool = Directory.new('/some/dir').exists;
my @entries = Directory.new('/some/dir').read;
my $bool = Directory.new('/some/dir').mktree;
my $bool = Directory.new('/some/dir').rmtree;
my $bool = Directory.new('/some/dir').empty-directory;
my $path = Directory.new('/some/dir').path;
Directory.new('/some/dir').open;
Directory.new('/some/dir').open.close;

=end code


A Directory object is a subclass of an IO::Dir object and also wraps
the subroutines found in the File::Tree::Directory distribution with methods.
The module aims to make working with directories very simple.


Creates a new Directory object from the C<$path> supplied or with the path to the
current working directory if no C<$path> is given.  An error is thrown
if a file already exists at the C<$path>. A path beginning with the C<~> character
is replaced with the value of the C<%*ENV<HOME\>> environment variable.


Returns a boolean value of C<True> if the directory exists, C<False> otherwise.


Returns an array of strings for each file and directory in the
Directory object's path.


Returns the IO::Path object for the Directory object.


Opens the Directory object with the C<open> method from C<IO::Dir>


Closes the Directory object with the C<close> method from C<IO::Dir>


A wrapper for the L<File::Directory::Tree>'s mktree command.


A wrapper for the L<File::Directory::Tree>'s rmtree command.


A wrapper for the L<File::Directory::Tree>'s empty-directory command.


This library is free software; you can redistribute it and/or modify it under the Artistic License 2.0.


CREDITS


sub ROL64 { ($^a +> (64 - $_) +| $a +< $_) % (1 +< 64) given $^n%64 }

multi KeccakF1600(@lanes) {
  my $R = 1;
  for ^24 {
    # θ
    my @C = map -> $x { [+^] @lanes[$x;^5] }, ^5;
    my @D = map -> $x { @C[($x-1)%5] +^ ROL64(@C[($x+1)%5], 1) }, ^5; 
    for ^5 X ^5 -> ($x, $y) { @lanes[$x;$y] +^= @D[$x] }
    # ρ and π
    my ($x, $y) = 1, 0;
    my $current = @lanes[$x; $y];
    for ^24 -> $t {
      ($x, $y) = $y, (2*$x+3*$y)%5;
      ($current, @lanes[$x;$y]) =
      @lanes[$x;$y], ROL64 $current, ($t+1)*($t+2) div 2;
    }
    # χ
    for ^5 -> $y {
      my @T = map { @lanes[$_;$y] }, ^5;
      for ^5 -> $x {
        @lanes[$x;$y] = @T[$x] +^ (
	  +^@T[($x+1)%5] +& @T[($x+2)%5]
	);
      }
    }
    # ι
    for ^7 -> $j {
      $R = ($R +< 1 +^ (($R +> 7)*0x71)) % 256;
      if $R +& 2 { @lanes[0;0] +^= 1 +< ((1 +< $j) - 1); }
    }
  }
  return @lanes;
}

multi KeccakF1600(blob8 $state) {
  sub load64 { :256[|@^b.reverse] }
  sub store64 { $^a.polymod: 256 xx 7 }
  my @lanes;
  for ^5 X ^5 -> ($i, $j) { @lanes[$i;$j] = load64 $state.subbuf: 8*($i + 5*$j), 8; }
  KeccakF1600 @lanes;
  my buf8 $new-state .= new: 0 xx 200;
  for ^5 X ^5 -> ($i, $j) {
    given 8*($i + 5*$j) {
      $new-state[$_ ..^ $_ + 8] = store64 @lanes[$i;$j];
    }
  }
  return $new-state;
}

our proto Keccak(
  Blob $inputBytes,
  byte :$delimitedSuffix,
  UInt :$outputByteLen is copy,
  UInt :$rate where * %% 8,
  UInt :$capacity where $rate + $capacity == 1600,
) {*}

multi Keccak(
  $inputBytes,
  :$delimitedSuffix,
  :$rate,
  :$capacity
) {

  my buf8 $outputBytes .= new;
  my buf8 $state .= new: 0 xx 200;
  my $rateInBytes = $rate div 8;
  my $blockSize = 0;
  my $inputOffset = 0;

  # === Absorb all the input blocks ===
  while $inputOffset < $inputBytes.elems {
    $blockSize = min $inputBytes - $inputOffset, $rateInBytes;
    for ^$blockSize -> $i {
      $state[$i] +^= $inputBytes[$i+$inputOffset];
    }
    $inputOffset += $blockSize;
    if $blockSize == $rateInBytes {
      $state .= &KeccakF1600;
      $blockSize = 0;
    }
  }

  # === Do the padding and switch to the squeezing phase ===
  $state[$blockSize] +^= $delimitedSuffix;
  if ($delimitedSuffix +& 0x80) != 0 and ($blockSize == ($rateInBytes-1)) {
    $state .= &KeccakF1600;
  }
  $state[$rateInBytes-1] +^= 0x80;
  $state .= &KeccakF1600;
  
  # === Squeeze out all the output blocks ===
  gather loop {
    take $state.subbuf: 0, $rateInBytes;
    $state .= &KeccakF1600;
  }

}

multi Keccak(
  $inputBytes,
  :$delimitedSuffix,
  :$outputByteLen is copy,
  :$rate,
  :$capacity,
) {
  gather for samewith $inputBytes, :$delimitedSuffix, :$rate, :$capacity {
    # === Squeeze out all the output blocks ===
    my $blockSize = min $outputByteLen, .elems;
    take .subbuf: 0, $blockSize;
    $outputByteLen -= $blockSize;
    last if $outputByteLen ≤ 0;
  }
}

# vim: ft=raku


SHA3

The Raku Knowledge Base


=begin React :component<HeaderCol> :id<footer>  
=begin nested :!nested
=item1 B<Language>
    =item2 L<Get started|file:../getting-started/getting-started.podlite>
    =item2 L<Why Raku?|/doc/language/faq#Why-should-I-learn-Raku-What's-so-great-about-it>
    =item2 L<Try Raku|https://glot.io/new/raku>
    =item2 L<Raku cheat sheet|https://github.com/Raku/mu/blob/master/docs/Perl6/Cheatsheet/cheatsheet.txt>
    =item2 L<empty|#>
    =item2 L<empty|#>
    =item2 L<empty|#>
    =item2 L<Raku on Exercism|https://exercism.org/tracks/raku>
    =item2 L<Wikipedia|https://en.wikipedia.org/wiki/Raku_(programming_language)>
    =item2 L<empty|#>
    =item2 L<empty|#>
    =item2 L<empty|#>

=end nested
=begin nested :!nested

=item1 B<L<Documentation|/doc>>
    =item2 L<Getting started, Migration guides from other languages, & Tutorials | file:../doc/introduction.podlite>
    =item2 L<Language References|file:../doc/reference.podlite>
    =item2 L<Type Reference| file:../doc/types.podlite>
    =item2 L<Miscellaneous| file:../doc/miscellaneous.podlite>
    =item2 L<FAQs (Frequently Asked Questions)|/doc/language/faq>
    =item2 L<Community|/doc/language/community>
    =item2 L<The list of all documents|file:../doc/index.podlite>

=item1 B<Resources>
    =item2 L<The Raku Guide|https://raku.guide/>
    =item2 L<Books |https://perl6book.com/>
    =item2 L<Rosetta Code | https://www.raku.org/community/rosettacode>

=end nested
=begin nested :!nested

=item1 B<Resoures>
    =item2 L<Download | file:../download/index.podlite>
    =item2 L<empty|#>
    =item2 L<empty|#>
    =item2 L<empty|#>
    =item2 L<empty|#>
    =item2 L<empty|#>
    =item2 L<empty|#>
    =item2 L<empty|#>

=item1 B<Learning>
    =item2 L<The Raku Guide|https://raku.guide/>
    =item2 L<Wikibook |https://en.wikibooks.org/wiki/Raku_Programming>
    =item2 L<Books |https://perl6book.com/>
    =item2 L<Rosetta Code | https://www.raku.org/community/rosettacode>
    =item2 L<Learn Raku in Y minutes|https://learnxinyminutes.com/docs/raku/>
    =item2 L<Golfing |https://github.com/AlexDaniel/raku-golf-cheatsheet>
=end nested
=begin nested :!nested

=item1 B<Explore>
    =item2 L<Raku Blog Aggregator|https://planet.raku.org/>
    =item2 L<Rakudo Weekly|https://rakudoweekly.blog/>
    =item2 L<The Weekly Challenge |https://perlweeklychallenge.org/>
    =item2 L<Raku Advent Calendar|https://raku-advent.blog/>
    =item2 L<empty|#>
    =item2 L<empty|#>
    =item2 L<empty|#>
    =item2 L<empty|#>
    =item2 L<empty|#>

=end nested
=end React


=begin React :component<CookieConsent> :id<CookieConsent> :buttonCaption("Got it!")
=para
This website uses cookies for analytics.
=end React


README

Digests in raku

Synopsis

Features

License

Digest v0.28.0

Authors

License

Dependencies

Test Dependencies

Provides

Documentation