view release on metacpan or  search on metacpan

inc/Test/Base.pm  view on Meta::CPAN

    eval { require Text::Diff; 1 } &&
        $Text::Diff::VERSION >= 0.35 &&
        $Algorithm::Diff::VERSION >= 1.15;
}

sub is($$;$) {
    (my ($self), @_) = find_my_self(@_);
    my ($actual, $expected, $name) = @_;
    local $Test::Builder::Level = $Test::Builder::Level + 1;
    if ($ENV{TEST_SHOW_NO_DIFFS} or
         not defined $actual or

 view release on metacpan or  search on metacpan

lib/HTTP/UserAgentString/Browser.pm  view on Meta::CPAN

	return bless($h, $pkg);
}

sub type($) { $_[0]->{type} }
sub info_url($) { $_[0]->{info_url} }
sub os($) { $_[0]->{os} }
sub version($) { $_[0]->{version} }
sub major_version($) { $_[0]->{major_version} }
sub minor_version($) { $_[0]->{minor_version} }
sub typeDesc($) { $_[0]->{typeDesc} }

 view release on metacpan or  search on metacpan

inc/Test/Base.pm  view on Meta::CPAN

    eval { require Text::Diff; 1 } &&
        $Text::Diff::VERSION >= 0.35 &&
        $Algorithm::Diff::VERSION >= 1.15;
}

