This is an automated email from the git hooks/post-receive script.
js pushed a commit to tag 0.91
in repository libcatmandu-perl.
commit 341afe1d6b8b84768dec50f29a69063690f502d8
Author: Patrick Hochstenbach <patrick.hochstenb...@ugent.be>
Date: Sat May 10 20:15:20 2014 +0200
Deleted the loop and each monads and adding monadic laws into the tests
---
lib/Catmandu/Fix/Bind.pm | 123 +++++++++++++++++---------------
lib/Catmandu/Fix/Bind/benchmark.pm | 2 +-
lib/Catmandu/Fix/Bind/each.pm | 81 ---------------------
lib/Catmandu/Fix/Bind/loop.pm | 42 -----------
t/Catmandu-Fix-Bind-benchmark.t | 12 +++-
t/Catmandu-Fix-Bind-each.t | 142 -------------------------------------
t/Catmandu-Fix-Bind-identity.t | 12 +++-
t/Catmandu-Fix-Bind-loop.t | 120 -------------------------------
8 files changed, 87 insertions(+), 447 deletions(-)
diff --git a/lib/Catmandu/Fix/Bind.pm b/lib/Catmandu/Fix/Bind.pm
index 156aeaa..db02454 100644
--- a/lib/Catmandu/Fix/Bind.pm
+++ b/lib/Catmandu/Fix/Bind.pm
@@ -8,11 +8,6 @@ requires 'bind';
has fixes => (is => 'rw', default => sub { [] });
-sub zero {
- my ($self) = @_;
- +{};
-}
-
sub unit {
my ($self,$data) = @_;
return $data;
@@ -23,16 +18,6 @@ sub bind {
return $code->($data);
}
-sub plus {
- my ($self,$prev,$curr) = @_;
- if ($prev == $self->zero || $curr == $self->zero) {
- $self->zero;
- }
- else {
- $curr;
- }
-}
-
sub finally {
my ($self,$data) = @_;
$data;
@@ -54,26 +39,30 @@ sub emit_bind {
my $perl = "";
- my $monad = $fixer->capture($self);
- my $m_res = $fixer->generate_var;
+ my $bind_var = $fixer->capture($self);
+ my $unit = $fixer->generate_var;
- $perl .= "my ${m_res} = ${monad}->unit(${var});";
+ # Poor man's monads using global state. Should be a bit
+ # faster than nested binds. The finally method is required
+ # to unwrap monadic values again to perl Hashes that
+ # Catmandu::Fix can understand
+ $perl .= "my ${unit} = ${bind_var}->unit(${var});";
for my $pair (@$code) {
my $name = $pair->[0];
my $code = $pair->[1];
my $code_var = $fixer->capture($code);
- $perl .= "${m_res} = ${monad}->plus(${m_res},${monad}->bind(${m_res},
sub {";
+ $perl .= "${unit} = ${bind_var}->bind(${unit}, sub {";
$perl .= "${var} = shift;";
$perl .= $code;
$perl .= "${var}";
- $perl .= "},'$name',${code_var}));"
+ $perl .= "},'$name',${code_var});"
}
- $perl .= "${var} = ${monad}->finally(${m_res});" if $self->can('finally');
+ $perl .= "${unit} = ${bind_var}->finally(${unit});" if
$self->can('finally');
my $reject = $fixer->capture($fixer->_reject);
- $perl .= "return ${var} if ${var} == ${reject};";
+ $perl .= "return ${unit} if ${unit} == ${reject};";
$perl;
}
@@ -103,7 +92,8 @@ Catmandu::Fix::Bind - a wrapper for Catmandu::Fix-es
fix3()
end
- # this will execute all the fixes as expected plus print to STDERR
+ # this will execute all the fixes as expected, and print to STDERR the
following messages
+
executing fix1
executing fix2
executing fix3
@@ -114,7 +104,7 @@ Bind is a package that wraps Catmandu::Fix-es and other
Catmandu::Bind-s togethe
the programmer further control on the excution of fixes. With
Catmandu::Fix::Bind you can simulate
the 'before', 'after' and 'around' modifiers as found in Moo or Dancer.
-To wrap Fix functions, the Fix language has provided a 'do' statment:
+To wrap Fix functions, the Fix language has a 'do' statment:
do BIND
FIX1
@@ -122,6 +112,8 @@ To wrap Fix functions, the Fix language has provided a 'do'
statment:
FIX3
end
+where BIND is a implementation of BIND and FIX1,...,FIXn are fix functions.
+
In the example above the BIND will wrap FIX1, FIX2 and FIX3.
A Catmandu::Fix::Bind needs to implement two methods: 'unit' and 'bind'.
@@ -130,62 +122,75 @@ A Catmandu::Fix::Bind needs to implement two methods:
'unit' and 'bind'.
=head2 unit($data)
-The unit method receives a Perl $data HASH and should return it. The 'unit'
method is called on a
-Catmandu::Fix::Bind instance before all Fix methods are executed. A trivial
implementation of 'unit' is:
+The unit method receives a Perl $data HASH and should return it, possibly
converted to a new type.
+The 'unit' method is called before all Fix methods are executed. A trivial,
but verbose, implementation
+of 'unit' is:
- # Wrap the data into an array
sub unit {
my ($self,$data) = @_;
- my $m_data = ['foobar',$data];
- return $m_data;
+ my $wrapped_data = $data;
+ return $wrapped_data;
}
-=head2 bind($m_data,$code,$name,$perl)
+=head2 bind($wrapped_data,$code,$name,$perl)
-The bind method is executed for every Catmandu::Fix method in the fixer. It
receives the $data
-, which as wrapped by unit, the fix method as anonymous subroutine, the name
of the fix and the actual perl
-code to run it. It should return the fixed code. A trivial implementaion of
'bind' is:
+The bind method is executed for every Catmandu::Fix method in the fix script.
It receives the $wrapped_data
+(wrapped by 'unit'), the fix method as anonymous subroutine, the name of the
fix and the actual perl
+code which runs it as a string. It should return data with the same type as
returned by 'unit'.
+A trivial, but verbose, implementaion of 'bind' is:
- # Unwrap the data and execute the given code
sub bind {
- my ($self,$m_data,$code,$name) = @_;
- my ($foo, $data) = @$m_data
- my $res = $code->($data);
- ['foobar',$res];
+ my ($self,$wrapped_data,$code,$name,$perl) = @_;
+ my $data = $wrapped_data;
+ $data = $code->($data);
+ # we don't need to wrap it again because the $data and $wrapped_data have
the same type
+ $data;
}
-=head2 zero
+=head2 finally($data)
-Optionally provide an zero unit in combining computations. E.g.
-
- sub zero {
- return undef;
+Optionally finally is executed at the end the 'do' block. This method should
be an inverse of unit (unwrap the data).
+A trivial, but verbose, implementation of 'finally' is:
+
+ sub finally {
+ my ($self,$wrapped_data) = @_;
+ my $data = $wrapped_data;
+ $data;
}
-=head2 plus($prev,$curr)
+=head1 REQUIREMENTS
-Optionally provide a function to combine the results of two computations. E.g.
+Bind mmodules are simplified implementations of Monads. They should answer the
formal definition of Monads, codified
+in 3 monadic laws:
- sub plus {
- my ($self,$prev,$curr) = @_;
- return $curr;
- }
+=head2 left unit: unit acts as a neutral element of bind
-=head2 finally($data)
+ my $monad = Catmandu::Fix::Bind->demo();
-Optionally finally is executed on the data when all the fixes in a do block
have run. A trivial example of finally is:
+ # bind(unit(data), coderef) == coderef(data)
+ $monad->bind( $monad->unit({foo=>'bar'}) , $coderef) ==
$coderef->({foo=>'bar'});
- # Unwrap the data and return the original
- sub finally {
- my ($self,$m_data) = @_;
- my ($foo, $data) = @$m_data ;
- $data;
- }
+=head2 right unit: unit act as a neutral element of bind
+
+ # bind(unit(data), unit) == unit(data)
+ $monad->bind( $monad->unit({foo=>'bar'}) , sub { $monad->unit(shift) } ) ==
$monad->unit({foo=>'bar'});
+
+=head2 associative: chaining bind blocks should have the same effect as
nesting them
+
+ # bind(bind(unit(data),f),g) == bind(unit(data), sub { return
bind(f(data),g) } )
+ my $f = sub { my $data = shift; $data->{demo} = 1 ; $data };
+ my $g = sub { my $data = shift; $data->{demo} += 1 ; $data};
+
+ $monad->bind( $monad->bind( $monad->unit({}) , f ) , g ) ==
+ $monad->bind( $monad->unit({}) , sub { my $data = shift;
$monad->bind($f->($data), $g ); $data; });
=head1 SEE ALSO
-L<Catmandu::Fix::Bind::identity>, L<Catmandu::Fix::Bind::each> ,
L<Catmandu::Fix::Bind::loop> ,
-L<Catmandu::Fix::Bind::eval>, L<Catmandu::Fix::Bind::benchmark>
+L<Catmandu::Fix::Bind::identity>, L<Catmandu::Fix::Bind::benchmark>
+
+=head1 AUTHOR
+
+Patrick Hochstenbach - L<patrick.hochstenb...@ugent.be>
=cut
diff --git a/lib/Catmandu/Fix/Bind/benchmark.pm
b/lib/Catmandu/Fix/Bind/benchmark.pm
index 807b309..c398d20 100644
--- a/lib/Catmandu/Fix/Bind/benchmark.pm
+++ b/lib/Catmandu/Fix/Bind/benchmark.pm
@@ -15,7 +15,7 @@ sub _build_stats {
sub bind {
my ($self,$data,$code,$name) = @_;
-
+ $name = '<undef>' unless defined $name;
my $t0 = [gettimeofday];
$data = $code->($data);
my $elapsed = tv_interval ( $t0 );
diff --git a/lib/Catmandu/Fix/Bind/each.pm b/lib/Catmandu/Fix/Bind/each.pm
deleted file mode 100644
index f3958d3..0000000
--- a/lib/Catmandu/Fix/Bind/each.pm
+++ /dev/null
@@ -1,81 +0,0 @@
-package Catmandu::Fix::Bind::each;
-
-use Moo;
-use Catmandu::Util qw(:data :is);
-
-with 'Catmandu::Fix::Bind';
-
-has path => (is => 'ro' , required => 1);
-has index => (is => 'ro');
-has values => (is => 'rw', default => sub { [] });
-has promises => (is => 'rw', default => sub { [] });
-
-sub bind {
- my ($self,$data,$code,$name) = @_;
-
- my $value = data_at($self->path,$data);
-
- if (defined $value && is_array_ref($value)) {
- $self->values($value);
- push @{$self->promises} , [$code,$name];
- }
-
- $data;
-}
-
-sub finally {
- my ($self,$data) = @_;
-
- for my $i (@{$self->values}) {
- for my $promise (@{$self->promises}) {
- my ($code,$name) = @$promise;
- if (defined $self->index) {
- $data->{$self->index} = $i;
- }
- $data = $code->($data);
- }
- }
-
- if (defined $self->index) {
- delete $data->{$self->index};
- }
-
- $self->promises([]);
- $self->values([]);
-
- $data;
-}
-
-=head1 NAME
-
-Catmandu::Fix::Bind::each - loop over all the values in a path
-
-=head1 SYNOPSIS
-
- add_field(demo.$append,foo)
- add_field(demo.$append,bar)
-
- do each(path => demo, index => val)
- copy_field(val,demo2.$append)
- end
-
- # demo = ['foo' , 'bar'];
- # demo2 = ['foo' , 'bar'];
-
-=head1 PARAMETERS
-
-=head2 path (required)
-
-A path to an array ref over which the 'each' needs to loop
-
-=head2 index (optional)
-
-The name of an index field that gets populated for every value on the path
-
-=head1 SEE ALSO
-
-L<Catmandu::Fix::Bind>
-
-=cut
-
-1;
diff --git a/lib/Catmandu/Fix/Bind/loop.pm b/lib/Catmandu/Fix/Bind/loop.pm
deleted file mode 100644
index 72610e5..0000000
--- a/lib/Catmandu/Fix/Bind/loop.pm
+++ /dev/null
@@ -1,42 +0,0 @@
-package Catmandu::Fix::Bind::loop;
-
-use Moo;
-
-with 'Catmandu::Fix::Bind';
-
-has count => (is => 'ro' , default => sub { 1 } );
-has index => (is => 'ro');
-has promises => (is => 'rw', default => sub { [] });
-
-sub bind {
- my ($self,$data,$code,$name) = @_;
-
- push @{$self->promises} , [$code,$name];
-
- $data;
-}
-
-sub finally {
- my ($self,$data) = @_;
-
- for (my $i = 0 ; $i < $self->count ; $i++) {
-
- for my $promise (@{$self->promises}) {
- my ($code,$name) = @$promise;
- if (defined $self->index) {
- $data->{$self->index} = $i;
- }
- $data = $code->($data);
- }
- }
-
- if (defined $self->index) {
- delete $data->{$self->index};
- }
-
- $self->promises([]);
-
- $data;
-}
-
-1;
diff --git a/t/Catmandu-Fix-Bind-benchmark.t b/t/Catmandu-Fix-Bind-benchmark.t
index 8338be8..a670e51 100644
--- a/t/Catmandu-Fix-Bind-benchmark.t
+++ b/t/Catmandu-Fix-Bind-benchmark.t
@@ -14,6 +14,16 @@ BEGIN {
}
require_ok $pkg;
+my $monad = Catmandu::Fix::Bind::benchmark->new(output => '/dev/null');
+my $f = sub { $_[0]->{demo} = 1 ; $_[0] };
+my $g = sub { $_[0]->{demo} += 1 ; $_[0] };
+
+is_deeply $monad->bind( $monad->unit({}), $f) , $f->({}) , "left unit monadic
law";
+is_deeply $monad->bind( $monad->unit({}), sub { $monad->unit(shift) }) ,
$monad->unit({}) , "right unit monadic law";
+is_deeply $monad->bind( $monad->bind( $monad->unit({}), $f ) , $g ) ,
+ $monad->bind( $monad->unit({}) , sub { $monad->bind($f->($_[0]),$g)
} ) , "associative monadic law";
+is_deeply $monad->finally( $monad->unit({hello => 'world'} ) ) , {hello =>
'world'} , "can we unwrap the monad?";
+
my $fixes =<<EOF;
do benchmark(output => /dev/null)
add_field(foo,bar)
@@ -93,4 +103,4 @@ $fixer = Catmandu::Fix->new(fixes => [$fixes]);
is_deeply $fixer->fix({foo => 'bar'}), {foo => 'bar'} , 'testing nesting';
-done_testing 10;
\ No newline at end of file
+done_testing 14;
\ No newline at end of file
diff --git a/t/Catmandu-Fix-Bind-each.t b/t/Catmandu-Fix-Bind-each.t
deleted file mode 100644
index 81acab3..0000000
--- a/t/Catmandu-Fix-Bind-each.t
+++ /dev/null
@@ -1,142 +0,0 @@
-#!/usr/bin/env perl
-use strict;
-use warnings;
-use Test::More;
-use Test::Exception;
-use Catmandu::Fix;
-use Catmandu::Importer::Mock;
-use Catmandu::Util qw(:is);
-
-my $pkg;
-BEGIN {
- $pkg = 'Catmandu::Fix::Bind::each';
- use_ok $pkg;
-}
-require_ok $pkg;
-
-my $fixes =<<EOF;
-add_field(test.\$append,1)
-do each(path => test)
- add_field(foo,bar)
-end
-remove_field(test)
-EOF
-
-my $fixer = Catmandu::Fix->new(fixes => [$fixes]);
-
-ok $fixer , 'create fixer';
-
-is_deeply $fixer->fix({}), {foo => 'bar'} , 'testing add_field';
-
-$fixes =<<EOF;
-add_field(test.\$append,1)
-do each(path => test)
-end
-remove_field(test)
-EOF
-
-$fixer = Catmandu::Fix->new(fixes => [$fixes]);
-
-is_deeply $fixer->fix({foo => 'bar'}), {foo => 'bar'} , 'testing zero fix
functions';
-
-$fixes =<<EOF;
-add_field(test.\$append,1)
-do each(path => test)
- unless exists(foo)
- add_field(foo,bar)
- end
-end
-remove_field(test)
-EOF
-
-$fixer = Catmandu::Fix->new(fixes => [$fixes]);
-
-is_deeply $fixer->fix({}), {foo => 'bar'} , 'testing unless';
-
-$fixes =<<EOF;
-add_field(test.\$append,1)
-do each(path => test)
- if exists(foo)
- add_field(foo2,bar)
- end
-end
-remove_field(test)
-EOF
-
-$fixer = Catmandu::Fix->new(fixes => [$fixes]);
-
-is_deeply $fixer->fix({foo => 'bar'}), {foo => 'bar', foo2 => 'bar'} ,
'testing if';
-
-$fixes =<<EOF;
-add_field(test.\$append,1)
-do each(path => test)
- reject exists(foo)
-end
-remove_field(test)
-EOF
-
-$fixer = Catmandu::Fix->new(fixes => [$fixes]);
-
-ok ! defined $fixer->fix({foo => 'bar'}) , 'testing reject';
-
-$fixes =<<EOF;
-add_field(test.\$append,1)
-do each(path => test)
- select exists(foo)
-end
-remove_field(test)
-EOF
-
-$fixer = Catmandu::Fix->new(fixes => [$fixes]);
-
-is_deeply $fixer->fix({foo => 'bar'}), {foo => 'bar'} , 'testing select';
-
-$fixes =<<EOF;
-add_field(test.\$append,1)
-do each(path => test)
- do each(path => test)
- do each(path => test)
- add_field(foo,bar)
- end
- end
-end
-remove_field(test)
-EOF
-
-$fixer = Catmandu::Fix->new(fixes => [$fixes]);
-
-is_deeply $fixer->fix({foo => 'bar'}), {foo => 'bar'} , 'testing nesting';
-
-$fixes =<<EOF;
-add_field(test.\$append,0)
-add_field(test.\$append,1)
-add_field(test.\$append,2)
-do each(path => test, index => i)
- copy_field(i,demo.\$append)
- copy_field(i,demo2.\$append)
-end
-remove_field(test)
-EOF
-
-$fixer = Catmandu::Fix->new(fixes => [$fixes]);
-
-is_deeply $fixer->fix({}), {demo => [(qw(0 1 2))] , demo2 => [qw(0 1 2 )]} ,
'testing specific loop';
-
-$fixes =<<EOF;
-add_field(test.\$append,0)
-add_field(test.\$append,1)
-add_field(test.\$append,2)
-do each(path => test, index => i)
- copy_field(i,demo.\$append)
- do loop(count => 3)
- copy_field(i,demo2.\$append)
- end
-end
-remove_field(test)
-EOF
-
-$fixer = Catmandu::Fix->new(fixes => [$fixes]);
-
-is_deeply $fixer->fix({}), {demo => [(qw(0 1 2))] , demo2 => [qw(0 0 0 1 1 1 2
2 2)]} , 'testing specific loop';
-
-done_testing 12;
\ No newline at end of file
diff --git a/t/Catmandu-Fix-Bind-identity.t b/t/Catmandu-Fix-Bind-identity.t
index b5989e6..e60868b 100644
--- a/t/Catmandu-Fix-Bind-identity.t
+++ b/t/Catmandu-Fix-Bind-identity.t
@@ -14,6 +14,16 @@ BEGIN {
}
require_ok $pkg;
+my $monad = Catmandu::Fix::Bind::identity->new();
+my $f = sub { $_[0]->{demo} = 1 ; $_[0] };
+my $g = sub { $_[0]->{demo} += 1 ; $_[0] };
+
+is_deeply $monad->bind( $monad->unit({}), $f) , $f->({}) , "left unit monadic
law";
+is_deeply $monad->bind( $monad->unit({}), sub { $monad->unit(shift) }) ,
$monad->unit({}) , "right unit monadic law";
+is_deeply $monad->bind( $monad->bind( $monad->unit({}), $f ) , $g ) ,
+ $monad->bind( $monad->unit({}) , sub { $monad->bind($f->($_[0]),$g)
} ) , "associative monadic law";
+is_deeply $monad->finally( $monad->unit({hello => 'world'} ) ) , {hello =>
'world'} , "can we unwrap the monad?";
+
my $fixes =<<EOF;
do identity()
add_field(foo,bar)
@@ -93,4 +103,4 @@ $fixer = Catmandu::Fix->new(fixes => [$fixes]);
is_deeply $fixer->fix({foo => 'bar'}), {foo => 'bar'} , 'testing nesting';
-done_testing 10;
\ No newline at end of file
+done_testing 14;
\ No newline at end of file
diff --git a/t/Catmandu-Fix-Bind-loop.t b/t/Catmandu-Fix-Bind-loop.t
deleted file mode 100644
index be05ed1..0000000
--- a/t/Catmandu-Fix-Bind-loop.t
+++ /dev/null
@@ -1,120 +0,0 @@
-#!/usr/bin/env perl
-use strict;
-use warnings;
-use Test::More;
-use Test::Exception;
-use Catmandu::Fix;
-use Catmandu::Importer::Mock;
-use Catmandu::Util qw(:is);
-
-my $pkg;
-BEGIN {
- $pkg = 'Catmandu::Fix::Bind::loop';
- use_ok $pkg;
-}
-require_ok $pkg;
-
-my $fixes =<<EOF;
-do loop(count => 1)
- add_field(foo,bar)
-end
-EOF
-
-my $fixer = Catmandu::Fix->new(fixes => [$fixes]);
-
-ok $fixer , 'create fixer';
-
-is_deeply $fixer->fix({}), {foo => 'bar'} , 'testing add_field';
-
-$fixes =<<EOF;
-do loop(count => 1)
-end
-EOF
-
-$fixer = Catmandu::Fix->new(fixes => [$fixes]);
-
-is_deeply $fixer->fix({foo => 'bar'}), {foo => 'bar'} , 'testing zero fix
functions';
-
-$fixes =<<EOF;
-do loop(count => 1)
- unless exists(foo)
- add_field(foo,bar)
- end
-end
-EOF
-
-$fixer = Catmandu::Fix->new(fixes => [$fixes]);
-
-is_deeply $fixer->fix({}), {foo => 'bar'} , 'testing unless';
-
-$fixes =<<EOF;
-do loop(count => 1)
- if exists(foo)
- add_field(foo2,bar)
- end
-end
-EOF
-
-$fixer = Catmandu::Fix->new(fixes => [$fixes]);
-
-is_deeply $fixer->fix({foo => 'bar'}), {foo => 'bar', foo2 => 'bar'} ,
'testing if';
-
-$fixes =<<EOF;
-do loop(count => 1)
- reject exists(foo)
-end
-EOF
-
-$fixer = Catmandu::Fix->new(fixes => [$fixes]);
-
-ok ! defined $fixer->fix({foo => 'bar'}) , 'testing reject';
-
-$fixes =<<EOF;
-do loop(count => 1)
- select exists(foo)
-end
-EOF
-
-$fixer = Catmandu::Fix->new(fixes => [$fixes]);
-
-is_deeply $fixer->fix({foo => 'bar'}), {foo => 'bar'} , 'testing select';
-
-$fixes =<<EOF;
-do loop(count => 1)
- do loop(count => 1)
- do loop(count => 1)
- add_field(foo,bar)
- end
- end
-end
-EOF
-
-$fixer = Catmandu::Fix->new(fixes => [$fixes]);
-
-is_deeply $fixer->fix({foo => 'bar'}), {foo => 'bar'} , 'testing nesting';
-
-$fixes =<<EOF;
-do loop(count => 3 , index => i)
- copy_field(i,demo.\$append)
- copy_field(i,demo2.\$append)
-end
-EOF
-
-$fixer = Catmandu::Fix->new(fixes => [$fixes]);
-
-is_deeply $fixer->fix({}), {demo => [(qw(0 1 2))] , demo2 => [qw(0 1 2 )]} ,
'testing specific loop';
-
-$fixes =<<EOF;
-do loop(count => 3 , index => i)
- copy_field(i,demo.\$append)
- do loop(count => 3)
- copy_field(i,demo2.\$append)
- end
-end
-EOF
-
-$fixer = Catmandu::Fix->new(fixes => [$fixes]);
-
-is_deeply $fixer->fix({}), {demo => [(qw(0 1 2))] , demo2 => [qw(0 0 0 1 1 1 2
2 2)]} , 'testing specific loop';
-
-done_testing 12;
--
Alioth's /usr/local/bin/git-commit-notice on
/srv/git.debian.org/git/pkg-perl/packages/libcatmandu-perl.git
_______________________________________________
Pkg-perl-cvs-commits mailing list
Pkg-perl-cvs-commits@lists.alioth.debian.org
http://lists.alioth.debian.org/cgi-bin/mailman/listinfo/pkg-perl-cvs-commits
