Perl6-Junction-1.60000/0000755000076400007640000000000012205146520014606 5ustar cafrankscafranksPerl6-Junction-1.60000/t/0000755000076400007640000000000012205146520015051 5ustar cafrankscafranksPerl6-Junction-1.60000/t/join.t0000644000076400007640000000207312151670000016172 0ustar cafrankscafranksuse strict; use Test::More tests => 21; use Perl6::Junction ':ALL'; ok( all( 3, 3.0 ) == all( 3, 3.0 ), '==' ); ok( all( 3, 3.0 ) == any( 3, 3.0 ), '==' ); ok( any( 3, 3.0 ) == all( 3, 3.0 ), '==' ); ok( all( 1, 3.0 ) == none( 2, 4, 5 ), '==' ); ok( none( 5, 6, 8 ) == all( 5, 6, 8 ), '==' ); ok( all( 1, 3.0 ) == one( 1, 3 ), '==' ); ok( one( 5, 6 ) == all( 5, 5, 5 ), '==' ); ok( not( all( 2, 3 ) == all( 2, 3 ) ), '== negated' ); ok( not( all( 2, 3 ) == any( 4, 5 ) ), '== negated' ); ok( not( any( 2, 3 ) == all( 2, 3 ) ), '== negated' ); ok( not( all( 2, 3 ) == none( 2, 3 ) ), '== negated' ); ok( not( none( 2, 3 ) == all( 2, 2 ) ), '== negated' ); ok( not( all( 2, 3 ) == one( 2, 2 ) ), '== negated' ); ok( not( one( 2, 3 ) == all( 2, 3 ) ), '== negated' ); ok( all( 3, 4, 5 ) >= all( 2, 3 ), '>=' ); ok( all( 5, 10, 15 ) > any( 3, 5, -1, 2 ), '>=' ); ok( any( 3, 4, 5 ) >= all( 3, 4, 5 ), '>=' ); ok( all( 1, 3.0 ) >= none( 4, 5, 6 ), '>=' ); ok( none( 5, 6, 8 ) >= all( 9, 10 ), '>=' ); ok( all( 3, 4 ) >= one( 3, 6 ), '>=' ); ok( one( 4, 5 ) >= all( 5, 5, 5 ), '>=' ); Perl6-Junction-1.60000/t/none.t0000644000076400007640000001016312151670000016171 0ustar cafrankscafranksuse strict; use Test::More tests => 81; use Perl6::Junction 'none'; ok( none( 2, 3.0 ) == 4, '==' ); ok( not( none( 2, 3.0 ) == 3 ), '== negated' ); ok( none( 4, 4.0 ) != 4, '!=' ); ok( not( none( 3, 4, 5 ) != 6 ), '!= negated' ); ok( none( 3, 4, 5 ) >= 6, '>=' ); ok( not( none( 3, 4, 5 ) >= 4 ), '>= negated' ); ok( not( none( 3, 4, 5 ) >= 2 ), '>= negated' ); ok( 2 >= none( 3, 4, 5 ), '>= switched' ); ok( not( 6 >= none( 3, 4, 5 ) ), '>= negated switched' ); ok( not( 3 >= none( 3, 4, 5 ) ), '>= negated switched' ); ok( none( 3, 4, 5 ) > 6, '>' ); ok( none( 3, 4, 5 ) > 5, '>' ); ok( not( none( 3, 4, 5 ) > 3 ), '> negated' ); ok( not( none( 3, 4, 5 ) > 2 ), '> negated' ); ok( 2 > none( 3, 4, 5 ), '> switched' ); ok( 3 > none( 3, 4, 5 ), '> switched' ); ok( not( 5 > none( 3, 4, 5 ) ), '> negated switched' ); ok( not( 6 > none( 3, 4, 5 ) ), '> negated switched' ); ok( none( 3, 4, 5 ) <= 2, '<=' ); ok( not( none( 3, 4, 5 ) <= 5 ), '<= negated' ); ok( not( none( 3, 4, 5 ) <= 6 ), '<= negated' ); ok( 6 <= none( 3, 4, 5 ), '<= switched' ); ok( not( 2 <= none( 3, 4, 5 ) ), '<= negated switched' ); ok( not( 4 <= none( 3, 4, 5 ) ), '<= negated switched' ); ok( not( 5 <= none( 3, 4, 5 ) ), '<= negated switched' ); ok( none( 3, 4, 5 ) < 3, '<' ); ok( none( 3, 4, 5 ) < 2, '<' ); ok( not( none( 3, 4, 5 ) < 5 ), '< negated' ); ok( not( none( 3, 4, 5 ) < 6 ), '< negated' ); ok( 6 < none( 3, 4, 5 ), '< switched' ); ok( 5 < none( 3, 4, 5 ), '< switched' ); ok( not( 2 < none( 3, 4, 5 ) ), '< negated switched' ); ok( not( 3 < none( 3, 4, 5 ) ), '< negated switched' ); ok( not( 4 < none( 3, 4, 5 ) ), '< negated switched' ); ok( none( 'g', 'h' ) eq 'i', 'eq' ); ok( not( none( 'g', 'h' ) eq 'g' ), 'eq negated' ); ok( not( none( 'g', 'g' ) eq 'g' ), 'eq negated' ); ok( none( 'h', 'h' ) ne 'h', 'ne' ); ok( not( none( 'h', 'i' ) ne 'i' ), 'ne negated' ); ok( not( none( 'i', 'i' ) ne 'j' ), 'ne negated' ); ok( none( 'g', 'h' ) ge 'i', 'ge' ); ok( not( none( 'g', 'h' ) ge 'g' ), 'ge negated' ); ok( not( none( 'g', 'g' ) ge 'g' ), 'ge negated' ); ok( 'f' ge none( 'g', 'h' ), 'ge switched' ); ok( not( 'i' ge none( 'g', 'h' ) ), 'ge negated switched' ); ok( not( 'g' ge none( 'g', 'h' ) ), 'ge negated switched' ); ok( none( 'g', 'h' ) gt 'h', 'gt' ); ok( none( 'g', 'h' ) gt 'i', 'gt' ); ok( not( none( 'g', 'h' ) gt 'f' ), 'gt negated' ); ok( not( none( 'g', 'h' ) gt 'g' ), 'gt negated' ); ok( 'f' gt none( 'g', 'h' ), 'gt switched' ); ok( not( 'h' gt none( 'g', 'h' ) ), 'gt negated switched' ); ok( not( 'i' gt none( 'g', 'h' ) ), 'gt negated switched' ); ok( none( 'g', 'h' ) le 'f', 'le' ); ok( not( none( 'g', 'h' ) le 'h' ), 'le negated' ); ok( not( none( 'g', 'h' ) le 'i' ), 'le negated' ); ok( 'i' le none( 'g', 'h' ), 'le switched' ); ok( not( 'f' le none( 'g', 'h' ) ), 'le negated switched' ); ok( not( 'g' le none( 'g', 'h' ) ), 'le negated switched' ); ok( none( 'g', 'h' ) lt 'f', 'lt' ); ok( not( none( 'g', 'h' ) lt 'i' ), 'lt negated' ); ok( not( none( 'g', 'h' ) lt 'h' ), 'lt negated' ); ok( 'i' lt none( 'g', 'h' ), 'lt switched' ); ok( not( 'f' lt none( 'g', 'h' ) ), 'lt negated switched' ); ok( not( 'g' lt none( 'g', 'h' ) ), 'lt negated switched' ); ok( none( 'a', 'b' ) == qr/\d+/, '== regex' ); ok( qr/^[ab]$/ == none( 3, 4, 5 ), '== regex' ); ok( not( none( 3, 4, 'b' ) == qr/[a-z]/ ), '== regex negated' ); ok( not( qr/\d/ == none( 'a', 'b', 5 ) ), '== regex negated' ); ok( none( 3, 4, 5 ) != qr/[0-9]/, '!= regex' ); ok( qr/[0-9]/ != none( 3, 4, 5 ), '!= regex' ); ok( none( 3, 3, 5 ) != qr/./, '!= regex' ); ok( qr/./ != none( 3, 3, 5 ), '!= regex' ); ok( not( none( 'a', 'b', 5 ) != qr/\d/ ), '!= regex negated' ); ok( not( qr/\d/ != none( 'a', 'b', 5 ) ), '!= regex negated' ); ok( none( undef, '', 0, 0.0 ), 'bool' ); ok( !none( undef, 'a' ), '! bool' ); like( none( 1, 2 ), qr/^Perl6::Junction::None=/, 'stringified to ref' ); my @data = qw(3 4 5 6 7); my $junction = none(@data); can_ok $junction, 'values'; my @values = $junction->values; is_deeply \@values, \@data, 'values() in list context'; my $values = $junction->values; is_deeply $values, \@data, 'values() in scalar context'; Perl6-Junction-1.60000/t/01_use.t0000644000076400007640000000010312151670000016317 0ustar cafrankscafranksuse strict; use Test::More tests => 1; use_ok('Perl6::Junction'); Perl6-Junction-1.60000/t/all.t0000644000076400007640000001051412151670000016002 0ustar cafrankscafranksuse strict; use Test::More tests => 90; use Perl6::Junction 'all'; ok( all( 3, 3.0 ) == 3, '==' ); ok( all( 3, 3 ) == 3, '==' ); ok( all( 3, 3.0, 3 ) == 3, '==' ); ok( not( all( 2, 3.0 ) == 3 ), '== negated' ); ok( not( all( 2, 2.0, 3 ) == 3 ), '== negated' ); ok( not( all( 2, 3, 3.0 ) == 3 ), '== negated' ); ok( all( 3, 4, 5 ) != 2, '!=' ); ok( all( 3, 3, 5 ) != 2, '!=' ); ok( all( 3, 3, 3.0 ) != 2, '!=' ); ok( not( all( 3, 4, 5 ) != 3 ), '!= negated' ); ok( not( all( 3, 3.0 ) != 3 ), '!= negated' ); ok( all( 3, 4, 5 ) >= 2, '>=' ); ok( all( 3, 4, 5 ) >= 3, '>=' ); ok( not( all( 3, 4, 5 ) >= 4 ), '>= negated' ); ok( not( all( 3, 4, 5 ) >= 5 ), '>= negated' ); ok( not( all( 3, 5, 6 ) >= 4 ), '>= negated' ); ok( 6 >= all( 3, 4, 5 ), '>= switched' ); ok( 5 >= all( 3, 4, 5 ), '>= switched' ); ok( not( 2 >= all( 3, 4, 5 ) ), '>= negated switched' ); ok( not( 3 >= all( 3, 4, 5 ) ), '>= negated switched' ); ok( not( 4 >= all( 3, 4, 5 ) ), '>= negated switched' ); ok( not( 4 >= all( 3, 5, 6 ) ), '>= negated switched' ); ok( all( 3, 4, 5 ) > 2, '>' ); ok( not( all( 3, 4, 5 ) > 4 ), '> negated' ); ok( not( all( 3, 4, 5 ) > 5 ), '> negated' ); ok( not( all( 3, 4, 5 ) > 6 ), '> negated' ); ok( 6 > all( 3, 4, 5 ), '> switched' ); ok( not( 5 > all( 3, 4, 5 ) ), '> negated switched' ); ok( not( 4 > all( 3, 4, 5 ) ), '> negated switched' ); ok( not( 3 > all( 3, 4, 5 ) ), '> negated switched' ); ok( not( 2 > all( 3, 4, 5 ) ), '> negated switched' ); ok( all( 3, 4, 5 ) <= 5, '<=' ); ok( all( 3, 4, 5 ) <= 6, '<=' ); ok( not( all( 3, 4, 5 ) <= 2 ), '<= negated' ); ok( 2 <= all( 3, 4, 5 ), '<= switched' ); ok( 3 <= all( 3, 4, 5 ), '<= switched' ); ok( not( 6 <= all( 3, 4, 5 ) ), '<= negated switched' ); ok( all( 3, 4, 5 ) < 6, '<' ); ok( not( all( 3, 4, 5 ) < 5 ), '< negated' ); ok( not( all( 3, 4, 5 ) < 2 ), '< negated' ); ok( 2 < all( 3, 4, 5 ), '< switched' ); ok( not( 5 < all( 3, 4, 5 ) ), '< negated switched' ); ok( not( 6 < all( 3, 4, 5 ) ), '< negated switched' ); ok( all( 'g', 'g' ) eq 'g', 'eq' ); ok( not( all( 'g', 'h' ) eq 'g' ), 'eq negated' ); ok( all( 'h', 'i' ) ne 'g', 'ne' ); ok( not( all( 'h', 'i' ) ne 'i' ), 'ne negated' ); ok( all( 'g', 'h' ) ge 'g', 'ge' ); ok( all( 'g', 'h' ) ge 'f', 'ge' ); ok( not( all( 'g', 'h' ) ge 'i' ), 'ge negated' ); ok( 'i' ge all( 'g', 'h' ), 'ge switched' ); ok( 'h' ge all( 'g', 'h' ), 'ge switched' ); ok( not( 'f' ge all( 'g', 'h' ) ), 'ge negated switched' ); ok( all( 'g', 'h' ) gt 'f', 'gt' ); ok( not( all( 'a', 'h' ) gt 'e' ), 'gt negated' ); ok( not( all( 'g', 'h' ) gt 'g' ), 'gt negated' ); ok( 'i' gt all( 'g', 'h' ), 'gt switched' ); ok( not( 'f' gt all( 'g', 'h' ) ), 'gt negated switched' ); ok( not( 'g' gt all( 'g', 'h' ) ), 'gt negated switched' ); ok( all( 'g', 'h' ) le 'i', 'le' ); ok( all( 'g', 'h' ) le 'h', 'le' ); ok( not( all( 'g', 'h' ) le 'f' ), 'le negated' ); ok( 'f' le all( 'g', 'h' ), 'le switched' ); ok( 'g' le all( 'g', 'h' ), 'le switched' ); ok( not( 'i' le all( 'g', 'h' ) ), 'le negated switched' ); ok( all( 'g', 'h' ) lt 'i', 'lt' ); ok( not( all( 'b', 'h' ) lt 'a' ), 'lt negated' ); ok( not( all( 'g', 'h' ) lt 'f' ), 'lt negated' ); ok( 'f' lt all( 'g', 'h' ), 'lt switched' ); ok( not( 'h' lt all( 'g', 'h' ) ), 'lt negated switched' ); ok( not( 'i' lt all( 'g', 'h' ) ), 'lt negated switched' ); ok( all( 3, 40 ) == qr/\d+/, '== regex' ); ok( qr/^[ab]$/ == all( 'a', 'b' ), '== regex' ); ok( not( all( 2, 3, 'c' ) == qr/\d+/ ), '== regex negated' ); ok( not( qr/\d/ == all( 2, 3, 'c' ) ), '== regex negated' ); ok( not( qr/[a-z]+/ == all( 'a', 'b', 3 ) ), '== regex negated' ); ok( all( 3, 4, 5 ) != qr/[a-z]/, '!= regex' ); ok( all( 'a', 'b', 'c' ) != qr/\d/, '!= regex' ); ok( not( all( 3, 4, 5 ) != qr/4/ ), '!= regex negated' ); ok( not( all( 3, 4, 'a' ) != qr/[a-z]/ ), '!= regex negated' ); ok( all( 3, 3.0 ), 'bool' ); ok( all( 3, 3 ), 'bool' ); ok( all( 3, 3.0, 3 ), 'bool' ); ok( !all( 2, 0 ), '! bool' ); ok( !all( '', 'a' ), '! bool' ); ok( !all( 'a', undef, 'c' ), '! bool' ); like( all( 1, 2 ), qr/^Perl6::Junction::All=/, 'stringified to ref' ); my @data = qw(3 4 5 6 7); my $junction = all(@data); can_ok $junction, 'values'; my @values = $junction->values; is_deeply \@values, \@data, 'values() in list context'; my $values = $junction->values; is_deeply $values, \@data, 'values() in scalar context'; Perl6-Junction-1.60000/t/no_import.t0000644000076400007640000000040112151670000017232 0ustar cafrankscafranksuse strict; use Test::More tests => 4; use Perl6::Junction; ok( Perl6::Junction::all( 3, 3.0 ) == 3, '==' ); ok( Perl6::Junction::any( 2, 3.0 ) == 2, '==' ); ok( Perl6::Junction::none( 2, 3.0 ) == 4, '==' ); ok( Perl6::Junction::one( 2, 3 ) == 2, '==' ); Perl6-Junction-1.60000/t/one.t0000644000076400007640000001120212151670000016006 0ustar cafrankscafranksuse strict; use Test::More tests => 98; use Perl6::Junction 'one'; ok( one( 2, 3 ) == 2, '==' ); ok( one( 2, 3.0 ) == 3, '==' ); ok( one( 1, 2, 3, 4, 5 ) == 2, '==' ); ok( not( one( 2, 3.0 ) == 4 ), '== negated' ); ok( not( one( 3, 3.0 ) == 3 ), '== negated' ); ok( one( 3, 4 ) != 4, '!=' ); ok( not( one( 3, 3.0 ) != 3 ), '!= negated' ); ok( not( one( 3, 4 ) != 5 ), '!= negated' ); ok( one( 3, 4, 5 ) >= 5, '>=' ); ok( one( 3, 4, 6 ) >= 5, '>=' ); ok( one( 1, 2, 3, 4, 6 ) >= 5, '>=' ); ok( not( one( 3, 4, 5 ) >= 6 ), '>= negated' ); ok( not( one( 3, 4, 5 ) >= 4 ), '>= negated' ); ok( not( one( 3, 4, 5 ) >= 2 ), '>= negated' ); ok( 4 >= one(3), '>= switched' ); ok( 4 >= one(4), '>= switched' ); ok( 4 >= one( 3, 5 ), '>= switched' ); ok( not( 2 >= one( 3, 4, 5 ) ), '>= negated switched' ); ok( not( 4 >= one( 3, 4, 5 ) ), '>= negated switched' ); ok( one( 3, 4, 5 ) > 4, '>' ); ok( one( 3, 5 ) > 4, '>' ); ok( not( one( 3, 4, 5 ) > 6 ), '> negated' ); ok( not( one( 3, 4, 5 ) > 3 ), '> negated' ); ok( 4 > one( 3, 4, 5 ), '> switched' ); ok( 4 > one( 3, 5 ), '> switched' ); ok( not( 2 > one( 3, 4, 5 ) ), '> negated switched' ); ok( not( 5 > one( 3, 4, 5 ) ), '> negated switched' ); ok( one( 3, 4, 5 ) <= 3, '<=' ); ok( one( 3, 5 ) <= 4, '<=' ); ok( not( one( 3, 4, 5 ) <= 2 ), '<= negated' ); ok( not( one( 3, 4, 5 ) <= 6 ), '<= negated' ); ok( 5 <= one( 3, 4, 5 ), '<= switched' ); ok( not( 6 <= one( 3, 4, 5 ) ), '<= negated switched' ); ok( not( 3 <= one( 3, 4, 5 ) ), '<= negated switched' ); ok( one( 3, 4, 5 ) < 4, '<' ); ok( one( 5, 4, 3 ) < 4, '<' ); ok( not( one( 3, 4, 5 ) < 2 ), '< negated' ); ok( not( one( 3, 4, 5 ) < 6 ), '< negated' ); ok( 4 < one( 3, 4, 5 ), '< switched' ); ok( 4 < one( 3, 3, 5 ), '< switched' ); ok( not( 6 < one( 3, 4, 5 ) ), '< negated switched' ); ok( not( 3 < one( 3, 4, 5 ) ), '< negated switched' ); ok( one( 'g', 'h' ) eq 'g', 'eq' ); ok( not( one( 'g', 'h' ) eq 'f' ), 'eq negated' ); ok( not( one( 'g', 'g' ) eq 'g' ), 'eq negated' ); ok( one( 'g', 'h' ) ne 'g', 'ne' ); ok( one( 'g', 'h', 'g' ) ne 'g', 'ne' ); ok( not( one( 'i', 'i' ) ne 'i' ), 'ne negated' ); ok( not( one( 'g', 'h' ) ne 'i' ), 'ne negated' ); ok( one( 'g', 'h' ) ge 'h', 'ge' ); ok( one('g') ge 'g', 'ge' ); ok( not( one( 'g', 'h' ) ge 'i' ), 'ge negated' ); ok( not( one( 'g', 'g' ) ge 'g' ), 'ge negated' ); ok( 'h' ge one( 'g', 'i' ), 'ge switched' ); ok( 'g' ge one( 'g', 'h' ), 'ge switched' ); ok( not( 'f' ge one( 'g', 'h' ) ), 'ge negated switched' ); ok( not( 'h' ge one( 'g', 'h' ) ), 'ge negated switched' ); ok( one( 'g', 'h' ) gt 'g', 'gt' ); ok( one( 'g', 'i' ) gt 'h', 'gt' ); ok( not( one( 'g', 'h' ) gt 'f' ), 'gt negated' ); ok( 'h' gt one( 'g', 'h' ), 'gt switched' ); ok( 'h' gt one( 'h', 'g' ), 'gt switched' ); ok( not( 'g' gt one( 'g', 'h' ) ), 'gt negated switched' ); ok( not( 'i' gt one( 'g', 'h' ) ), 'gt negated switched' ); ok( one( 'g', 'i' ) le 'h', 'le' ); ok( not( one( 'g', 'h' ) le 'f' ), 'le negated' ); ok( not( one( 'g', 'g' ) le 'f' ), 'le negated' ); ok( 'g' le one( 'f', 'h' ), 'le switched' ); ok( not( 'i' le one( 'g', 'h' ) ), 'le negated switched' ); ok( not( 'g' le one( 'g', 'h' ) ), 'le negated switched' ); ok( one( 'g', 'h' ) lt 'h', 'lt' ); ok( one( 'h', 'g' ) lt 'h', 'lt' ); ok( not( one( 'g', 'h' ) lt 'i' ), 'lt negated' ); ok( not( one( 'g', 'h' ) lt 'f' ), 'lt negated' ); ok( 'g' lt one( 'g', 'h' ), 'lt switched' ); ok( 'g' lt one( 'h', 'g' ), 'lt switched' ); ok( not( 'f' lt one( 'g', 'h' ) ), 'lt negated switched' ); ok( not( 'i' lt one( 'g', 'h' ) ), 'lt negated switched' ); ok( one( 3, 4, 'a' ) == qr/[a-z]/, '== regex' ); ok( qr/\d/ == one( 'a', 'b', 5 ), '== regex' ); ok( not( one( 2, 3, 'c' ) == qr/\d/ ), '== regex negated' ); ok( not( qr/\d/ == one( 2, 3, 'c' ) ), '== regex negated' ); ok( not( qr/[a-z]+/ == one( 'a', 'b', 3 ) ), '== regex negated' ); ok( one( 3, 4, 'a' ) != qr/[0-9]/, '!= regex' ); ok( qr/[0-9] != one(3,4,'a') /, '!= regex' ); ok( one( 3, 'a', 'c' ) != qr/[a-z]/, '!= regex' ); ok( qr/[a-z] != one(3,'a','c')/, '!= regex' ); ok( not( one( 3, 4, 5 ) != qr/\d/ ), '!= regex negated' ); ok( not( one( 3, 4, 5 ) != qr/[a-z]/ ), '!= regex negated' ); ok( one( 2, 0 ), 'bool' ); ok( one( undef, 'a' ), 'bool' ); ok( one( 'a', '' ), 'bool' ); ok( !one( undef, 0, '' ), '! bool' ); ok( !one( 'a', 'b' ), '! bool' ); like( one( 1, 2 ), qr/^Perl6::Junction::One=/, 'stringified to ref' ); my @data = qw(3 4 5 6 7); my $junction = one(@data); can_ok $junction, 'values'; my @values = $junction->values; is_deeply \@values, \@data, 'values() in list context'; my $values = $junction->values; is_deeply $values, \@data, 'values() in scalar context'; Perl6-Junction-1.60000/t/any.t0000644000076400007640000000677512151670000016037 0ustar cafrankscafranksuse strict; use Test::More tests => 75; use Perl6::Junction 'any'; ok( any( 2, 3.0 ) == 2, '==' ); ok( any( 2, 3.0 ) == 3, '==' ); ok( not( any( 2, 3.0 ) == 4 ), '== negated' ); ok( any( 3, 4.0 ) != 4, '!=' ); ok( any( 4, 5.0 ) != 4, '!=' ); ok( not( any( 3, 3.0 ) != 3 ), '!= negated' ); ok( any( 3, 4, 5 ) >= 5, '>=' ); ok( any( 3, 4, 5 ) >= 2, '>=' ); ok( not( any( 3, 4, 5 ) >= 6 ), '>= negated' ); ok( 6 >= any( 3, 4, 5 ), '>= switched' ); ok( 3 >= any( 3, 4, 5 ), '>= switched' ); ok( not( 2 >= any( 3, 4, 5 ) ), '>= negated switched' ); ok( any( 3, 4, 5 ) > 2, '>' ); ok( any( 3, 4, 5 ) > 3, '>' ); ok( not( any( 3, 4, 5 ) > 6 ), '> negated' ); ok( 6 > any( 3, 4, 5 ), '> switched' ); ok( 4 > any( 3, 4, 5 ), '> switched' ); ok( not( 2 > any( 3, 4, 5 ) ), '> negated switched' ); ok( any( 3, 4, 5 ) <= 5, '<=' ); ok( any( 3, 4, 5 ) <= 6, '<=' ); ok( not( any( 3, 4, 5 ) <= 2 ), '<= negated' ); ok( 5 <= any( 3, 4, 5 ), '<= switched' ); ok( 2 <= any( 3, 4, 5 ), '<= switched' ); ok( not( 6 <= any( 3, 4, 5 ) ), '<= negated switched' ); ok( any( 3, 4, 5 ) < 6, '<' ); ok( any( 5, 4, 3 ) < 4, '<' ); ok( not( any( 3, 4, 5 ) < 2 ), '< negated' ); ok( 2 < any( 3, 4, 5 ), '< switched' ); ok( 4 < any( 3, 4, 5 ), '< switched' ); ok( not( 6 < any( 3, 4, 5 ) ), '< negated switched' ); ok( any( 'g', 'h' ) eq 'g', 'eq' ); ok( any( 'g', 'g' ) eq 'g', 'eq' ); ok( not( any( 'g', 'h' ) eq 'i' ), 'eq negated' ); ok( any( 'g', 'h' ) ne 'g', 'ne' ); ok( not( any( 'i', 'i' ) ne 'i' ), 'ne negated' ); ok( any( 'g', 'h' ) ge 'f', 'ge' ); ok( any( 'g', 'h' ) ge 'g', 'ge' ); ok( not( any( 'g', 'h' ) ge 'i' ), 'ge negated' ); ok( 'i' ge any( 'g', 'h' ), 'ge switched' ); ok( 'g' ge any( 'g', 'f' ), 'ge switched' ); ok( not( 'f' ge any( 'g', 'h' ) ), 'ge negated switched' ); ok( any( 'g', 'h' ) gt 'f', 'gt' ); ok( any( 'g', 'h' ) gt 'g', 'gt' ); ok( not( any( 'g', 'h' ) gt 'i' ), 'gt negated' ); ok( 'i' gt any( 'h', 'g' ), 'gt switched' ); ok( 'h' gt any( 'h', 'g' ), 'gt switched' ); ok( not( 'g' gt any( 'g', 'h' ) ), 'gt negated switched' ); ok( not( 'f' gt any( 'g', 'h' ) ), 'gt negated switched' ); ok( any( 'g', 'h' ) le 'i', 'le' ); ok( any( 'g', 'f' ) le 'g', 'le' ); ok( not( any( 'g', 'h' ) le 'f' ), 'le negated' ); ok( 'f' le any( 'g', 'h' ), 'le switched' ); ok( 'g' le any( 'h', 'g' ), 'le switched' ); ok( not( 'i' le any( 'g', 'h' ) ), 'le negated switched' ); ok( any( 'g', 'h' ) lt 'i', 'lt' ); ok( any( 'h', 'g' ) lt 'h', 'lt' ); ok( not( any( 'g', 'h' ) lt 'f' ), 'lt negated' ); ok( 'f' lt any( 'g', 'h' ), 'lt switched' ); ok( 'g' lt any( 'h', 'g' ), 'lt switched' ); ok( not( 'i' lt any( 'g', 'h' ) ), 'lt negated switched' ); ok( any( 3, 'b' ) == qr/\d+/, '== regex' ); ok( qr/^[ab]$/ == any( 'a', 4 ), '== regex' ); ok( not( any( 'a', 'b', 'c' ) == qr/\d+/ ), '== regex negated' ); ok( not( qr/\d/ == any( 'a', 'b', 'c' ) ), '== regex negated' ); ok( not( qr/[a-z]/ == any( 3, 4, 5 ) ), '== regex negated' ); ok( any( 3, 4, 'a' ) != qr/\d/, '!= regex' ); ok( any( 3, 4, '5.0' ) != qr/^\d+$/, '!= regex' ); ok( not( any( 3, 4, 5 ) != qr/\d/ ), '!= regex negated' ); ok( any( 2, 0 ), 'bool' ); ok( any( '', 'a' ), 'bool' ); ok( !any( undef, 0 ), '! bool' ); like( any( 1, 2 ), qr/^Perl6::Junction::Any=/, 'stringified to ref' ); my @data = qw(3 4 5 6 7); my $junction = any(@data); can_ok $junction, 'values'; my @values = $junction->values; is_deeply \@values, \@data, 'values() in list context'; my $values = $junction->values; is_deeply $values, \@data, 'values() in scalar context'; Perl6-Junction-1.60000/t/import_tags.t0000644000076400007640000000030412151670000017556 0ustar cafrankscafranksuse strict; use Test::More tests => 4; use Perl6::Junction ':ALL'; ok( all( 3, 3.0 ) == 3, '==' ); ok( any( 2, 3.0 ) == 2, '==' ); ok( none( 2, 3.0 ) == 4, '==' ); ok( one( 2, 3 ) == 2, '==' ); Perl6-Junction-1.60000/lib/0000755000076400007640000000000012205146520015354 5ustar cafrankscafranksPerl6-Junction-1.60000/lib/Perl6/0000755000076400007640000000000012205146520016344 5ustar cafrankscafranksPerl6-Junction-1.60000/lib/Perl6/Junction/0000755000076400007640000000000012205146520020135 5ustar cafrankscafranksPerl6-Junction-1.60000/lib/Perl6/Junction/All.pm0000644000076400007640000000467612205146333021222 0ustar cafrankscafrankspackage Perl6::Junction::All; use strict; our $VERSION = '1.60000'; use base 'Perl6::Junction::Base'; sub num_eq { return regex_eq(@_) if ref( $_[1] ) eq 'Regexp'; my ( $self, $test ) = @_; for (@$self) { return unless $_ == $test; } return 1; } sub num_ne { return regex_ne(@_) if ref( $_[1] ) eq 'Regexp'; my ( $self, $test ) = @_; for (@$self) { return unless $_ != $test; } return 1; } sub num_ge { my ( $self, $test, $switch ) = @_; return num_le( $self, $test ) if $switch; for (@$self) { return unless $_ >= $test; } return 1; } sub num_gt { my ( $self, $test, $switch ) = @_; return num_lt( $self, $test ) if $switch; for (@$self) { return unless $_ > $test; } return 1; } sub num_le { my ( $self, $test, $switch ) = @_; return num_ge( $self, $test ) if $switch; for (@$self) { return unless $_ <= $test; } return 1; } sub num_lt { my ( $self, $test, $switch ) = @_; return num_gt( $self, $test ) if $switch; for (@$self) { return unless $_ < $test; } return 1; } sub str_eq { my ( $self, $test ) = @_; for (@$self) { return unless $_ eq $test; } return 1; } sub str_ne { my ( $self, $test ) = @_; for (@$self) { return unless $_ ne $test; } return 1; } sub str_ge { my ( $self, $test, $switch ) = @_; return str_le( $self, $test ) if $switch; for (@$self) { return unless $_ ge $test; } return 1; } sub str_gt { my ( $self, $test, $switch ) = @_; return str_lt( $self, $test ) if $switch; for (@$self) { return unless $_ gt $test; } return 1; } sub str_le { my ( $self, $test, $switch ) = @_; return str_ge( $self, $test ) if $switch; for (@$self) { return unless $_ le $test; } return 1; } sub str_lt { my ( $self, $test, $switch ) = @_; return str_gt( $self, $test ) if $switch; for (@$self) { return unless $_ lt $test; } return 1; } sub regex_eq { my ( $self, $test, $switch ) = @_; for (@$self) { return unless $_ =~ $test; } return 1; } sub regex_ne { my ( $self, $test, $switch ) = @_; for (@$self) { return unless $_ !~ $test; } return 1; } sub bool { my ($self) = @_; for (@$self) { return unless $_; } return 1; } 1; Perl6-Junction-1.60000/lib/Perl6/Junction/One.pm0000644000076400007640000000733712205146333021230 0ustar cafrankscafrankspackage Perl6::Junction::One; use strict; our $VERSION = '1.60000'; use base 'Perl6::Junction::Base'; sub num_eq { return regex_eq(@_) if ref( $_[1] ) eq 'Regexp'; my ( $self, $test ) = @_; my $count = 0; for (@$self) { if ( $_ == $test ) { return if $count; $count = 1; } } return 1 if $count; } sub num_ne { return regex_ne(@_) if ref( $_[1] ) eq 'Regexp'; my ( $self, $test ) = @_; my $count = 0; for (@$self) { if ( $_ != $test ) { return if $count; $count = 1; } } return 1 if $count; } sub num_ge { my ( $self, $test, $switch ) = @_; return num_le( $self, $test ) if $switch; my $count = 0; for (@$self) { if ( $_ >= $test ) { return if $count; $count = 1; } } return 1 if $count; } sub num_gt { my ( $self, $test, $switch ) = @_; return num_lt( $self, $test ) if $switch; my $count = 0; for (@$self) { if ( $_ > $test ) { return if $count; $count = 1; } } return 1 if $count; } sub num_le { my ( $self, $test, $switch ) = @_; return num_ge( $self, $test ) if $switch; my $count = 0; for (@$self) { if ( $_ <= $test ) { return if $count; $count = 1; } } return 1 if $count; } sub num_lt { my ( $self, $test, $switch ) = @_; return num_gt( $self, $test ) if $switch; my $count = 0; for (@$self) { if ( $_ < $test ) { return if $count; $count = 1; } } return 1 if $count; } sub str_eq { my ( $self, $test ) = @_; my $count = 0; for (@$self) { if ( $_ eq $test ) { return if $count; $count = 1; } } return 1 if $count; } sub str_ne { my ( $self, $test ) = @_; my $count = 0; for (@$self) { if ( $_ ne $test ) { return if $count; $count = 1; } } return 1 if $count; } sub str_ge { my ( $self, $test, $switch ) = @_; return str_le( $self, $test ) if $switch; my $count = 0; for (@$self) { if ( $_ ge $test ) { return if $count; $count = 1; } } return 1 if $count; } sub str_gt { my ( $self, $test, $switch ) = @_; return str_lt( $self, $test ) if $switch; my $count = 0; for (@$self) { if ( $_ gt $test ) { return if $count; $count = 1; } } return 1 if $count; } sub str_le { my ( $self, $test, $switch ) = @_; return str_ge( $self, $test ) if $switch; my $count = 0; for (@$self) { if ( $_ le $test ) { return if $count; $count = 1; } } return 1 if $count; } sub str_lt { my ( $self, $test, $switch ) = @_; return str_gt( $self, $test ) if $switch; my $count = 0; for (@$self) { if ( $_ lt $test ) { return if $count; $count = 1; } } return 1 if $count; } sub regex_eq { my ( $self, $test, $switch ) = @_; my $count = 0; for (@$self) { if ( $_ =~ $test ) { return if $count; $count = 1; } } return 1 if $count; } sub regex_ne { my ( $self, $test, $switch ) = @_; my $count = 0; for (@$self) { if ( $_ !~ $test ) { return if $count; $count = 1; } } return 1 if $count; } sub bool { my ($self) = @_; my $count = 0; for (@$self) { if ($_) { return if $count; $count = 1; } } return 1 if $count; } 1; Perl6-Junction-1.60000/lib/Perl6/Junction/None.pm0000644000076400007640000000460312205146333021377 0ustar cafrankscafrankspackage Perl6::Junction::None; use strict; our $VERSION = '1.60000'; use base 'Perl6::Junction::Base'; sub num_eq { return regex_eq(@_) if ref( $_[1] ) eq 'Regexp'; my ( $self, $test ) = @_; for (@$self) { return if $_ == $test; } return 1; } sub num_ne { return regex_ne(@_) if ref( $_[1] ) eq 'Regexp'; my ( $self, $test ) = @_; for (@$self) { return if $_ != $test; } return 1; } sub num_ge { my ( $self, $test, $switch ) = @_; return num_le( $self, $test ) if $switch; for (@$self) { return if $_ >= $test; } return 1; } sub num_gt { my ( $self, $test, $switch ) = @_; return num_lt( $self, $test ) if $switch; for (@$self) { return if $_ > $test; } return 1; } sub num_le { my ( $self, $test, $switch ) = @_; return num_ge( $self, $test ) if $switch; for (@$self) { return if $_ <= $test; } return 1; } sub num_lt { my ( $self, $test, $switch ) = @_; return num_gt( $self, $test ) if $switch; for (@$self) { return if $_ < $test; } return 1; } sub str_eq { my ( $self, $test ) = @_; for (@$self) { return if $_ eq $test; } return 1; } sub str_ne { my ( $self, $test ) = @_; for (@$self) { return if $_ ne $test; } return 1; } sub str_ge { my ( $self, $test, $switch ) = @_; return str_le( $self, $test ) if $switch; for (@$self) { return if $_ ge $test; } return 1; } sub str_gt { my ( $self, $test, $switch ) = @_; return str_lt( $self, $test ) if $switch; for (@$self) { return if $_ gt $test; } return 1; } sub str_le { my ( $self, $test, $switch ) = @_; return str_ge( $self, $test ) if $switch; for (@$self) { return if $_ le $test; } return 1; } sub str_lt { my ( $self, $test, $switch ) = @_; return str_gt( $self, $test ) if $switch; for (@$self) { return if $_ lt $test; } return 1; } sub regex_eq { my ( $self, $test, $switch ) = @_; for (@$self) { return if $_ =~ $test; } return 1; } sub regex_ne { my ( $self, $test, $switch ) = @_; for (@$self) { return if $_ !~ $test; } return 1; } sub bool { my ($self) = @_; for (@$self) { return if $_; } return 1; } 1; Perl6-Junction-1.60000/lib/Perl6/Junction/Any.pm0000644000076400007640000000460212205146333021226 0ustar cafrankscafrankspackage Perl6::Junction::Any; use strict; our $VERSION = '1.60000'; use base 'Perl6::Junction::Base'; sub num_eq { return regex_eq(@_) if ref( $_[1] ) eq 'Regexp'; my ( $self, $test ) = @_; for (@$self) { return 1 if $_ == $test; } return; } sub num_ne { return regex_ne(@_) if ref( $_[1] ) eq 'Regexp'; my ( $self, $test ) = @_; for (@$self) { return 1 if $_ != $test; } return; } sub num_ge { my ( $self, $test, $switch ) = @_; return num_le( $self, $test ) if $switch; for (@$self) { return 1 if $_ >= $test; } return; } sub num_gt { my ( $self, $test, $switch ) = @_; return num_lt( $self, $test ) if $switch; for (@$self) { return 1 if $_ > $test; } return; } sub num_le { my ( $self, $test, $switch ) = @_; return num_ge( $self, $test ) if $switch; for (@$self) { return 1 if $_ <= $test; } return; } sub num_lt { my ( $self, $test, $switch ) = @_; return num_gt( $self, $test ) if $switch; for (@$self) { return 1 if $_ < $test; } return; } sub str_eq { my ( $self, $test ) = @_; for (@$self) { return 1 if $_ eq $test; } return; } sub str_ne { my ( $self, $test ) = @_; for (@$self) { return 1 if $_ ne $test; } return; } sub str_ge { my ( $self, $test, $switch ) = @_; return str_le( $self, $test ) if $switch; for (@$self) { return 1 if $_ ge $test; } return; } sub str_gt { my ( $self, $test, $switch ) = @_; return str_lt( $self, $test ) if $switch; for (@$self) { return 1 if $_ gt $test; } return; } sub str_le { my ( $self, $test, $switch ) = @_; return str_ge( $self, $test ) if $switch; for (@$self) { return 1 if $_ le $test; } return; } sub str_lt { my ( $self, $test, $switch ) = @_; return str_gt( $self, $test ) if $switch; for (@$self) { return 1 if $_ lt $test; } return; } sub regex_eq { my ( $self, $test, $switch ) = @_; for (@$self) { return 1 if $_ =~ $test; } return; } sub regex_ne { my ( $self, $test, $switch ) = @_; for (@$self) { return 1 if $_ !~ $test; } return; } sub bool { my ($self) = @_; for (@$self) { return 1 if $_; } return; } 1; Perl6-Junction-1.60000/lib/Perl6/Junction/Base.pm0000644000076400007640000000111612205146333021346 0ustar cafrankscafrankspackage Perl6::Junction::Base; use strict; our $VERSION = '1.60000'; use overload( '==' => "num_eq", '!=' => "num_ne", '>=' => "num_ge", '>' => "num_gt", '<=' => "num_le", '<' => "num_lt", 'eq' => "str_eq", 'ne' => "str_ne", 'ge' => "str_ge", 'gt' => "str_gt", 'le' => "str_le", 'lt' => "str_lt", 'bool' => "bool", '""' => sub {shift}, ); sub new { my ( $class, @param ) = @_; return bless \@param, $class; } sub values { my $self = shift; return wantarray ? @$self : [ @$self ]; } 1; Perl6-Junction-1.60000/lib/Perl6/Junction.pm0000644000076400007640000001030512205146333020474 0ustar cafrankscafrankspackage Perl6::Junction; use strict; use Perl6::Junction::All; use Perl6::Junction::Any; use Perl6::Junction::None; use Perl6::Junction::One; require Exporter; our $VERSION = '1.60000'; our @ISA = qw/ Exporter /; my @routines = qw/ all any none one /; our @EXPORT_OK = @routines; our %EXPORT_TAGS = ( ALL => [@routines] ); sub all { return Perl6::Junction::All->new(@_); } sub any { return Perl6::Junction::Any->new(@_); } sub none { return Perl6::Junction::None->new(@_); } sub one { return Perl6::Junction::One->new(@_); } 1; __END__ =head1 NAME Perl6::Junction - Perl6 style Junction operators in Perl5. =head1 SYNOPSIS use Perl6::Junction qw/ all any none one /; if (any(@grant) eq 'su') { ... } if (all($foo, $bar) >= 10) { ... } if (qr/^\d+$/ == all(@answers)) { ... } if (all(@input) <= @limits) { ... } if (none(@pass) eq 'password') { ... } if (one(@answer) == 42) { ... } =head1 DESCRIPTION This is a lightweight module which provides 'Junction' operators, the most commonly used being C and C. Inspired by the Perl6 design docs, L. Provides a limited subset of the functionality of L, see L for comment. Notice in the L above, that if you want to match against a regular expression, you must use C<==> or C. B C<=~> or C. You must also use a regex object, such as C, not a plain regex such as C. =head1 SUBROUTINES =head2 all() Returns an object which overloads the following operators: '<', '<=', '>', '>=', '==', '!=', 'lt', 'le', 'gt', 'ge', 'eq', 'ne', Returns true only if B arguments test true according to the operator used. =head2 any() Returns an object which overloads the following operators: '<', '<=', '>', '>=', '==', '!=', 'lt', 'le', 'gt', 'ge', 'eq', 'ne', Returns true if B argument tests true according to the operator used. =head2 none() Returns an object which overloads the following operators: '<', '<=', '>', '>=', '==', '!=', 'lt', 'le', 'gt', 'ge', 'eq', 'ne', Returns true only if B argument tests true according to the operator used. =head2 one() Returns an object which overloads the following operators: '<', '<=', '>', '>=', '==', '!=', 'lt', 'le', 'gt', 'ge', 'eq', 'ne', Returns true only if B argument tests true according to the operator used. =head1 ALTERING JUNCTIONS You cannot alter junctions. Instead, you can create new junctions out of old junctions. You can do this by calling the C method on a junction. my $numbers = any(qw/1 2 3 4 5/); print $numbers == 3 ? 'Yes' : 'No'; # Yes $numbers = any( grep { $_ != 3 } $numbers->values ); print $numbers == 3 ? 'Yes' : 'No'; # No =head1 EXPORT 'all', 'any', 'none', 'one', as requested. All subroutines can be called by its fully qualified name, if you don't want to export them. use Perl6::Junction; if (Perl6::Junction::any( @questions )) { ... } =head1 WARNING When comparing against a regular expression, you must remember to use a regular expression object: C B C. You must also use either C<==> or C. This is because C<=~> and C cannot be overriden. =head1 TO DO Add overloading for arithmetic operators, such that this works: $result = any(2,3,4) * 2; if ($result == 8) {...} =head1 SUPPORT / BUGS Submit to the CPAN bugtracker L =head1 SEE ALSO L provides the same functionality as this, and more. However, this module provides this limited functionality at a much greater runtime speed, with my benchmarks showing between 500% and 6000% improvment. L - "The Wonderful World of Junctions". =head1 AUTHOR Carl Franks =head1 ACKNOWLEDGEMENTS Thanks to C for the L changes in release C<0.40000>. =head1 COPYRIGHT AND LICENSE Copyright 2005, Carl Franks. All rights reserved. This library is free software; you can redistribute it and/or modify it under the same terms as Perl itself (L, L). =cut Perl6-Junction-1.60000/Changes0000644000076400007640000000163312205146213016103 0ustar cafrankscafranks1.60000 2013-08-21 - Removed support for smartmatch - as of perl 5.18.0 smartmatch is marked as experimental, and subject to change or removal. 1.50000 2012-09-11 - Add support for smartmatch (~~) for perl 5.10.1 and higher. (Ricardo Signes) 1.40000 2008-06-20 - Added 'values' method to ensure that we can fetch data from junctions and create new junctions based upon old ones. 1.30000 2007-05-11 - Non-development release. - Moved .pm files into lib directory 1.20_01 2007-01-08 - Added :ALL export tag (RT #16429). - Added bool and string overloading to stop fatal errors on stringification (RT #24237). - Removed duplicated tests. - Ran files through perltidy. 1.10 2005-05-13 - Bugfix: error in none() and one() when comparing a Regexp object with != 1.00 2005-05-13 - Initial release, includes test suite. Perl6-Junction-1.60000/MYMETA.json0000644000076400007640000000160412205146511016476 0ustar cafrankscafranks{ "abstract" : "Perl6 style Junction operators in Perl5.", "author" : [ "Carl Franks" ], "dynamic_config" : 0, "generated_by" : "ExtUtils::MakeMaker version 6.6302, CPAN::Meta::Converter version 2.120630", "license" : [ "perl_5" ], "meta-spec" : { "url" : "http://search.cpan.org/perldoc?CPAN::Meta::Spec", "version" : "2" }, "name" : "Perl6-Junction", "no_index" : { "directory" : [ "t", "inc" ] }, "prereqs" : { "build" : { "requires" : { "ExtUtils::MakeMaker" : "0" } }, "configure" : { "requires" : { "ExtUtils::MakeMaker" : "0" } }, "runtime" : { "requires" : { "Carp" : "0", "Test::More" : "0" } } }, "release_status" : "stable", "version" : "1.60000" } Perl6-Junction-1.60000/MYMETA.yml0000644000076400007640000000076012205146511016330 0ustar cafrankscafranks--- abstract: 'Perl6 style Junction operators in Perl5.' author: - 'Carl Franks' build_requires: ExtUtils::MakeMaker: 0 configure_requires: ExtUtils::MakeMaker: 0 dynamic_config: 0 generated_by: 'ExtUtils::MakeMaker version 6.6302, CPAN::Meta::Converter version 2.120630' license: perl meta-spec: url: http://module-build.sourceforge.net/META-spec-v1.4.html version: 1.4 name: Perl6-Junction no_index: directory: - t - inc requires: Carp: 0 Test::More: 0 version: 1.60000 Perl6-Junction-1.60000/MANIFEST0000644000076400007640000000062612151670000015736 0ustar cafrankscafranksChanges lib/Perl6/Junction.pm lib/Perl6/Junction/All.pm lib/Perl6/Junction/Any.pm lib/Perl6/Junction/Base.pm lib/Perl6/Junction/None.pm lib/Perl6/Junction/One.pm Makefile.PL MANIFEST This list of files README t/01_use.t t/all.t t/any.t t/import_tags.t t/join.t t/no_import.t t/none.t t/one.t META.yml Module meta-data (added by MakeMaker) META.json MYMETA.yml MYMETA.json Perl6-Junction-1.60000/Makefile.PL0000644000076400007640000000054712151670000016561 0ustar cafrankscafranksuse 5.000; use ExtUtils::MakeMaker; WriteMakefile( NAME => 'Perl6::Junction', AUTHOR => 'Carl Franks', ABSTRACT_FROM => 'lib/Perl6/Junction.pm', VERSION_FROM => 'lib/Perl6/Junction.pm', LICENSE => 'perl', PREREQ_PM => { Carp => 0, Test::More => 0, }, ); Perl6-Junction-1.60000/README0000644000076400007640000000134012151670000015457 0ustar cafrankscafranks Perl6::Junction DESCRIPTION Perl6 style Junction operators in Perl5. This is a lightweight module which provides 'Junction' operators, the most commonly used being 'any' and 'all'. Inspired by the Perl6 design docs, . DOCUMENTATION The documentation is in Junction.pm in the form of POD format perldocs. INSTALLATION To install this module type the following: perl Makefile.PL make make test make install COPYRIGHT Copyright 2005, Carl Franks. All rights reserved. This library is free software; you can redistribute it and/or modify it under the same terms as Perl itself. Perl6-Junction-1.60000/META.yml0000664000076400007640000000076012205146520016064 0ustar cafrankscafranks--- abstract: 'Perl6 style Junction operators in Perl5.' author: - 'Carl Franks' build_requires: ExtUtils::MakeMaker: 0 configure_requires: ExtUtils::MakeMaker: 0 dynamic_config: 1 generated_by: 'ExtUtils::MakeMaker version 6.6302, CPAN::Meta::Converter version 2.120630' license: perl meta-spec: url: http://module-build.sourceforge.net/META-spec-v1.4.html version: 1.4 name: Perl6-Junction no_index: directory: - t - inc requires: Carp: 0 Test::More: 0 version: 1.60000 Perl6-Junction-1.60000/META.json0000664000076400007640000000160412205146520016232 0ustar cafrankscafranks{ "abstract" : "Perl6 style Junction operators in Perl5.", "author" : [ "Carl Franks" ], "dynamic_config" : 1, "generated_by" : "ExtUtils::MakeMaker version 6.6302, CPAN::Meta::Converter version 2.120630", "license" : [ "perl_5" ], "meta-spec" : { "url" : "http://search.cpan.org/perldoc?CPAN::Meta::Spec", "version" : "2" }, "name" : "Perl6-Junction", "no_index" : { "directory" : [ "t", "inc" ] }, "prereqs" : { "build" : { "requires" : { "ExtUtils::MakeMaker" : "0" } }, "configure" : { "requires" : { "ExtUtils::MakeMaker" : "0" } }, "runtime" : { "requires" : { "Carp" : "0", "Test::More" : "0" } } }, "release_status" : "stable", "version" : "1.60000" }