sub is($$;$) {
    (my ($self), @_) = find_my_self(@_);
    my ($actual, $expected, $name) = @_;
    local $Test::Builder::Level = $Test::Builder::Level + 1;
    if ($ENV{TEST_SHOW_NO_DIFFS} or
         not defined $actual or

 view release on metacpan or  search on metacpan

t/lib/Hailo/Test/TimToady.trn  view on Meta::CPAN

=== always fails for differing types (in the absence of MMD)
don't follow...
2,"2" doesn't even see Str,Str
we haven't really nailed down MMD distance yet, except to nail up Manhattan...
probably needs a slightly more formal proposal.
sub f (Dog $x) already means 'does', so 'as' is probably better for coercion.
Unless we mean 'to'.
Yeah, and 'does' says 'can you do this without changing yourself?'
nothingmuch: yes
C++ handles all that with constructor/coercion
That's why I originally had coerce:<as> make both coercion and constructor semantics, if I recall...

 view release on metacpan or  search on metacpan

inc/Test/Base.pm  view on Meta::CPAN

    eval { require Text::Diff; 1 } &&
        $Text::Diff::VERSION >= 0.35 &&
        $Algorithm::Diff::VERSION >= 1.15;
}

sub is($$;$) {
    (my ($self), @_) = find_my_self(@_);
    my ($actual, $expected, $name) = @_;
    local $Test::Builder::Level = $Test::Builder::Level + 1;
    if ($ENV{TEST_SHOW_NO_DIFFS} or
         not defined $actual or

 view release on metacpan or  search on metacpan

lib/IMAP/Client.pm  view on Meta::CPAN

None of the keys are required - if the client wishes not to supply information for a key, the key is simply omitted.  Not all clients support this extention:  Support can be identified by using the capability() command, and verifying the atom "ID" is...

=cut

sub id($%) {
    my ($self,%perams) = @_;
    my $peramlist;

    return($self->throw_error("ID not supported for ID command")) unless ($self->check_capability('ID'));

 view release on metacpan or  search on metacpan

lib/IOMux/Handler.pm  view on Meta::CPAN

sub name()   {shift->{IH_name}}
sub mux()    {shift->{IH_mux}}


sub fileno() {shift->{IH_fileno}}
sub fh()     {shift->{IH_fh}}
sub usesSSL(){shift->{IH_uses_ssl}}

#-----------------------

sub timeout(;$)

 view release on metacpan or  search on metacpan

IPC/MPS.pm  view on Meta::CPAN

		$ipc_loop = 0;
	}
}


sub wt($$) {
	my ($waited_vpid, $waited_msg) = @_;
	defined $waited_vpid or carp("Argument vpid required"), return;
	defined $waited_msg  or carp("Argument msg required"),  return;
	$waited_vpid = $self_parent_vpid if $waited_vpid == 0;
	foreach my $i (0 .. $#rcv) {

 view release on metacpan or  search on metacpan

lib/Image/ExifTool/MXF.pm  view on Meta::CPAN

#------------------------------------------------------------------------------
# Convert 16 bytes to UL format
# Inputs: 0) 16-byte value
# Returns: UL string
sub UL($)
{
    return join('.', unpack('H8H4H4H8H8', shift));;
}

#------------------------------------------------------------------------------

 view release on metacpan or  search on metacpan

lib/JE/Parser.pm  view on Meta::CPAN

	push @$_vars, $ret;

	bless $ret, JECS;
}

sub if() {
	my $pos = pos;
	/\Gif$s\($s/cg or return;
	my $ret = [[$pos], 'if'];

	@$ret == push @$ret, &expr

lib/JE/Parser.pm  view on Meta::CPAN

	push @{$$ret[0]},pos;

	bless $ret, JECS;
}

sub do() {
	my $pos = pos;
	/\G do(?!$id_cont)$s/cgx or return;
	my $ret = [[$pos], 'do'];

	@$ret != push @$ret, &statement

 view release on metacpan or  search on metacpan

inc/Test/Base.pm  view on Meta::CPAN

        $Text::Diff::VERSION >= 0.35 &&
        $Algorithm::Diff::VERSION >= 1.15;
}

provides 'is';
sub is($$;$) {
    (my ($self), @_) = find_my_self(@_);
    my ($actual, $expected, $name) = @_;
    local $Test::Builder::Level = $Test::Builder::Level + 1 unless $HAS_PROVIDER;
    if ($ENV{TEST_SHOW_NO_DIFFS} or
         not defined $actual or

 view release on metacpan or  search on metacpan

t/01_utf8.t  view on Meta::CPAN

use utf8;
use JSON::SIMD;

our $test;
sub ok($) {
   print $_[0] ? "" : "not ", "ok ", ++$test, "\n";
}

ok (JSON::SIMD->new->allow_nonref (1)->utf8 (1)->encode ("ü") eq "\"\xc3\xbc\"");
ok (JSON::SIMD->new->allow_nonref (1)->encode ("ü") eq "\"ü\"");

 view release on metacpan or  search on metacpan

lib/JSON/Schema/Modern/Utilities.pm  view on Meta::CPAN

# - recommended_response (optional)
# - depth
# - traverse (boolean, used for mode)
# returns defined-false, so callers can use 'return;' to differentiate between
# failed-with-no-error from failed-with-error.
sub E ($state, $error_string, @args) {
  croak 'E called in void context' if not defined wantarray;

  # sometimes the keyword shouldn't be at the very end of the schema path
  my $sps = delete $state->{_keyword_path_suffix};
  my @keyword_path_suffix = defined $sps && ref $sps eq 'ARRAY' ? $sps->@* : $sps//();

lib/JSON/Schema/Modern/Utilities.pm  view on Meta::CPAN

# - keyword_path
# - annotations
# - collect_annotations
# - _unknown (boolean)
# - depth
sub A ($state, $annotation) {
  # even if the user requested annotations, we only collect them for later drafts
  # ..but we always collect them if the lowest bit is set, indicating the presence of unevaluated*
  # keywords necessary for accurate validation
  return 1 if not ($state->{collect_annotations}
    & ($state->{specification_version} =~ /^draft[467]\z/ ? ~(1<<8) : ~0));

 view release on metacpan or  search on metacpan

lib/JSON/Schema/Tiny.pm  view on Meta::CPAN

  $uri;
}

# shorthand for creating error objects
# based on JSON::Schema::Modern::Utilities::E
sub E ($state, $error_string, @args) {
  # sometimes the keyword shouldn't be at the very end of the schema path
  my $sps = delete $state->{_schema_path_suffix};
  my @schema_path_suffix = defined $sps && is_plain_arrayref($sps) ? $sps->@* : $sps//();

  my $uri = canonical_uri($state, $state->{keyword}, @schema_path_suffix);

 view release on metacpan or  search on metacpan

t/01_utf8.t  view on Meta::CPAN

use utf8;
use JSON::XS;

our $test;
sub ok($) {
   print $_[0] ? "" : "not ", "ok ", ++$test, "\n";
}

ok (JSON::XS->new->allow_nonref (1)->utf8 (1)->encode ("ü") eq "\"\xc3\xbc\"");
ok (JSON::XS->new->allow_nonref (1)->encode ("ü") eq "\"ü\"");

 view release on metacpan or  search on metacpan

lib/JSON/ize.pm  view on Meta::CPAN

    }
  }
}

sub jsonise (;$) { jsonize($_[0]) }
sub J (;$) { jsonize($_[0]) }
sub yamlize (;$) { jsonize($_[0]) }
sub yamlise (;$) { jsonize($_[0]) }
sub Y (;$) { jsonize($_[0]) }


sub parsej () {
  $_last_out = $JOBJ->incr_parse($_);
}

 view release on metacpan or  search on metacpan

inc/Test/Base.pm  view on Meta::CPAN

    eval { require Text::Diff; 1 } &&
        $Text::Diff::VERSION >= 0.35 &&
        $Algorithm::Diff::VERSION >= 1.15;
}

sub is($$;$) {
    (my ($self), @_) = find_my_self(@_);
    my ($actual, $expected, $name) = @_;
    local $Test::Builder::Level = $Test::Builder::Level + 1;
    if ($ENV{TEST_SHOW_NO_DIFFS} or
         not defined $actual or

 view release on metacpan or  search on metacpan

inc/Test/Base.pm  view on Meta::CPAN

    eval { require Text::Diff; 1 } &&
        $Text::Diff::VERSION >= 0.35 &&
        $Algorithm::Diff::VERSION >= 1.15;
}

sub is($$;$) {
    (my ($self), @_) = find_my_self(@_);
    my ($actual, $expected, $name) = @_;
    local $Test::Builder::Level = $Test::Builder::Level + 1;
    if ($ENV{TEST_SHOW_NO_DIFFS} or
         not defined $actual or

 view release on metacpan or  search on metacpan

inc/Test/Base.pm  view on Meta::CPAN

    eval { require Text::Diff; 1 } &&
        $Text::Diff::VERSION >= 0.35 &&
        $Algorithm::Diff::VERSION >= 1.15;
}

sub is($$;$) {
    (my ($self), @_) = find_my_self(@_);
    my ($actual, $expected, $name) = @_;
    local $Test::Builder::Level = $Test::Builder::Level + 1;
    if ($ENV{TEST_SHOW_NO_DIFFS} or
         not defined $actual or

 view release on metacpan or  search on metacpan

lib/Kwargs.pm  view on Meta::CPAN

    my $hash  = @$array == 1 ? $array->[0] : { @$array };
    return (@pos, $hash) unless @_;
    return (@pos, @{$hash}{@_});
}

sub kw(\@@) {
    splice(@_, 1, 0, 0);
    goto &kwn;
}

1;

 view release on metacpan or  search on metacpan

inc/Test/Base.pm  view on Meta::CPAN

    eval { require Text::Diff; 1 } &&
        $Text::Diff::VERSION >= 0.35 &&
        $Algorithm::Diff::VERSION >= 1.15;
}

sub is($$;$) {
    (my ($self), @_) = find_my_self(@_);
    my ($actual, $expected, $name) = @_;
    local $Test::Builder::Level = $Test::Builder::Level + 1;
    if ($ENV{TEST_SHOW_NO_DIFFS} or
         not defined $actual or

 view release on metacpan or  search on metacpan

test.pl  view on Meta::CPAN

use strict;
ok(1); # If we made it this far, we're ok (1)

my ($str, $res);

sub fp($) {
    perl2fp(fp_eval shift);
}

sub alltests {

 view release on metacpan or  search on metacpan

Functional.pm  view on Meta::CPAN

  or        :: [Bool] -> Bool
  or         = foldr (||) False

=cut

sub Or($) {
  my $xs = shift;
  map {
    return 1 if $_;
  } @{$xs};
  return 0;

 view release on metacpan or  search on metacpan

inc/Test/Base.pm  view on Meta::CPAN

    eval { require Text::Diff; 1 } &&
        $Text::Diff::VERSION >= 0.35 &&
        $Algorithm::Diff::VERSION >= 1.15;
}

sub is($$;$) {
    (my ($self), @_) = find_my_self(@_);
    my ($actual, $expected, $name) = @_;
    local $Test::Builder::Level = $Test::Builder::Level + 1;
    if ($ENV{TEST_SHOW_NO_DIFFS} or
         not defined $actual or

 view release on metacpan or  search on metacpan

inc/Test/Base.pm  view on Meta::CPAN

        $Text::Diff::VERSION >= 0.35 &&
        $Algorithm::Diff::VERSION >= 1.15;
}

provides 'is';
sub is($$;$) {
    (my ($self), @_) = find_my_self(@_);
    my ($actual, $expected, $name) = @_;
    local $Test::Builder::Level = $Test::Builder::Level + 1 unless $HAS_PROVIDER;
    if ($ENV{TEST_SHOW_NO_DIFFS} or
         not defined $actual or

 view release on metacpan or  search on metacpan

t/procedural.t  view on Meta::CPAN

use Test::More;

BEGIN { use_ok("Lingua::EN::BioLemmatizer", "biolemma") };

# return first whitespace-separated "word" in argument string
sub fw($) {
    my($string) = @_;
    my @words = split /\s+/, $string;
    return $words[0];
} 

 view release on metacpan or  search on metacpan

t/inflections.t  view on Meta::CPAN

use Lingua::EN::Inflect qw( :ALL );
$loaded = 1;
print "ok 1\n";

my $count = 2;
sub ok($;$$)
{
    my $ok = $_[0];
    print "not " unless $ok;
    print "ok $count";
    print "\t# $_[1]" if $_[1];

 view release on metacpan or  search on metacpan

t/30_v1_tests.t  view on Meta::CPAN

use Lingua::EN::Numbers qw(num2en num2en_ordinal);
print "# Using Lingua::EN::Numbers v$Lingua::EN::Numbers::VERSION\n";
ok 1;

sub N ($) { num2en(        $_[0]) }
sub O ($) { num2en_ordinal($_[0]) }

ok N   0, 'zero';
ok N   1, 'one';
ok N   2, 'two';
ok N   3, 'three';

 view release on metacpan or  search on metacpan

t/inflections.t  view on Meta::CPAN

use Lingua::ENG::Inflect qw( :ALL );
$loaded = 1;
print "ok 1\n";

my $count = 2;
sub ok($;$$)
{
	my $ok = $_[0];
	print "not " unless $ok;
	print "ok $count";
	print "\t# $_[1]" if $_[1];

 view release on metacpan or  search on metacpan

inc/Test/Base.pm  view on Meta::CPAN

    eval { require Text::Diff; 1 } &&
        $Text::Diff::VERSION >= 0.35 &&
        $Algorithm::Diff::VERSION >= 1.15;
}

sub is($$;$) {
    (my ($self), @_) = find_my_self(@_);
    my ($actual, $expected, $name) = @_;
    local $Test::Builder::Level = $Test::Builder::Level + 1;
    if ($ENV{TEST_SHOW_NO_DIFFS} or
         not defined $actual or