text:
perlsyn - Perl syntax
A Perl program consists of a sequence of declarations and statements which run from the top to the bottom. Loops, subroutines, and other control structures allow you to jump around within the code.
Perl is a free-form language: you can format and indent it however you like. Whitespace serves mostly to separate tokens, unlike languages like Python where it is an important part of the syntax, or Fortran where it is immaterial.
Many of Perl's syntactic elements are optional. Rather than requiring you to put parentheses around every function call and declare every variable, you can often leave such explicit elements off and Perl will figure out what you meant. This is known as Do What I Mean, abbreviated DWIM. It allows programmers to be lazy and to code in a style with which they are comfortable.
Perl borrows syntax and concepts from many languages: awk, sed, C, Bourne Shell, Smalltalk, Lisp and even English. Other languages have borrowed syntax from Perl, particularly its regular expression extensions. So if you have programmed in another language you will see familiar pieces in Perl. They often work the same, but see perltrap for information about how they differ.
The only things you need to declare in Perl are report formats and subroutines (and sometimes not even subroutines). A scalar variable holds the undefined value (undef
) until it has been assigned a defined value, which is anything other than undef
. When used as a number, undef
is treated as 0
; when used as a string, it is treated as the empty string, ""
; and when used as a reference that isn't being assigned to, it is treated as an error. If you enable warnings, you'll be notified of an uninitialized value whenever you treat undef
as a string or a number. Well, usually. Boolean contexts, such as:
if ($a) {}
are exempt from warnings (because they care about truth rather than definedness). Operators such as ++
, --
, +=
, -=
, and .=
, that operate on undefined variables such as:
undef $a;
are also always exempt from such warnings.
A declaration can be put anywhere a statement can, but has no effect on the execution of the primary sequence of statements: declarations all take effect at compile time. All declarations are typically put at the beginning or the end of the script. However, if you're using lexically-scoped private variables created with my()
, state()
, or our()
, you'll have to make sure your format or subroutine definition is within the same block scope as the my if you expect to be able to access those private variables.
Declaring a subroutine allows a subroutine name to be used as if it were a list operator from that point forward in the program. You can declare a subroutine without defining it by saying sub name
, thus:
sub myname;
$me = myname $0 or die "can't get myname";
A bare declaration like that declares the function to be a list operator, not a unary operator, so you have to be careful to use parentheses (or or
instead of ||
.) The ||
operator binds too tightly to use after list operators; it becomes part of the last element. You can always use parentheses around the list operators arguments to turn the list operator back into something that behaves more like a function call. Alternatively, you can use the prototype ($)
to turn the subroutine into a unary operator:
sub myname ($);
$me = myname $0 || die "can't get myname";
That now parses as you'd expect, but you still ought to get in the habit of using parentheses in that situation. For more on prototypes, see perlsub.
Subroutines declarations can also be loaded up with the require
statement or both loaded and imported into your namespace with a use
statement. See perlmod for details on this.
A statement sequence may contain declarations of lexically-scoped variables, but apart from declaring a variable name, the declaration acts like an ordinary statement, and is elaborated within the sequence of statements as if it were an ordinary statement. That means it actually has both compile-time and run-time effects.
Text from a "#"
character until the end of the line is a comment, and is ignored. Exceptions include "#"
inside a string or regular expression.
The only kind of simple statement is an expression evaluated for its side-effects. Every simple statement must be terminated with a semicolon, unless it is the final statement in a block, in which case the semicolon is optional. But put the semicolon in anyway if the block takes up more than one line, because you may eventually add another line. Note that there are operators like eval {}
, sub {}
, and do {}
that look like compound statements, but aren't--they're just TERMs in an expression--and thus need an explicit termination when used as the last item in a statement.
The number 0, the strings '0'
and ""
, the empty list ()
, and undef
are all false in a boolean context. All other values are true. Negation of a true value by !
or not
returns a special false value. When evaluated as a string it is treated as ""
, but as a number, it is treated as 0. Most Perl operators that return true or false behave this way.
Any simple statement may optionally be followed by a SINGLE modifier, just before the terminating semicolon (or block ending). The possible modifiers are:
if EXPR
unless EXPR
while EXPR
until EXPR
for LIST
foreach LIST
when EXPR
The EXPR
following the modifier is referred to as the "condition". Its truth or falsehood determines how the modifier will behave.
executes the statement once if and only if the condition is true. unless
is the opposite, it executes the statement unless the condition is true (that is, if the condition is false).
print "Basset hounds got long ears" if length $ear >= 10;
go_outside() and play() unless $is_raining;
The for(each)
modifier is an iterator: it executes the statement once for each item in the LIST (with $_
aliased to each item in turn).
print "Hello $_!\n" for qw(world Dolly nurse);
repeats the statement while the condition is true. until
does the opposite, it repeats the statement until the condition is true (or while the condition is false):
# Both of these count from 0 to 10.
print $i++ while $i <= 10;
print $j++ until $j > 10;
The while
and until
modifiers have the usual "while
loop" semantics (conditional evaluated first), except when applied to a do
-BLOCK (or to the Perl4 do
-SUBROUTINE statement), in which case the block executes once before the conditional is evaluated.
This is so that you can write loops like:
do {
$line = <STDIN>;
} until !defined($line) || $line eq ".\n"
See "do" in perlfunc. Note also that the loop control statements described later will NOT work in this construct, because modifiers don't take loop labels. Sorry. You can always put another block inside of it (for next
) or around it (for last
) to do that sort of thing.
For next
or redo
, just double the braces:
do {{
next if $x == $y;
# do something here
}} until $x++ > $z;
For last
, you have to be more elaborate and put braces around it:
do {
last if $x == $y**2;
# do something here
} while $x++ <= $z;
If you need both next
and last
, you have to do both and also use a loop label:
do {{
next if $x == $y;
last LOOP if $x == $y**2;
# do something here
}} until $x++ > $z;
NOTE: The behaviour of a my
, state
, or our
modified with a statement modifier conditional or loop construct (for example, my $x if ...
) is undefined. The value of the my
variable may be undef
, any previously assigned value, or possibly anything else. Don't rely on it. Future versions of perl might do something different from the version of perl you try it out on. Here be dragons.
The when
modifier is an experimental feature that first appeared in Perl 5.14. To use it, you should include a use v5.14
declaration. (Technically, it requires only the switch
feature, but that aspect of it was not available before 5.14.) Operative only from within a foreach
loop or a given
block, it executes the statement only if the smartmatch $_ ~~ EXPR
is true. If the statement executes, it is followed by a next
from inside a foreach
and break
from inside a given
Under the current implementation, the foreach
loop can be anywhere within the when
modifier's dynamic scope, but must be within the given
block's lexical scope. This restriction may be relaxed in a future release. See "Switch Statements" below.
In Perl, a sequence of statements that defines a scope is called a block. Sometimes a block is delimited by the file containing it (in the case of a required file, or the program as a whole), and sometimes a block is delimited by the extent of a string (in the case of an eval).
But generally, a block is delimited by curly brackets, also known as braces. We will call this syntactic construct a BLOCK.
The following compound statements may be used to control flow:
if (EXPR) BLOCK
if (EXPR) BLOCK else BLOCK
if (EXPR) BLOCK elsif (EXPR) BLOCK ...
if (EXPR) BLOCK elsif (EXPR) BLOCK ... else BLOCK
unless (EXPR) BLOCK
unless (EXPR) BLOCK else BLOCK
unless (EXPR) BLOCK elsif (EXPR) BLOCK ...
unless (EXPR) BLOCK elsif (EXPR) BLOCK ... else BLOCK
given (EXPR) BLOCK
LABEL while (EXPR) BLOCK
LABEL while (EXPR) BLOCK continue BLOCK
LABEL until (EXPR) BLOCK
LABEL until (EXPR) BLOCK continue BLOCK
LABEL for (EXPR; EXPR; EXPR) BLOCK
LABEL for VAR (LIST) BLOCK
LABEL for VAR (LIST) BLOCK continue BLOCK
LABEL foreach (EXPR; EXPR; EXPR) BLOCK
LABEL foreach VAR (LIST) BLOCK
LABEL foreach VAR (LIST) BLOCK continue BLOCK
LABEL BLOCK continue BLOCK
The experimental given
statement is not automatically enabled; see "Switch Statements" below for how to do so, and the attendant caveats.
Unlike in C and Pascal, in Perl these are all defined in terms of BLOCKs, not statements. This means that the curly brackets are required--no dangling statements allowed. If you want to write conditionals without curly brackets, there are several other ways to do it. The following all do the same thing:
if (!open(FOO)) { die "Can't open $FOO: $!" }
die "Can't open $FOO: $!" unless open(FOO);
open(FOO) || die "Can't open $FOO: $!";
open(FOO) ? () : die "Can't open $FOO: $!";
# a bit exotic, that last one
The if
statement is straightforward. Because BLOCKs are always bounded by curly brackets, there is never any ambiguity about which if
an else
goes with. If you use unless
in place of if
, the sense of the test is reversed. Like if
, unless
can be followed by else
. unless
can even be followed by one or more elsif
statements, though you may want to think twice before using that particular language construct, as everyone reading your code will have to think at least twice before they can understand what's going on.
The while
statement executes the block as long as the expression is true. The until
statement executes the block as long as the expression is false. The LABEL is optional, and if present, consists of an identifier followed by a colon. The LABEL identifies the loop for the loop control statements next
, last
, and redo
. If the LABEL is omitted, the loop control statement refers to the innermost enclosing loop. This may include dynamically looking back your call-stack at run time to find the LABEL. Such desperate behavior triggers a warning if you use the use warnings
pragma or the -w flag.
If there is a continue
BLOCK, it is always executed just before the conditional is about to be evaluated again. Thus it can be used to increment a loop variable, even when the loop has been continued via the next
When a block is preceding by a compilation phase keyword such as BEGIN
, or UNITCHECK
, then the block will run only during the corresponding phase of execution. See perlmod for more details.
Extension modules can also hook into the Perl parser to define new kinds of compound statements. These are introduced by a keyword which the extension recognizes, and the syntax following the keyword is defined entirely by the extension. If you are an implementor, see "PL_keyword_plugin" in perlapi for the mechanism. If you are using such a module, see the module's documentation for details of the syntax that it defines.
The next
command starts the next iteration of the loop:
LINE: while (<STDIN>) {
next LINE if /^#/; # discard comments
The last
command immediately exits the loop in question. The continue
block, if any, is not executed:
LINE: while (<STDIN>) {
last LINE if /^$/; # exit when done with header
The redo
command restarts the loop block without evaluating the conditional again. The continue
block, if any, is not executed. This command is normally used by programs that want to lie to themselves about what was just input.
For example, when processing a file like /etc/termcap. If your input lines might end in backslashes to indicate continuation, you want to skip ahead and get the next record.
while (<>) {
if (s/\\$//) {
$_ .= <>;
redo unless eof();
# now process $_
which is Perl shorthand for the more explicitly written version:
LINE: while (defined($line = <ARGV>)) {
if ($line =~ s/\\$//) {
$line .= <ARGV>;
redo LINE unless eof(); # not eof(ARGV)!
# now process $line
Note that if there were a continue
block on the above code, it would get executed only on lines discarded by the regex (since redo skips the continue block). A continue block is often used to reset line counters or m?pat?
one-time matches:
# inspired by :1,$g/fred/s//WILMA/
while (<>) {
m?(fred)? && s//WILMA $1 WILMA/;
m?(barney)? && s//BETTY $1 BETTY/;
m?(homer)? && s//MARGE $1 MARGE/;
} continue {
print "$ARGV $.: $_";
close ARGV if eof; # reset $.
reset if eof; # reset ?pat?
If the word while
is replaced by the word until
, the sense of the test is reversed, but the conditional is still tested before the first iteration.
Loop control statements don't work in an if
or unless
, since they aren't loops. You can double the braces to make them such, though.
if (/pattern/) {{
last if /fred/;
next if /barney/; # same effect as "last",
# but doesn't document as well
# do something here
This is caused by the fact that a block by itself acts as a loop that executes once, see "Basic BLOCKs".
The form while/if BLOCK BLOCK
, available in Perl 4, is no longer available. Replace any occurrence of if BLOCK
by if (do BLOCK)
Perl's C-style for
loop works like the corresponding while
loop; that means that this:
for ($i = 1; $i < 10; $i++) {
is the same as this:
$i = 1;
while ($i < 10) {
} continue {
There is one minor difference: if variables are declared with my
in the initialization section of the for
, the lexical scope of those variables is exactly the for
loop (the body of the loop and the control sections).
As a special case, if the test in the for
loop (or the corresponding while
loop) is empty, it is treated as true. That is, both
for (;;) {
while () {
are treated as infinite loops.
Besides the normal array index looping, for
can lend itself to many other interesting applications. Here's one that avoids the problem you get into if you explicitly test for end-of-file on an interactive file descriptor causing your program to appear to hang.
$on_a_tty = -t STDIN && -t STDOUT;
sub prompt { print "yes? " if $on_a_tty }
for ( prompt(); <STDIN>; prompt() ) {
# do something
Using readline
(or the operator form, <EXPR>
) as the conditional of a for
loop is shorthand for the following. This behaviour is the same as a while
loop conditional.
for ( prompt(); defined( $_ = <STDIN> ); prompt() ) {
# do something
The foreach
loop iterates over a normal list value and sets the scalar variable VAR to be each element of the list in turn. If the variable is preceded with the keyword my
, then it is lexically scoped, and is therefore visible only within the loop. Otherwise, the variable is implicitly local to the loop and regains its former value upon exiting the loop. If the variable was previously declared with my
, it uses that variable instead of the global one, but it's still localized to the loop. This implicit localization occurs only in a foreach
The foreach
keyword is actually a synonym for the for
keyword, so you can use either. If VAR is omitted, $_
is set to each value.
If any element of LIST is an lvalue, you can modify it by modifying VAR inside the loop. Conversely, if any element of LIST is NOT an lvalue, any attempt to modify that element will fail. In other words, the foreach
loop index variable is an implicit alias for each item in the list that you're looping over.
If any part of LIST is an array, foreach
will get very confused if you add or remove elements within the loop body, for example with splice
. So don't do that.
probably won't do what you expect if VAR is a tied or other special variable. Don't do that either.
As of Perl 5.22, there is an experimental variant of this loop that accepts a variable preceded by a backslash for VAR, in which case the items in the LIST must be references. The backslashed variable will become an alias to each referenced item in the LIST, which must be of the correct type. The variable needn't be a scalar in this case, and the backslash may be followed by my
. To use this form, you must enable the refaliasing
feature via use feature
. (See feature. See also "Assigning to References" in perlref.)
for (@ary) { s/foo/bar/ }
for my $elem (@elements) {
$elem *= 2;
for $count (reverse(1..10), "BOOM") {
print $count, "\n";
for (1..15) { print "Merry Christmas\n"; }
foreach $item (split(/:[\\\n:]*/, $ENV{TERMCAP})) {
print "Item: $item\n";
use feature "refaliasing";
no warnings "experimental::refaliasing";
foreach \my %hash (@array_of_hash_references) {
# do something which each %hash
Here's how a C programmer might code up a particular algorithm in Perl:
for (my $i = 0; $i < @ary1; $i++) {
for (my $j = 0; $j < @ary2; $j++) {
if ($ary1[$i] > $ary2[$j]) {
last; # can't go to outer :-(
$ary1[$i] += $ary2[$j];
# this is where that last takes me
Whereas here's how a Perl programmer more comfortable with the idiom might do it:
OUTER: for my $wid (@ary1) {
INNER: for my $jet (@ary2) {
next OUTER if $wid > $jet;
$wid += $jet;
See how much easier this is? It's cleaner, safer, and faster. It's cleaner because it's less noisy. It's safer because if code gets added between the inner and outer loops later on, the new code won't be accidentally executed. The next
explicitly iterates the other loop rather than merely terminating the inner one. And it's faster because Perl executes a foreach
statement more rapidly than it would the equivalent for
Perceptive Perl hackers may have noticed that a for
loop has a return value, and that this value can be captured by wrapping the loop in a do
block. The reward for this discovery is this cautionary advice: The return value of a for
loop is unspecified and may change without notice. Do not rely on it.
A BLOCK by itself (labeled or not) is semantically equivalent to a loop that executes once. Thus you can use any of the loop control statements in it to leave or restart the block. (Note that this is NOT true in eval{}
, sub{}
, or contrary to popular belief do{}
blocks, which do NOT count as loops.) The continue
block is optional.
The BLOCK construct can be used to emulate case structures.
if (/^abc/) { $abc = 1; last SWITCH; }
if (/^def/) { $def = 1; last SWITCH; }
if (/^xyz/) { $xyz = 1; last SWITCH; }
$nothing = 1;
You'll also find that foreach
loop used to create a topicalizer and a switch:
for ($var) {
if (/^abc/) { $abc = 1; last SWITCH; }
if (/^def/) { $def = 1; last SWITCH; }
if (/^xyz/) { $xyz = 1; last SWITCH; }
$nothing = 1;
Such constructs are quite frequently used, both because older versions of Perl had no official switch
statement, and also because the new version described immediately below remains experimental and can sometimes be confusing.
Starting from Perl 5.10.1 (well, 5.10.0, but it didn't work right), you can say
use feature "switch";
to enable an experimental switch feature. This is loosely based on an old version of a Perl 6 proposal, but it no longer resembles the Perl 6 construct. You also get the switch feature whenever you declare that your code prefers to run under a version of Perl that is 5.10 or later. For example:
use v5.14;
Under the "switch" feature, Perl gains the experimental keywords given
, when
, default
, continue
, and break
. Starting from Perl 5.16, one can prefix the switch keywords with CORE::
to access the feature without a use feature
statement. The keywords given
and when
are analogous to switch
and case
in other languages -- though continue
is not -- so the code in the previous section could be rewritten as
use v5.10.1;
for ($var) {
when (/^abc/) { $abc = 1 }
when (/^def/) { $def = 1 }
when (/^xyz/) { $xyz = 1 }
default { $nothing = 1 }
The foreach
is the non-experimental way to set a topicalizer. If you wish to use the highly experimental given
, that could be written like this:
use v5.10.1;
given ($var) {
when (/^abc/) { $abc = 1 }
when (/^def/) { $def = 1 }
when (/^xyz/) { $xyz = 1 }
default { $nothing = 1 }
As of 5.14, that can also be written this way:
use v5.14;
for ($var) {
$abc = 1 when /^abc/;
$def = 1 when /^def/;
$xyz = 1 when /^xyz/;
default { $nothing = 1 }
Or if you don't care to play it safe, like this:
use v5.14;
given ($var) {
$abc = 1 when /^abc/;
$def = 1 when /^def/;
$xyz = 1 when /^xyz/;
default { $nothing = 1 }
The arguments to given
and when
are in scalar context, and given
assigns the $_
variable its topic value.
Exactly what the EXPR argument to when
does is hard to describe precisely, but in general, it tries to guess what you want done. Sometimes it is interpreted as $_ ~~ EXPR
, and sometimes it is not. It also behaves differently when lexically enclosed by a given
block than it does when dynamically enclosed by a foreach
loop. The rules are far too difficult to understand to be described here. See "Experimental Details on given and when" later on.
Due to an unfortunate bug in how given
was implemented between Perl 5.10 and 5.16, under those implementations the version of $_
governed by given
is merely a lexically scoped copy of the original, not a dynamically scoped alias to the original, as it would be if it were a foreach
or under both the original and the current Perl 6 language specification. This bug was fixed in Perl 5.18 (and lexicalized $_
itself was removed in Perl 5.24).
If your code still needs to run on older versions, stick to foreach
for your topicalizer and you will be less unhappy.
Although not for the faint of heart, Perl does support a goto
statement. There are three forms: goto
-LABEL, goto
-EXPR, and goto
-&NAME. A loop's LABEL is not actually a valid target for a goto
; it's just the name of the loop.
The goto
-LABEL form finds the statement labeled with LABEL and resumes execution there. It may not be used to go into any construct that requires initialization, such as a subroutine or a foreach
loop. It also can't be used to go into a construct that is optimized away. It can be used to go almost anywhere else within the dynamic scope, including out of subroutines, but it's usually better to use some other construct such as last
or die
. The author of Perl has never felt the need to use this form of goto
(in Perl, that is--C is another matter).
The goto
-EXPR form expects a label name, whose scope will be resolved dynamically. This allows for computed goto
s per FORTRAN, but isn't necessarily recommended if you're optimizing for maintainability:
goto(("FOO", "BAR", "GLARCH")[$i]);
The goto
-&NAME form is highly magical, and substitutes a call to the named subroutine for the currently running subroutine. This is used by AUTOLOAD()
subroutines that wish to load another subroutine and then pretend that the other subroutine had been called in the first place (except that any modifications to @_
in the current subroutine are propagated to the other subroutine.) After the goto
, not even caller()
will be able to tell that this routine was called first.
In almost all cases like this, it's usually a far, far better idea to use the structured control flow mechanisms of next
, last
, or redo
instead of resorting to a goto
. For certain applications, the catch and throw pair of eval{}
and die() for exception processing can also be a prudent approach.
Beginning in Perl 5.12, Perl accepts an ellipsis, "...
", as a placeholder for code that you haven't implemented yet. This form of ellipsis, the unimplemented statement, should not be confused with the binary flip-flop ...
operator. One is a statement and the other an operator. (Perl doesn't usually confuse them because usually Perl can tell whether it wants an operator or a statement, but see below for exceptions.)
When Perl 5.12 or later encounters an ellipsis statement, it parses this without error, but if and when you should actually try to execute it, Perl throws an exception with the text Unimplemented
use v5.12;
sub unimplemented { ... }
eval { unimplemented() };
if ($@ =~ /^Unimplemented at /) {
say "I found an ellipsis!";
You can only use the elliptical statement to stand in for a complete statement. These examples of how the ellipsis works:
use v5.12;
{ ... }
sub foo { ... }
eval { ... };
sub somemeth {
my $self = shift;
$x = do {
my $n;
say "Hurrah!";
The elliptical statement cannot stand in for an expression that is part of a larger statement, since the ...
is also the three-dot version of the flip-flop operator (see "Range Operators" in perlop).
These examples of attempts to use an ellipsis are syntax errors:
use v5.12;
print ...;
open(my $fh, ">", "/dev/passwd") or ...;
if ($condition && ... ) { say "Howdy" };
There are some cases where Perl can't immediately tell the difference between an expression and a statement. For instance, the syntax for a block and an anonymous hash reference constructor look the same unless there's something in the braces to give Perl a hint. The ellipsis is a syntax error if Perl doesn't guess that the { ... }
is a block. In that case, it doesn't think the ...
is an ellipsis because it's expecting an expression instead of a statement:
@transformed = map { ... } @input; # syntax error
Inside your block, you can use a ;
before the ellipsis to denote that the { ... }
is a block and not a hash reference constructor. Now the ellipsis works:
@transformed = map {; ... } @input; # ';' disambiguates
Note: Some folks colloquially refer to this bit of punctuation as a "yada-yada" or "triple-dot", but its true name is actually an ellipsis.
Perl has a mechanism for intermixing documentation with source code. While it's expecting the beginning of a new statement, if the compiler encounters a line that begins with an equal sign and a word, like this
=head1 Here There Be Pods!
Then that text and all remaining text up through and including a line beginning with =cut
will be ignored. The format of the intervening text is described in perlpod.
This allows you to intermix your source code and your documentation text freely, as in
=item snazzle($)
The snazzle() function will behave in the most spectacular
form that you can possibly imagine, not even excepting
cybernetic pyrotechnics.
=cut back to the compiler, nuff of this pod stuff!
sub snazzle($) {
my $thingie = shift;
Note that pod translators should look at only paragraphs beginning with a pod directive (it makes parsing easier), whereas the compiler actually knows to look for pod escapes even in the middle of a paragraph. This means that the following secret stuff will be ignored by both the compiler and the translators.
=secret stuff
warn "Neither POD nor CODE!?"
=cut back
print "got $a\n";
You probably shouldn't rely upon the warn()
being podded out forever. Not all pod translators are well-behaved in this regard, and perhaps the compiler will become pickier.
One may also use pod directives to quickly comment out a section of code.
Perl can process line directives, much like the C preprocessor. Using this, one can control Perl's idea of filenames and line numbers in error or warning messages (especially for strings that are processed with eval()
). The syntax for this mechanism is almost the same as for most C preprocessors: it matches the regular expression
# example: '# line 42 "new_filename.plx"'
/^\# \s*
line \s+ (\d+) \s*
(?:\s("?)([^"]+)\g2)? \s*
with $1
being the line number for the next line, and $3
being the optional filename (specified with or without quotes). Note that no whitespace may precede the #
, unlike modern C preprocessors.
There is a fairly obvious gotcha included with the line directive: Debuggers and profilers will only show the last source line to appear at a particular line number in a given file. Care should be taken not to cause line number collisions in code you'd like to debug later.
Here are some examples that you should be able to type into your command shell:
% perl
# line 200 "bzzzt"
# the '#' on the previous line must be the first char on line
die 'foo';
foo at bzzzt line 201.
% perl
# line 200 "bzzzt"
eval qq[\n#line 2001 ""\ndie 'foo']; print $@;
foo at - line 2001.
% perl
eval qq[\n#line 200 "foo bar"\ndie 'foo']; print $@;
foo at foo bar line 200.
% perl
# line 345 "goop"
eval "\n#line " . __LINE__ . ' "' . __FILE__ ."\"\ndie 'foo'";
print $@;
foo at goop line 345.
As previously mentioned, the "switch" feature is considered highly experimental; it is subject to change with little notice. In particular, when
has tricky behaviours that are expected to change to become less tricky in the future. Do not rely upon its current (mis)implementation. Before Perl 5.18, given
also had tricky behaviours that you should still beware of if your code must run on older versions of Perl.
Here is a longer example of given
use feature ":5.10";
given ($foo) {
when (undef) {
say '$foo is undefined';
when ("foo") {
say '$foo is the string "foo"';
when ([1,3,5,7,9]) {
say '$foo is an odd digit';
continue; # Fall through
when ($_ < 100) {
say '$foo is numerically less than 100';
when (\&complicated_check) {
say 'a complicated check for $foo is true';
default {
die q(I don't know what to do with $foo);
Before Perl 5.18, given(EXPR)
assigned the value of EXPR to merely a lexically scoped copy (!) of $_
, not a dynamically scoped alias the way foreach
does. That made it similar to
do { my $_ = EXPR; ... }
except that the block was automatically broken out of by a successful when
or an explicit break
. Because it was only a copy, and because it was only lexically scoped, not dynamically scoped, you could not do the things with it that you are used to in a foreach
loop. In particular, it did not work for arbitrary function calls if those functions might try to access $_. Best stick to foreach
for that.
Most of the power comes from the implicit smartmatching that can sometimes apply. Most of the time, when(EXPR)
is treated as an implicit smartmatch of $_
, that is, $_ ~~ EXPR
. (See "Smartmatch Operator" in perlop for more information on smartmatching.) But when EXPR is one of the 10 exceptional cases (or things like them) listed below, it is used directly as a boolean.
A user-defined subroutine call or a method invocation.
A regular expression match in the form of /REGEX/
, $foo =~ /REGEX/
, or $foo =~ EXPR
. Also, a negated regular expression match in the form !/REGEX/
, $foo !~ /REGEX/
, or $foo !~ EXPR
A smart match that uses an explicit ~~
operator, such as EXPR ~~ EXPR
NOTE: You will often have to use $c ~~ $_
because the default case uses $_ ~~ $c
, which is frequentlythe opposite of what you want.
A boolean comparison operator such as $_ < 10
or $x eq "abc"
. The relational operators that this applies to are the six numeric comparisons (<
, >
, <=
, >=
, ==
, and !=
), and the six string comparisons (lt
, gt
, le
, ge
, eq
, and ne
At least the three builtin functions defined(...)
, exists(...)
, and eof(...)
. We might someday add more of these later if we think of them.
A negated expression, whether !(EXPR)
or not(EXPR)
, or a logical exclusive-or, (EXPR1) xor (EXPR2)
. The bitwise versions (~
and ^
) are not included.
A filetest operator, with exactly 4 exceptions: -s
, and -C
, as these return numerical values, not boolean ones. The -z
filetest operator is not included in the exception list.
The ..
and ...
flip-flop operators. Note that the ...
flip-flop operator is completely different from the ...
elliptical statement just described.
In those 8 cases above, the value of EXPR is used directly as a boolean, so no smartmatching is done. You may think of when
as a smartsmartmatch.
Furthermore, Perl inspects the operands of logical operators to decide whether to use smartmatching for each one by applying the above test to the operands:
If EXPR is EXPR1 && EXPR2
or EXPR1 and EXPR2
, the test is applied recursively to both EXPR1 and EXPR2. Only if both operands also pass the test, recursively, will the expression be treated as boolean. Otherwise, smartmatching is used.
If EXPR is EXPR1 || EXPR2
, or EXPR1 or EXPR2
, the test is applied recursively to EXPR1 only (which might itself be a higher-precedence AND operator, for example, and thus subject to the previous rule), not to EXPR2. If EXPR1 is to use smartmatching, then EXPR2 also does so, no matter what EXPR2 contains. But if EXPR2 does not get to use smartmatching, then the second argument will not be either. This is quite different from the &&
case just described, so be careful.
These rules are complicated, but the goal is for them to do what you want (even if you don't quite understand why they are doing it). For example:
when (/^\d+$/ && $_ < 75) { ... }
will be treated as a boolean match because the rules say both a regex match and an explicit test on $_
will be treated as boolean.
when ([qw(foo bar)] && /baz/) { ... }
will use smartmatching because only one of the operands is a boolean: the other uses smartmatching, and that wins.
when ([qw(foo bar)] || /^baz/) { ... }
will use smart matching (only the first operand is considered), whereas
when (/^baz/ || [qw(foo bar)]) { ... }
will test only the regex, which causes both operands to be treated as boolean. Watch out for this one, then, because an arrayref is always a true value, which makes it effectively redundant. Not a good idea.
Tautologous boolean operators are still going to be optimized away. Don't be tempted to write
when ("foo" or "bar") { ... }
This will optimize down to "foo"
, so "bar"
will never be considered (even though the rules say to use a smartmatch on "foo"
). For an alternation like this, an array ref will work, because this will instigate smartmatching:
when ([qw(foo bar)] { ... }
This is somewhat equivalent to the C-style switch statement's fallthrough functionality (not to be confused with Perl's fallthrough functionality--see below), wherein the same block is used for several case
Another useful shortcut is that, if you use a literal array or hash as the argument to given
, it is turned into a reference. So given(@foo)
is the same as given(\@foo)
, for example.
behaves exactly like when(1 == 1)
, which is to say that it always matches.
You can use the break
keyword to break out of the enclosing given
block. Every when
block is implicitly ended with a break
You can use the continue
keyword to fall through from one case to the next immediate when
or default
given($foo) {
when (/x/) { say '$foo contains an x'; continue }
when (/y/) { say '$foo contains a y' }
default { say '$foo does not contain a y' }
When a given
statement is also a valid expression (for example, when it's the last statement of a block), it evaluates to:
An empty list as soon as an explicit break
is encountered.
The value of the last evaluated expression of the successful when
clause, if there happens to be one.
The value of the last evaluated expression of the given
block if no condition is true.
In both last cases, the last expression is evaluated in the context that was applied to the given
Note that, unlike if
and unless
, failed when
statements always evaluate to an empty list.
my $price = do {
given ($item) {
when (["pear", "apple"]) { 1 }
break when "vote"; # My vote cannot be bought
1e10 when /Mona Lisa/;
Currently, given
blocks can't always be used as proper expressions. This may be addressed in a future version of Perl.
Instead of using given()
, you can use a foreach()
loop. For example, here's one way to count how many times a particular string occurs in an array:
use v5.10.1;
my $count = 0;
for (@array) {
when ("foo") { ++$count }
print "\@array contains $count copies of 'foo'\n";
Or in a more recent version:
use v5.14;
my $count = 0;
for (@array) {
++$count when "foo";
print "\@array contains $count copies of 'foo'\n";
At the end of all when
blocks, there is an implicit next
. You can override that with an explicit last
if you're interested in only the first match alone.
This doesn't work if you explicitly specify a loop variable, as in for $item (@array)
. You have to use the default variable $_
The Perl 5 smartmatch and given
constructs are not compatible with their Perl 6 analogues. The most visible difference and least important difference is that, in Perl 5, parentheses are required around the argument to given()
and when()
(except when this last one is used as a statement modifier). Parentheses in Perl 6 are always optional in a control construct such as if()
, while()
, or when()
; they can't be made optional in Perl 5 without a great deal of potential confusion, because Perl 5 would parse the expression
given $foo {
as though the argument to given
were an element of the hash %foo
, interpreting the braces as hash-element syntax.
However, their are many, many other differences. For example, this works in Perl 5:
use v5.12;
my @primary = ("red", "blue", "green");
if (@primary ~~ "red") {
say "primary smartmatches red";
if ("red" ~~ @primary) {
say "red smartmatches primary";
say "that's all, folks!";
But it doesn't work at all in Perl 6. Instead, you should use the (parallelizable) any
if any(@primary) eq "red" {
say "primary smartmatches red";
if "red" eq any(@primary) {
say "red smartmatches primary";
The table of smartmatches in "Smartmatch Operator" in perlop is not identical to that proposed by the Perl 6 specification, mainly due to differences between Perl 6's and Perl 5's data models, but also because the Perl 6 spec has changed since Perl 5 rushed into early adoption.
In Perl 6, when()
will always do an implicit smartmatch with its argument, while in Perl 5 it is convenient (albeit potentially confusing) to suppress this implicit smartmatch in various rather loosely-defined situations, as roughly outlined above. (The difference is largely because Perl 5 does not have, even internally, a boolean type.)


text:
Director: Evan Goldberg, Seth Rogen
Starring: Seth Rogen, James Franco, Jonah Hill
Year: 2013
When the trailer for This Is the End first came out I thought it looked pretty funny. I figured if you liked Superbad, which I did, you'd like this one as well. It has some of the same actors (Rogen, Hill, Cera) and the same style of raunchy comedy that revolves around bodily fluids and recreational drugs. However, a major difference would be that in this movie the actors play themselves, with a ton of cameos thrown in for good measure. So while I assumed that I'd find it funny, I also thought that it would fall short of better movies because it would lack that emotional base that we don't always notice but we usually need. Well, apparently they just decided to replace emotion with extra crude humor, and the result wasn't a shallow film but one of the funniest movies I've seen in years.
Almost the entire story takes place in James Franco's new house in Hollywood. Seth Rogen and his old friend Jay Baruchel are reuniting in California, a place that Jay hates to be. Seth talks him into coming with him to Franco's housewarming, where there will be a ton of drugs and celebrities. Among the elite are Craig Robinson, Danny McBride, Emma Watson, Rhianna, Michael Cera, Paul Rudd, Jason Segal, Aziz Ansari, and a bunch of others. Jay may not be having a great time, but the night is about to get worse. It seems as if the apocalypse is upon them, as the Hollywood Hills are engulfed in flame, blue lights take people into the sky, and monsters roam the streets. Only a small group of the party-goers survive and they must band together and get along if they are to have any chance of waiting out the end of the world.
I did not expect the movie to be as funny as it was. I mean, I thought it'd be funny, not hilarious, but it was definitely the latter. It was non-stop comedy from the very beginning, but somehow it never got old or annoying. I haven't laughed that hard since who knows when; maybe since Superbad. And while that movie relied on our memories of how awkward it is to be young, this movie got us laughing by putting audiences in ridiculous situations that only warped minds could possibly think of. And the comedy was warped, be warned. It was crude, sexual, graphic, dirty, whatever you want to call it. But it was also real; it was a bunch of guys stuck in a house together with nothing to do but smoke pot, look at porn, drink wine, turn on each other, and worry about which of them was going to die next.
I guess that's why the movie worked; it was surprisingly real for such a silly film. Now, by real I don't mean realistic, I mean it felt natural. It felt like the lines were what Seth and Jay and Jonah would say if they found themselves in this situation. Breaking down that fourth wall really worked because it made the characters real and allowed the actors to make fun of themselves and of each other while still playing people in the movie. It was kind of a genius idea, and I'm not sure the movie would have worked so well had they tried to create stories and backgrounds and fake names. It worked because it was off-center, because it was hilarious while being pretty original. And you could tell the guys were having a great time making the film, which was really infectious. I felt jealous that I wasn't under lock-down during the rapture with this crew; for being that close to death it seemed like they were having a pretty awesome time.
My rating: ✰ ✰ ✰ ✰ ✰

subset: commoncrawl


text:
An original late 1960's test specimen Concorde 'droop' nose section complete with pilots visor and
Automobilia & Aeronautica.
Sale Date(s)
Venue Address
General delivery information available from the auctioneer
At the auctioneer's absolute discretion we will post and pack small, light and unbreakable items.
There is a £10 handling charge for the first item, irrespective of size, each additional lot carries a handling charge of £2. Postage is at cost by Royal Mail - Special Deliver of Parcel Force 48.
If you would like postage added to your invoice please call or email the office and your invoice will be amended.
We are also happy to work with couriers.
We do not display furniture for viewing. Photos and condition reports can be provided upon request. Furniture is available for collection Monday - Wednesday 9am - 3pm the week following the sale. If you try to collect outside of these hours your item may not be accessable.
Collection by third party
If a third party is to collect the goods on behalf of a buyer, formal written authority and identification will be required before the goods can be released.
Overseas Buyers
Payment can only be accepted by Bankers Draft or Money Order in Pounds Stirling.
Important Information
Please familiarise yourself with our Terms and Conditions. By making a bid you agree to abide by the same.
Please note we do not accept card holder not present credit or debit card transactions.
Please only place a bid if you are satisfied with the authenticity of the item.
Please note: our buyer's premium is 23.4% inclusive of VAT (19.5% + VAT)
Payment for all purchased lots is required within three working days of the sale.
Lots purchased online will attract an additional charge for this service plus VAT at the rate imposed.
Viewing & Condition Reports
Furniture is not displayed in the saleroom for viewing, photos are displayed online and condition reports will be given on request. Furniture is available for collection Mon - Weds 9am - 3pm the week following the sale.
We respectfully remind all purchasers that there is ample viewing time prior to sale and we are very happy to furnish further information concerning condition reports and further images of any lots.
Prospective purchasers must satisfy themselves as to the authenticity of any lots offered. All catalogue descriptions are given in good faith.
Please note we do not accept card holder not present credit or debit card transactions.
Buyers in the room:
• All invoices must be settled in full on the day of sale.
• Payment can be made in person for immediate release of items by the following means:
• Cash
• Credit card or debit card in person using chip and pin
Absentee bidders:
• All invoices must be settled within three working days of sale.
Payment can be made by the following means:
• Debit card or Credit card in person using chip and pin
• Bank transfer :
Sort Code 40-15-33
Account 11252380 in name of Humbert & Ellis Ltd, HSBC Bank, Market Hill, Buckingham, MK18 1JL
IBAN No GB96MIDL40153311252380
Swift Code MIDLGB22
• Cash up to £3000
When the purchaser is collecting from the saleroom a form of ID, showing the address registered with, must be produced. (Driving license or utility bill)
If a third party is collecting on behalf of the purchaser we will require prior written authority, a copy of the invoice and ID of the third party collecting.
Postage and Packaging
We are happy to suggest Mailboxes Etc, Banbury on 01295 277733 who will collect, pack and post items both internationally and nationally. At the auctioneer's absolute discretion we will post and pack small, light and unbreakable items. There is a £10 handling charge for the first item, irrespective of size- and P&P at cost for this service. Each additional lot carries a handling charge of £2.
Collection of items
Furniture is not displayed in the saleroom, it is available for collection Mon - Weds 9am - 3pm the week following the sale. Please do not try to collect outside of these times as your item may not be accessable.
Storage for other items is free of charge for the first two weeks and thereafter charges apply. Please see our Terms and Conditions for further details.
Terms & Conditions
• Vendors are reminded that the terms of engagement and conditions of sale are incorporated into Humbert & Ellis Ltd entry form.
• Humbert & Ellis Ltd have absolute discretion to divide any lot, to combine any two or more lots or to withdraw any lot from the sale, to refuse bids, regulate bidding or to cancel the sale, without prior notice.
• Humbert & Ellis Ltd act only as agents for the Vendor. At his discretion, the Auctioneer may bid on behalf of the Vendor for all goods that are being offered, subject to reserve or otherwise.
• The highest bidder shall be the buyer, The Auctioneer may, at his sole discretion, determine the advance of the bidding or refuse a bid. If during the auction, the Auctioneer considers that a dispute has arisen, he has absolute discretion to settle the dispute or re-offer the lot for sale. The Auctioneers may only re-offer if a bidder contests a matter immediately, and before the offering of the next lot.
• The Auctioneers accept no responsibility for the accuracy of any statement, whether printed in the catalogue, published on the Internet or made verbally, as to grading, authorship, attribution, genuineness, origin, date, age, provenance and condition. All such statements are statements of opinion and are not to be taken as being, or implying, warranties, guarantees or representations of fact. The Auctioneers reserve the right in forming their opinion to consult and rely upon any expert or authority considered by them to be reliable.
• Ample opportunity is given for inspection. Each purchaser, by making a bid for a lot, is deemed to have knowledge of all the conditions of sale and to have satisfied themselves as to the physical condition and accuracy of the description of the lot, including, but not restricted to, whether the lot is damaged or has been repaired.
• All lots are sold as shown, with all faults, imperfections and errors of description. However, if within 7 days of the sale of any lot, the buyer gives notice in writing to the Auctioneers that the lot sold is a forgery and if within 14 days of giving such notice, the buyer returns the lot in the same condition as it was at the time of sale, to the Auctioneers premises and there is shown, to the satisfaction of the Auctioneers, that having regard to the catalogue description, the sold lot is a forgery, the Auctioneers are authorized to, and will, rescind the sale and refund the purchase price received by them. This right is limited to the buyer and may not be assigned.
• Each lot, at the fall of the hammer will be at the risk of the purchaser and will be taken away at the purchaser's risk and expense, on the day of sale unless prior arrangements have been made with the Auctioneers. In the event of any liability upon the Auctioneers in respect of any loss this shall be restricted to a maximum of the price paid by the buyer.
• The title of the goods shall not pass to the buyer until the purchase price has been paid in full and including the premium at the stated rate.
• At the fall of the hammer, the purchaser shall give his name and address, and may be required to pay immediately a percentage of the purchase price. If the buyer fails to comply with these requirements the lot may, at the Auctioneer's sole discretion, be put up again and resold. No lots may be taken away until paid for in full and a pass obtained from the Auctioneers.
• If any lots are not paid for and removed in accordance with the provisions of the Conditions of Sale, than the Auctioneers may, without prejudice, to any other right they may have, remove, store, and insure the lots at the expense of the defaulting buyer. If after the expiry of seven days, the purchaser is still in default, the Auctioneers may resell the lots, either by public auction, or private contract. The purchaser, making such default, shall be liable for any deficiency arising from such resale, and for resulting expenses, any surplus arising shall belong to the Vendor.
• The Buyer's premium shall be the same for all buyers where the service offered is the same, therefore, bidders in the room, shall pay a premium of 23.4% inclusive of VAT, on the hammer price, and all agree that the Auctioneers, when acting as agent for the Vendor, may also receive commission from the Vendor in accordance with the Vendor's conditions.
• Buyer`s Premium 23.4% inclusive of VAT. Lots purchased online with the-saleroom.com will attract an additional charge for this service in the sum of 4.95% of the hammer price plus VAT at the rate imposed.
• Humbert & Ellis Ltd reserve the right to illustrate any lot offered for auction, and will use such photographs/digital images, both before and after the auction, at their discretion.
• The export of any lot from the United Kingdom, or import into another country, may be subject to licenses being granted. It is the buyer's responsibility to obtain any relevant import or export licenses. The denial of any such license or delay in obtaining a license shall not justify the rescission or cancellation of the sale.
All prospective commission bidders are respectfully requested to furnish the auctioneers with current and valid debit or credit card information in order to confirm their bids. This includes: the long card number, valid to and from dates and the three-digit 'ICQ' number verso.
The information will only be used subsequent to successful purchase of any lot and all information will be securely destroyed post sale.
Regretfully commission bids cannot be actioned without this information. Payment for all purchased lots is required within three working days of the sale. The auctioneers will be happy to remotely debit the relevant card by proxy and sent the receipt to the purchaser.


text:
Rom the Space Knight Returns to Comics
Rom the Space Knight began life as one of the first LED-driven action figures in the late 1970s, then went on to much more acclaim as a comic book hero. Now, removed from comics for over three decades, the character is being given new life in Rom the Space Knight, an all-new comic book series from IDW Publishing.
Rom the Space Knight #0 will make its debut on the first Saturday in May as IDW's "Gold" offering for Free Comic Book Day. The annual FCBD event sees thousands upon thousands of comics from all publishers given away for free at participating comic shops. The comic will be co-written by IDW Chief Creative Officer/Editor-in-Chief Chris Ryall and acclaimed comic-book/TV writer Christos Gage. Art on Rom #0 will be handled by David Messina, who will also be sharing artistic duties on the ongoing Rom series. The cover art for Rom #0 is by the Wild Blue Yonder team of Zach Howard and Nelson Daniel.
"It's no hyperbole for me to say that launching a new Rom comic is one of the things we've most wanted to make happen for fans," said Chris Ryall. "I know this because I'm one of them. The character has been absent from comics for too long and we can't wait to introduce this all-new version to the world."
Rom the Space Knight tells the story of Rom, a member of the benevolent Solstar Order and greatest of the Space Knights, interstellar soldiers in a centuries-old war with the Dire Wraiths. The Wraiths are a race of alien invaders who've destroyed many planets and infiltrated Earth for nefarious purposes.
Rom the Space Knight #0 will feature an introductory 10-page story of Rom's arrival on Earth, an incident that sets up an ongoing Rom series launching in July 2016.
"Many people have only heard of Rom but that's it," continued Ryall. "And those that do know of his past iteration might have some preconceived notion of what this series will be. And while we can promise that the DNA of the character as established with the original toy remains intact, there will be surprises galore as people experience a new universe built entirely around Rom and company."
As an added bonus, the issue will contain additional content including character sketches, creator interviews and a glimpse of things to come. This debut represents a major launch for IDW and Hasbro next year, and this special first story will be free throughout the universe next May!
More About:Industry News


text:
Formal Opinion 2007-01: Applicability of Dr 7-104 (The "no-contact Rule") To Contacts with In-house Counsel
TOPIC: Contact with in-house counsel of a represented party.
DIGEST: DR 7-104(A)(1)prohibits a lawyer from communicating with a party that the lawyer knows to be represented in that matter by another lawyer. Nevertheless, DR 7-104(A)(1) does not prohibit a lawyer from communicating with an in-house counsel of a party known to be represented in that matter, so long as the lawyer seeking to make that communication has a reasonable, good-faith belief based on objective indicia that such an individual is serving as a lawyer for the entity.
Does DR 7-104(A)(1) prohibit communication with in-house counsel of an organization known to be represented in the matter by outside counsel?
Many business entities and other organizations employ in-house counsel who perform legal (and sometimes other) services solely for the organization. In-house counsel may, without engaging outside counsel, represent the organization with respect to particular matters. An organization may also engage outside counsel to represent it in a matter. In those cases, the inside and outside counsel typically will together provide legal representation to the entity. The precise relationship and division of responsibilities between inside and outside counsel will vary widely from organization to organization and matter to matter. In other instances an in-house counsel may serve generally as a lawyer to the entity without having specific responsibility for the matter on which outside counsel has been retained. The question therefore arises whether, under DR 7-104(A)(1), counsel representing another party in a matter may communicate directly with the organization's in-house counsel, without the consent, knowledge, or participation of the organization's outside counsel. This question most often will arise as an ethical consideration for the lawyer who wishes to bypass opposing outside counsel and to initiate contact with in-house counsel. The question also will apply when an in-house counsel of an organization seeks to initiate contact with an adverse party's outside counsel, who would be obligated to determine whether he or she must decline to participate in the communication. It also will arise when, as is sometimes the case, in-house counsel for one party wishes to have a dialogue with in-house counsel for another party, even though both parties are also represented by outside counsel.
DR 7-104(A)(1) states that "[d]uring the course of the representation of a client[,] a lawyer shall not . . . communicate . . . with a party the lawyer knows to be represented by a lawyer in that matter" without the other lawyer's prior consent. When an organization with an in-house counsel retains outside counsel for a particular matter, the question arises whether, for purposes of DR 7-104(A)(1), the inside counsel is "a party . . . represented by" the outside counsel with respect to that matter, or whether the in-house counsel, just like the outside counsel, is a "lawyer" "represent[ing]" the organization for the purposes of the Rule. If the in-house counsel is a represented party (i.e., a client of the outside lawyer), then DR 7-104(A)(1) would prohibit contact with the in-house counsel by an attorney representing another person in the matter whenever the attorney is aware that outside counsel has been retained. On the other hand, if in-house counsel is a lawyer representing a client, then such contact would not be prohibited, in the same way that, as an ethical matter, a lawyer in a given matter is free to contact any one of several co-counsel (e.g., a local counsel or a lead counsel) representing an opposing party in that matter without the consent of the remaining co-counsel.
Neither the text of the Rule nor the relevant Ethical Consideration (EC-18) distinguishes between outside and inside counsel, and the Code in general views an in-house legal department as the equivalent of a traditional law firm. See 22 N.Y.C.R.R. § 1200.1 (definition of "law firm"). When only inside counsel represents an organization, obviously opposing counsel is free to communicate with that inside counsel even though he or she is forbidden from communicating with at least some of the other employees of the same organization.1 Nothing in the text of the Rule or related Ethical Consideration suggests that the result should change simply because the organization chooses to retain outside counsel to represent it, when it is also represented by in-house counsel. To the contrary, the Rule distinguishes between two (presumably mutually exclusive) categories of persons — lawyers representing a client, on the one hand, and parties represented by a lawyer, on the other. If an in-house counsel represents his or her employer, nothing in the Rule suggests that contact with such a lawyer is barred.
The relatively few courts and other authorities that have addressed this question have not reached a uniform conclusion whether communication with an in-house counsel is proscribed, but the majority view is that such communication is generally permissible. 2 The District Court for the District of Connecticut opined on the issue in In re Grievance Proceeding, 2002 WL 31106389 (D. Conn. July 19, 2002). In that case, the general counsel for the defendant corporation, in a litigation in which the defendant corporation was also represented by outside counsel, received two letters from plaintiff's counsel. Id. at *1. The letters at issue were (1) a copy to the general counsel of a letter addressed to the defendant corporation's outside counsel regarding ongoing settlement negotiations, and (2) a letter addressed directly to the defendant corporation's general counsel notifying him of the outside counsel's failure to respond to plaintiff's counsel's inquiries. ("[I]t has been several weeks since I have been able to get in touch with your client's [outside] attorney. Please advise if the firm still represents your client.") Id. Noting that "[t]he rule's primary concern is to avoid overreaching caused by disparity in legal knowledge . . . [i.e.,] to protect lay parties" and that "communication with a general counsel generally will not raise the same concerns as communication with a lay employee" because "[t]he general counsel's training in the law helps ensure a level playing field of legal expertise in communications with opposing counsel," the court found that "the purpose of [the Rule] is simply not implicated, and [thus] the Rule . . . does not prohibit" such contact. Id. at *2-3. See also ABA Formal Op. 06-443 (2006) ("[contact with] an inside lawyer, unless that lawyer is in fact a party in the matter and represented by the same counsel as the organization . . . is not prohibited"); Washington, D.C. Bar Ass'n, Ethics Op. 331 (2005) ("a lawyer generally is not proscribed . . . from contacting in-house counsel even though the entity is represented by outside counsel" because "the in-house counsel is not also the 'party' within the meaning of [the Rule]"); Restatement (Third) of the Law Governing Lawyers § 100 cmt. c (2000) (contact with an in-house counsel generally not barred); Carl A. Pierce, Variations on a Basic Theme: Revisiting the ABA's Revision of Model Rule 4.2 (Part I), 70 Tenn. L. Rev. 121, 184-87 (2002) (same).
A few authorities have taken a more restrictive stance. For example, in Philadelphia Bar Ethics Op. 2000-11 (2001), the committee stated without elaboration that "ordinarily [the Rule] prohibits direct contact with in-house counsel"—although it found such contact permissible in that particular case because in-house counsel had actively represented the organization in a prior, related administrative proceeding. See also N.C. State Bar Ass'n, Ethics Op. RPC-128 (1993) (contact prohibited with in-house counsel who appeared in case as management representative).
New York courts have not ruled on this question. See Tylena M. v. HeartShare Human Servs., 2004 WL 1252945, at *1-2 (S.D.N.Y. June 7, 2004) (raising but declining to resolve the issue). One commentator has stated that such communications are "ethically risky" under the New York Code of Professional Responsibility and that the question should be decided on a case-by-case basis, upon consideration of a number of highly fact-specific questions. Roy Simon, Simon's New York Code of Professional Responsibility Annotated 1057-58 (2006 ed.).3
The Rule should be interpreted in accordance with its purposes. Although in-house counsel may well be among the category of decision-makers within the organization with whom contact would be prohibited under even a relatively narrow version of the rule, see Niesig, 558 N.E.2d at 1031 n.1, the fact that such counsel are trained in the law and often assigned to represent an organization places them in a different position than a non-lawyer employee—a distinction that Niesig did not need to, and did not, address. The principal purposes of the Rule are to prevent a lawyer from taking advantage of a non-lawyer who is represented by counsel (for example, in eliciting damaging admissions or agreement to unfair settlement terms) and to preserve the attorney-client relationship once it has been established. See, e.g., Tylena M., 2004 WL 1252945, at *1; In re Grievance Proceeding, 2002 WL 31106389 at *2-3. These purposes are at best attenuated when the recipient of the communication is a lawyer, and is acting as such. It fairly may be presumed that an in-house counsel, trained in the law, can exercise judgment as to whether he or she should engage in a given communication. Moreover, in most cases it should be a simple matter for in-house counsel to refuse to engage in such a communication and refer the caller to outside counsel. If the in-house counsel chooses to engage in the communication, the risk of making damaging admissions or entering into prejudicial agreements would seem to be no greater than with any other lawyer-to-lawyer communication.
The reasons why a lawyer may seek to bypass outside counsel and communicate directly with in-house counsel are many and varied; some may be salutary or at least innocuous (e.g., to break an impasse in negotiations with outside counsel; to make a time-sensitive communication when outside counsel is incommunicado; to take advantage of a particularly good working relationship with in-house counsel from prior matters), while others may be less so (e.g., to seek to marginalize outside counsel in order to diminish his or her effectiveness). It is possible that, in some cases, a lawyer in a matter may be attempting to drive a wedge between in-house and outside counsel by contacting in-house counsel directly. Yet, such a communication would not exploit the imbalance of power inherent in lawyer-layperson contact that is the concern of DR 7-104(A)(1). For example, when a party retains two or more outside counsel, it is permissible for a lawyer for another party in the matter to contact any of them without the others' permission. Even though this could indirectly undermine the attorney-client relationship as between the adverse party and the lawyers excluded from the communication, DR 7-104(A)(1) has no bearing on the issue.
As a general proposition, the applicability of the Rule should not turn on the subjective motivations of the communicating lawyer because of the difficulty in assessing actual motivations after the fact and the possibility of mixed or unprovable motives. Nor should the permissibility of contact depend on data likely to be unknowable to the attorney seeking to make the contact. Cf. Simon, supra note 3. Such a fact-specific, subjective test would reduce the predictive value of the Rules and chill the prudent practitioner from making even those contacts with in-house counsel that are not prohibited by the Rules—effectively turning DR 7-104(A)(1) into a blanket "no-contact" rule for any reasonably cautious lawyer who wishes to communicate with in-house counsel.
A number of authorities have recognized that in-house counsel often play multiple roles in an organization, including purely business roles. See, e.g.,U.S. Postal Serv. v. Phelps Dodge Ref. Corp., 852 F. Supp. 156, 160 (E.D.N.Y. 1994) ("[I]n house counsel . . . frequently have multi-faceted duties that go beyond traditional tasks performed by lawyers. House counsel have increased participation in the day-to-day operations of large corporations.")4 For that reason, it would be inappropriate to conclusively presume that every in-house counsel is acting as a lawyer for the organization at all times and for all purposes. It is essential that the in-house counsel be acting as a lawyer for the entity, though not necessarily with respect to the subject matter of the communication at issue, for the communication to be proper. For contact with an organization's in-house counsel to be proper under DR 7-104(A)(1) in a situation where the organization is also represented by outside counsel, the contacting lawyer must have a good faith belief based on objective evidence that the in-house counsel is acting as a lawyer representing the organization, and not merely as outside counsel's client.
Objective indicia that in-house counsel is acting as "lawyer" for the purposes of DR 7-104(A)(1) will vary from case to case, but may include:
(1) Job title. Certain titles (e.g., "General Counsel," whether alone or conjoined with an officer title such as "Senior Vice President and General Counsel") presumptively signify that the person acts as lawyer for the organization, unless there is notice to the contrary.5 By contrast, other titles, such as "Director of Legal and Corporate Affairs" or "Director of Compliance" are ambiguous as to the role performed by the titleholder in a particular matter, and would not, standing alone, give rise to the same presumption.
(2) Court papers. If the matter in question is a litigation, papers filed in the case may list the in-house counsel as "Of Counsel." Such a reference would reasonably entitle another lawyer in the case to assume that the listed person is acting as a lawyer.
(3) Course of conduct. In both litigation and transactional matters, the course of conduct between the in-house counsel and the lawyer who wishes to contact him or her may give rise to the reasonable presumption that in-house counsel is acting as lawyer. Course of conduct may also include prior, related, or similar proceedings; if in-house counsel actively represented the organization in such a proceeding, one could fairly presume that he or she is fulfilling the same role in the current proceeding as well.6
(4) Membership in an in-house legal department. Corporations often maintain a legal department whose attorneys serve the needs of the business from a centralized location. In those instances, the similarity of the in-house lawyer's role to that of a member of an outside law firm is most pronounced, and ordinarily would indicate that the members of the department are serving the entity as lawyers.
(5) Inquiry. A lawyer who wishes to communicate with in-house counsel of another party can ask the in-house counsel if he or she is acting as attorney for the organization. In-house counsel should exercise candor in clarifying their role to opposing counsel7 and a lawyer who makes such inquiry can ordinarily rely on the response.
Objective indicia may also establish that in-house counsel is not acting as lawyer for the purposes of DR 7-104(A)(1), and is instead merely an employee of a "represented party." For example, if the in-house lawyer was a participant in the events that form the basis of the action (such as drafter or negotiator of a contract now in dispute), one would not generally expect that in-house lawyer to be acting as counsel in the same matter because of, among other considerations, ethical constraints on attorneys serving as witnesses in matters where they represent a party. See DR 5-102.
1. Whether the Rule prohibits contact with all non-attorney employees of a represented entity, or only a core group of employees, is beyond the scope of this opinion. Cf. Niesig v. Team I,558 N.E.2d 1030, 1035 (N.Y. Ct. App. 1990) (holding that direct communication by adversary counsel is prohibited "with those officials, but only those, who have the legal power to bind the corporation in the matter or who are responsible for implementing the advice of the corporation's lawyer, or any member of the organization whose own interests are directly at stake in a representation"). (citation omitted)
2. Most of these pronouncements have been interpretations of the corresponding provision of ABA Model Rule 4.2, which is not materially different from DR 7-104(A)(1).
3. Professor Simon lists eleven "factors that may be relevant": (1) size of the corporation whose in-house counsel is to be contacted; (2) size of its legal department; (3) degree of experience of the in-house counsel with the type of litigation involved; (4) degree to which the in-house lawyers are involved in the litigation; (5) assuming the desired contact is motivated by the behavior of the outside counsel, "[w]hat is stopping the . . . corporation from simply instructing its outside lawyers to change their behavior"; (6) who initiated the communication; (7) whether the corporation's "control group" is aware of the communication or desires it to take place; (8) whether the outside counsel has acted unreasonably or unethically; (9) whether a judge or magistrate has encouraged the communication; (10) whether the communications are "intended to undermine the opposing corporation's relationship with its outside lawyers," or whether the communication is occurring "precisely because that relationship has already deteriorated"; and (11) whether the communication will allow the communicating party to "take advantage" of the opposing party or will result in an "unfair agreement." Simon, supra, at 1057-58.
4. Many of those authorities arise in the context of a challenge to the privileged status of a communication between an in-house counsel and another employee of the organization on the ground that the in-house counsel was communicating in a business, not a legal, capacity. Because the application of the attorney-client privilege turns on considerations significantly different from those implicated in the present ethics question, nothing in this opinion should be read as taking a position on the privileged status of a communication with an in-house counsel.
5. See In re Grievance Proceeding, 2002 WL 31106389, at *3 ("the general counsel by definition is a corporation lawyer and, absent notice that the general counsel is acting in a role other than as a lawyer with respect to a particular matter, opposing counsel can communicate with him or her").
6. See Philadelphia Bar Ass'n, Ethics Op. 2000-11.
7. See DR 1-102(A)(4)("a lawyer . . .shall not . . . engage in conduct involving . . . misrepresentation.")