1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
25
26
27
28
29
30
31
32
33
34
35
36
37
38
39
40
41
42
43
44
45
46
47
48
49
50
51
52
53
54
55
56
57
58
59
60
61
62
63
64
65
66
67
68
69
70
71
72
73
74
75
76
77
78
79
80
81
82
83
84
85
86
87
88
89
90
91
92
93
94
95
96
97
98
99
100
101
102
103
104
105
106
107
108
109
110
111
112
113
114
115
116
117
118
119
120
121
122
123
124
125
126
127
128
129
130
131
132
133
134
135
136
137
138
139
140
141
142
143
144
145
146
147
148
149
150
151
152
153
154
155
156
157
158
159
160
161
162
163
164
165
|
# You may distribute under the terms of either the GNU General Public License
# or the Artistic License (the same terms as Perl itself)
#
# (C) Paul Evans, 2022-2024 -- leonerd@leonerd.org.uk
package Syntax::Operator::Elem 0.10;
use v5.14;
use warnings;
use Carp;
use meta 0.003_002;
no warnings 'meta::experimental';
=encoding UTF-8
=head1 NAME
C<Syntax::Operator::Elem> - element-of-list operators
=head1 SYNOPSIS
On Perl v5.38 or later:
use Syntax::Operator::Elem;
if($x elem @some_strings) {
say "x is one of the given strings";
}
Or on Perl v5.14 or later:
use v5.14;
use Syntax::Operator::Elem qw( elem_str );
if(elem_str $x, @some_strings) {
say "x is one of the given strings";
}
=head1 DESCRIPTION
This module provides infix operators that implement element-of-list tests for
strings and numbers.
Support for custom infix operators was added in the Perl 5.37.x development
cycle and is available from development release v5.37.7 onwards, and therefore
in Perl v5.38 onwards. The documentation of L<XS::Parse::Infix>
describes the situation in more detail.
While Perl versions before this do not support custom infix operators, they
can still be used via C<XS::Parse::Infix> and hence L<XS::Parse::Keyword>.
Custom keywords which attempt to parse operator syntax may be able to use
these.
Additionally, earlier versions of perl can still use the function-like
wrapper versions of these operators. Even though the syntax appears like a
regular function call, the code is compiled internally into the same more
efficient operator internally, so will run without the function-call overhead
of a regular function.
=cut
sub import
{
my $pkg = shift;
my $caller = caller;
$pkg->import_into( $caller, @_ );
}
sub unimport
{
my $pkg = shift;
my $caller = caller;
$pkg->unimport_into( $caller, @_ );
}
sub import_into { shift->apply( 1, @_ ) }
sub unimport_into { shift->apply( 0, @_ ) }
sub apply
{
my $pkg = shift;
my ( $on, $caller, @syms ) = @_;
require Syntax::Operator::In; # no import
@syms or @syms = qw( elem ∈ );
$pkg->XS::Parse::Infix::apply_infix( $on, \@syms, qw( elem ∈ ) );
my %syms = map { $_ => 1 } @syms;
my $callerpkg;
foreach (qw( elem_str elem_num )) {
next unless delete $syms{$_};
$callerpkg //= meta::package->get( $caller );
$on ? $callerpkg->add_symbol( '&'.$_ => \&{$_} )
: $callerpkg->remove_symbol( '&'.$_ );
}
croak "Unrecognised import symbols @{[ keys %syms ]}" if keys %syms;
}
=head1 OPERATORS
=head2 elem
my $present = $lhs elem @rhs;
Yields true if the string on the lefthand side is equal to any of the strings
in the list on the right.
Note that it is specifically B<not> guaranteed that this test will be
performed in any particular order. Nor is it guaranteed that any C<eq>
operator overloading present on any of the elements is respected. These
conditions may allow an implementation at least partially based on a hash,
balanced binary tree, or other techniques.
=head2 ∈
my $present = $lhs ∈ @rhs;
Yields true if the number on the lefthand side is equal to any of the numbers
in the list on the right.
Note that it is specifically B<not> guaranteed that this test will be
performed in any particular order. Nor is it guaranteed that any C<==>
operator overloading present on any of the elements is respected. These
conditions may allow an implementation at least partially based on a hash,
balanced binary tree, or other techniques.
=cut
=head1 FUNCTIONS
As a convenience, the following functions may be imported which implement the
same behaviour as the infix operators, though are accessed via regular
function call syntax.
=head2 elem_str
my $present = elem_str( $lhs, @rhs );
A function version of the L</elem> stringy operator.
=head2 elem_num
my $present = elem_num( $lhs, @rhs );
A function version of the L</∈> numerical operator.
=cut
=head1 AUTHOR
Paul Evans <leonerd@leonerd.org.uk>
=cut
0x55AA;
|
