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::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.


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 <fernando.correa@humanstate.com>


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


Queue

use ValueClass;
unit value-class Functional::LinkedList does Positional;

my $both-default = True;

role Typed[::T = Any] {
  has T $.of
}

my $of = Any;
method ^parameterize(Mu:U \linked-list, ::T = Any) {
  $of = T;
  linked-list.^mixin(Typed[T]).^set_name: "LinkedList[{ $of.^name }]"
}

method mutate(&block) is export {
  my $*VALUE = self;
  block $*VALUE;
  $*VALUE
}

method iterator {
  class :: does Iterator {
    has $.list is required;
    method pull-one {
      return IterationEnd without $!list;
      my $value := $!list.value;
      $!list .= next;
      $value
    }
  }.new: :list(self)
}

my class NO-VALUE {}

has          $.value where $of = $of.WHAT;
has ::?CLASS $.next;
has UInt     $.size = 1 + ($!next andthen .size // 0);
has Bool     $.both = $both-default;

method of {Any}

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

multi method new(*@values, Bool :$both = $both-default, *% where *.not) {
  die X::TypeCheck.new: :operation("creating { $.^name }"), :expected($of), :got(@values) if @values && @values.are !~~ $of;
  my $obj = self.bless: :$both, :value(@values.tail // $of);
  for @values.reverse.skip -> $item {
    $obj := $obj.unshift: $item // $of
  }
  $obj
}

multi method AT-POS(::?CLASS:D: 0) {
  $!value
}

multi method AT-POS(::?CLASS:D: UInt $index) {
  $!next.AT-POS: $index - 1
}

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

multi method DELETE-POS(::?CLASS:D: Int $ where { $_ < 0 }) {
  NO-VALUE
}

multi method DELETE-POS(::?CLASS:D: 0, Bool :$both = $!both, Bool :$internal = False) {
  self!mutable: :$internal, :$both, $!next, $!value
}

multi method DELETE-POS(::?CLASS:D: UInt $index, Bool :$both = $!both, Bool :$internal = False) {
  my :($node, $value) := $!next.DELETE-POS: :internal, $index - 1;
  self!mutable: :$internal, :$both, self!replace($node), $value
}

multi method ASSIGN-POS(::?CLASS:D: Int $ where { $_ < 0 }, $, Bool :$both = $!both) {
  NO-VALUE
}

multi method ASSIGN-POS(0, $value where $of, Bool :$both = self.defined ?? $!both !! $both-default, Bool :$internal = False) {
  self!mutable: :$internal, :$both, $.new(:$value, |(:$!both with self), |(:$!next with self)), $value
}

multi method ASSIGN-POS(::?CLASS:U: UInt $index, $value where $of, Bool :$both = $both-default, Bool :$internal = False) {
  my :($node, $val) := $.new.ASSIGN-POS: :internal, $index - 1, $value;
  self!mutable: :$internal, :$both, self!replace($node), $val
}

multi method ASSIGN-POS(::?CLASS:D: UInt $index, $value where $of, Bool :$both = $!both, Bool :$internal = False) {
  my :($node, $val) := $!next.ASSIGN-POS: :internal, $index - 1, $value;
  self!mutable: :$internal, :$both, self!replace($node), $val
}

method BIND-POS(|c) { $.ASSIGN-POS: |c }

method !replace($_) {
  do if $_ !~~ NO-VALUE {
    $.new: next => .self, |(:$!both with self), |(:$!value with self)
  } else {
    self
  }
}

method unshift($value where $of) {
  self!mutable: $.new(:$value, :next(self), |(:$!both with self)), $value
}

method shift {
  self!mutable: $!next, $!value
}

method push($value where $of) {
  self[$!size] = $value;
}

method pop {
  self[$!size - 1]:delete
}

multi method gist(::?CLASS:U:) { "({ self.^shortname }{ "[{ $of.^name }]" })" }
multi method gist(::?CLASS:D:) { "$!value -> { quietly $!next.gist }" }

method WHICH { ValueObjAt.new: join "|", self.^shortname, |($!value.WHICH, $!next.WHERE with self) }

multi method Seq(::?CLASS:D:) { Seq.new: $.iterator }
multi method list(::?CLASS:D:) { $.Seq.list }



Functional::LinkedList - Functional data structure linked list.


=begin code :lang<raku>

my @linked := Functional::LinkedList.new: 1, 2, 3;

say @linked;           # 1 -> 2 -> 3 -> (LinkedList[Any])
say @linked.push: 10;  # (1 -> 2 -> 3 -> 10 -> (LinkedList[Any]) 10)
say @linked;           # 1 -> 2 -> 3 -> (LinkedList[Any])

my @linked2 := Functional::LinkedList.new: :!both, 1, 2, 3;

say @linked2;          # 1 -> 2 -> 3 -> (LinkedList[Any])
say @linked2.push: 10; # 1 -> 2 -> 3 -> 10 -> (LinkedList[Any])
say @linked2;          # 1 -> 2 -> 3 -> (LinkedList[Any])

my @mutated := @linked.mutate: {
   .say;               # 1 -> 2 -> 3 -> (LinkedList[Any])
   say .push: 10;      # 10
   .say;               # 1 -> 2 -> 3 -> 10 -> (LinkedList[Any])
}

say @linked;           # 1 -> 2 -> 3 -> (LinkedList[Any]
say @mutated;          # 1 -> 2 -> 3 -> 10 -> (LinkedList[Any])

=end code


Functional::LinkedList is a implementation of a functional data structure
linked list. It's immutable and thread-safe.


It has a C<mutate> method that topicalise the object and will always topicalise
the new generated list. 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>


LinkedList

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::LinkedList v0.0.1

Authors

License

Dependencies

Test Dependencies

Provides

Documentation