Image

head

code

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 ValueClass;
use Functional::LinkedList;

unit value-class Functional::Stack;

my $both-default = True;

has Functional::LinkedList $.list;
has Bool                   $.both = $both-default;

multi method mutate(::?CLASS:U: &block) { self.new.mutate: &block }

multi method mutate(::?CLASS:D: &block) {
  my $*STACK = self;
  block $*STACK;
  $*STACK
}

method !mutable($node, $value, Bool :$both = self.defined ?? $!both !! $both-default, :$internal = False) {
  return $node, $value if $internal;
  do if $*STACK !~~ Failure {
    $*STACK = $($node);
    $value
  } else {
    return $node, $value if $both;
    $node
  }
}

multi method size(::?CLASS:U:) { 0 }
multi method size(::?CLASS:D:) { $!list.elems }
method elems { $.size }

method push(\value) {
  self!mutable: self.new(:list($!list.unshift(value).head)), value
}

method pop {
  my ($list, \value) = $!list.shift: :both;
  self!mutable: $.new(:$list), value
}

method peek { $!list.value }



=begin code :lang<raku>

use Functional::Stack;
Functional::Stack.mutate: {
   for ^10 -> $value { say .push: $value }
   say .peek;
   say .pop while .elems;
}

=end code


Functional::Stack is a implementation of a functional data structure
stack. It's immutable and thread-safe.


It has a C<mutate> method that topicalise the object and will always topicalise
the new generated stack. And that's gives the impression of mutating and makes
it easier to interact with those objects.


Fernando Corrêa de Oliveira <fco@cpan.org>


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


Stack

use ValueClass;
use Functional::Stack;
unit value-class Functional::Queue;

my $both-default = True;

has Functional::Stack $.head;
has Functional::Stack $.tail;
has Bool              $.both = $both-default;

submethod TWEAK(|) {
  die "It shouldn't be possible to a queue have a head without a tail" if $!head.elems && !$!tail.elems;
}

multi method mutate(&block) {
  my $*QUEUE = self;
  block $*QUEUE;
  $*QUEUE
}

method !mutable($node, $value, Bool :$both = self.defined ?? $!both !! $both-default, :$internal = False) {
  return $node, $value if $internal;
  do if $*QUEUE !~~ Failure {
    $*QUEUE = $($node);
    $value
  } else {
    return $node, $value if $both;
    $node
  }
}

multi method elems(::?CLASS:U:) { 0 }
multi method elems(::?CLASS:D:) { $!head.elems + $!tail.elems }

multi method enqueue(::?CLASS:U: \value) {
  my ($tail, $) := Functional::Stack.push: value;
  self!mutable: $.new(:$tail), value
}

multi method enqueue(::?CLASS:D: \value) {
  return self.WHAT.enqueue: value unless $!tail;
  my ($head, $) := $!head.push: value;
  self!mutable: $.new(:$head, :$!tail), value
}

method dequeue {
  return $.mutable: self, Any without self;

  my $head = $!head;
  my :($t, \value) := $!tail.pop;
  my $tail = $t;
  unless $tail.elems {
    while $head.elems {
      my :($h, \v) := $head.pop;
      my :($t, $) := $tail.push: v;
      $head := $h;
      $tail := $t;
    }
  }
  self!mutable: $.new(:$head, :$tail), value
}

# method WHICH { ValueObjAt.new: join "|", $.^name, |($!head.WHERE, $!tail.WHERE with self) }



=begin code :lang<raku>

my $q1 = Functional::Queue.new;
my :($q2, $) := $q1.enqueue: 1;

my :($q3, $v3) := $q2.dequeue;
say $v3;

Functional::Queue.mutate: {
   for ^10 -> $v { .enqueue: $v }
   say .dequeue while .elems;
}

=end code


Functional::Queue is a implementation of a functional data structure
queue. It's immutable and thread-safe.


Fernando Corrêa de Oliveira <fernando.correa@humanstate.com>


Queue

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

NAME

SYNOPSIS

DESCRIPTION

AUTHOR

COPYRIGHT AND LICENSE

Functional::Queue v0.0.1

Authors

License

Dependencies

Test Dependencies

Provides

Documentation