lib/Moo.pm

   1 package Moo;
   2
   3 use strictures 1;
   4 use Moo::_Utils;
   5 use B 'perlstring';
   6 use Sub::Defer ();
   7
   8 our $VERSION = '0.091004'; # 0.91.4
   9 $VERSION = eval $VERSION;
  10
  11 require Moo::sification;
  12
  13 our %MAKERS;
  14
  15 sub import {
  16   my $target = caller;
  17   my $class = shift;
  18   strictures->import;
  19   return if $MAKERS{$target}; # already exported into this package
  20   _install_coderef "${target}::extends" => "Moo::extends" => sub {
  21     _load_module($_) for @_;
  22     # Can't do *{...} = \@_ or 5.10.0's mro.pm stops seeing @ISA
  23     @{*{_getglob("${target}::ISA")}{ARRAY}} = @_;
  24     if (my $old = delete $Moo::MAKERS{$target}{constructor}) {
  25       delete _getstash($target)->{new};
  26       Moo->_constructor_maker_for($target)
  27          ->register_attribute_specs(%{$old->all_attribute_specs});
  28     }
  29     $Moo::HandleMoose::MOUSE{$target} = [
  30       grep defined, map Mouse::Util::find_meta($_), @_
  31     ] if $INC{"Mouse.pm"};
  32     $class->_maybe_reset_handlemoose($target);
  33   };
  34   _install_coderef "${target}::with" => "Moo::with" => sub {
  35     require Moo::Role;
  36     Moo::Role->apply_roles_to_package($target, $_[0]);
  37     $class->_maybe_reset_handlemoose($target);
  38   };
  39   $MAKERS{$target} = {};
  40   _install_coderef "${target}::has" => "Moo::has" => sub {
  41     my ($name, %spec) = @_;
  42     $class->_constructor_maker_for($target)
  43           ->register_attribute_specs($name, \%spec);
  44     $class->_accessor_maker_for($target)
  45           ->generate_method($target, $name, \%spec);
  46     $class->_maybe_reset_handlemoose($target);
  47   };
  48   foreach my $type (qw(before after around)) {
  49     _install_coderef "${target}::${type}" => "Moo::${type}" => sub {
  50       require Class::Method::Modifiers;
  51       _install_modifier($target, $type, @_);
  52     };
  53   }
  54   {
  55     no strict 'refs';
  56     @{"${target}::ISA"} = do {
  57       require Moo::Object; ('Moo::Object');
  58     } unless @{"${target}::ISA"};
  59   }
  60   if ($INC{'Moo/HandleMoose.pm'}) {
  61     Moo::HandleMoose::inject_fake_metaclass_for($target);
  62   }
  63 }
  64
  65 sub _maybe_reset_handlemoose {
  66   my ($class, $target) = @_;
  67   if ($INC{"Moo/HandleMoose.pm"}) {
  68     Moo::HandleMoose::maybe_reinject_fake_metaclass_for($target);
  69   }
  70 }
  71
  72 sub _accessor_maker_for {
  73   my ($class, $target) = @_;
  74   return unless $MAKERS{$target};
  75   $MAKERS{$target}{accessor} ||= do {
  76     my $maker_class = do {
  77       if (my $m = do {
  78             if (my $defer_target =
  79                   (Sub::Defer::defer_info($target->can('new'))||[])->[0]
  80               ) {
  81               my ($pkg) = ($defer_target =~ /^(.*)::[^:]+$/);
  82               $MAKERS{$pkg} && $MAKERS{$pkg}{accessor};
  83             } else {
  84               undef;
  85             }
  86           }) {
  87         ref($m);
  88       } else {
  89         require Method::Generate::Accessor;
  90         'Method::Generate::Accessor'
  91       }
  92     };
  93     $maker_class->new;
  94   }
  95 }
  96
  97 sub _constructor_maker_for {
  98   my ($class, $target, $select_super) = @_;
  99   return unless $MAKERS{$target};
 100   $MAKERS{$target}{constructor} ||= do {
 101     require Method::Generate::Constructor;
 102     require Sub::Defer;
 103     my ($moo_constructor, $con);
 104
 105     if ($select_super && $MAKERS{$select_super}) {
 106       $moo_constructor = 1;
 107       $con = $MAKERS{$select_super}{constructor};
 108     } else {
 109       my $t_new = $target->can('new');
 110       if ($t_new) {
 111         if ($t_new == Moo::Object->can('new')) {
 112           $moo_constructor = 1;
 113         } elsif (my $defer_target = (Sub::Defer::defer_info($t_new)||[])->[0]) {
 114           my ($pkg) = ($defer_target =~ /^(.*)::[^:]+$/);
 115           if ($MAKERS{$pkg}) {
 116             $moo_constructor = 1;
 117             $con = $MAKERS{$pkg}{constructor};
 118           }
 119         }
 120       } else {
 121         $moo_constructor = 1; # no other constructor, make a Moo one
 122       }
 123     };
 124     ($con ? ref($con) : 'Method::Generate::Constructor')
 125       ->new(
 126         package => $target,
 127         accessor_generator => $class->_accessor_maker_for($target),
 128         construction_string => (
 129           $moo_constructor
 130             ? ($con ? $con->construction_string : undef)
 131             : ('$class->'.$target.'::SUPER::new(@_)')
 132         ),
 133         subconstructor_handler => (
 134           '      if ($Moo::MAKERS{$class}) {'."\n"
 135           .'        '.$class.'->_constructor_maker_for($class,'.perlstring($target).');'."\n"
 136           .'        return $class->new(@_)'.";\n"
 137           .'      }'."\n"
 138         ),
 139       )
 140       ->install_delayed
 141       ->register_attribute_specs(%{$con?$con->all_attribute_specs:{}})
 142   }
 143 }
 144
 145 1;
 146 =pod
 147
 148 =encoding utf-8
 149
 150 =head1 NAME
 151
 152 Moo - Minimalist Object Orientation (with Moose compatiblity)
 153
 154 =head1 SYNOPSIS
 155
 156  package Cat::Food;
 157
 158  use Moo;
 159  use Sub::Quote;
 160
 161  sub feed_lion {
 162    my $self = shift;
 163    my $amount = shift || 1;
 164
 165    $self->pounds( $self->pounds - $amount );
 166  }
 167
 168  has taste => (
 169    is => 'ro',
 170  );
 171
 172  has brand => (
 173    is  => 'ro',
 174    isa => sub {
 175      die "Only SWEET-TREATZ supported!" unless $_[0] eq 'SWEET-TREATZ'
 176    },
 177 );
 178
 179  has pounds => (
 180    is  => 'rw',
 181    isa => quote_sub q{ die "$_[0] is too much cat food!" unless $_[0] < 15 },
 182  );
 183
 184  1;
 185
 186 and else where
 187
 188  my $full = Cat::Food->new(
 189     taste  => 'DELICIOUS.',
 190     brand  => 'SWEET-TREATZ',
 191     pounds => 10,
 192  );
 193
 194  $full->feed_lion;
 195
 196  say $full->pounds;
 197
 198 =head1 DESCRIPTION
 199
 200 This module is an extremely light-weight, high-performance L<Moose> replacement.
 201 It also avoids depending on any XS modules to allow simple deployments.  The
 202 name C<Moo> is based on the idea that it provides almost -but not quite- two
 203 thirds of L<Moose>.
 204
 205 Unlike C<Mouse> this module does not aim at full L<Moose> compatibility.  See
 206 L</INCOMPATIBILITIES> for more details.
 207
 208 =head1 WHY MOO EXISTS
 209
 210 If you want a full object system with a rich Metaprotocol, L<Moose> is
 211 already wonderful.
 212
 213 I've tried several times to use L<Mouse> but it's 3x the size of Moo and
 214 takes longer to load than most of my Moo based CGI scripts take to run.
 215
 216 If you don't want L<Moose>, you don't want "less metaprotocol" like L<Mouse>,
 217 you want "as little as possible" - which means "no metaprotocol", which is
 218 what Moo provides.
 219
 220 By Moo 1.0 I intend to have Moo's equivalent of L<Any::Moose> built in -
 221 if Moose gets loaded, any Moo class or role will act as a Moose equivalent
 222 if treated as such.
 223
 224 Hence - Moo exists as its name - Minimal Object Orientation - with a pledge
 225 to make it smooth to upgrade to L<Moose> when you need more than minimal
 226 features.
 227
 228 =head1 Moo and Moose - NEW, EXPERIMENTAL
 229
 230 If L<Moo> detects L<Moose> being loaded, it will automatically register
 231 metaclasses for your L<Moo> and L<Moo::Role> packages, so you should be able
 232 to use them in L<Moose> code without it ever realising you aren't using
 233 L<Moose> everywhere.
 234
 235 Extending a L<Moose> class or consuming a L<Moose::Role> should also work.
 236
 237 So should extending a L<Mouse> class or consuming a L<Mouse::Role>.
 238
 239 This means that there is no need for anything like L<Any::Moose> for Moo
 240 code - Moo and Moose code should simply interoperate without problem. To
 241 handle L<Mouse> code, you'll likely need an empty Moo role or class consuming
 242 or extending the L<Mouse> stuff since it doesn't register true L<Moose>
 243 metaclasses like we do.
 244
 245 However, these features are new as of 0.91.0 (0.091000) so while serviceable,
 246 they are absolutely certain to not be 100% yet; please do report bugs.
 247
 248 If you need to disable the metaclass creation, add:
 249
 250   no Moo::sification;
 251
 252 to your code before Moose is loaded, but bear in mind that this switch is
 253 currently global and turns the mechanism off entirely, so don't put this
 254 in library code, only in a top level script as a temporary measure while
 255 you send a bug report.
 256
 257 =head1 IMPORTED METHODS
 258
 259 =head2 new
 260
 261  Foo::Bar->new( attr1 => 3 );
 262
 263 or
 264
 265  Foo::Bar->new({ attr1 => 3 });
 266
 267 =head2 BUILDARGS
 268
 269  sub BUILDARGS {
 270    my ( $class, @args ) = @_;
 271
 272    unshift @args, "attr1" if @args % 2 == 1;
 273
 274    return { @args };
 275  };
 276
 277  Foo::Bar->new( 3 );
 278
 279 The default implementation of this method accepts a hash or hash reference of
 280 named parameters. If it receives a single argument that isn't a hash reference
 281 it throws an error.
 282
 283 You can override this method in your class to handle other types of options
 284 passed to the constructor.
 285
 286 This method should always return a hash reference of named options.
 287
 288 =head2 BUILD
 289
 290 Define a C<BUILD> method on your class and the constructor will automatically
 291 call the C<BUILD> method from parent down to child after the object has
 292 been instantiated.  Typically this is used for object validation or possibly
 293 logging.
 294
 295 =head2 DEMOLISH
 296
 297 If you have a C<DEMOLISH> method anywhere in your inheritance hierarchy,
 298 a C<DESTROY> method is created on first object construction which will call
 299 C<< $instance->DEMOLISH($in_global_destruction) >> for each C<DEMOLISH>
 300 method from child upwards to parents.
 301
 302 Note that the C<DESTROY> method is created on first construction of an object
 303 of your class in order to not add overhead to classes without C<DEMOLISH>
 304 methods; this may prove slightly surprising if you try and define your own.
 305
 306 =head2 does
 307
 308  if ($foo->does('Some::Role1')) {
 309    ...
 310  }
 311
 312 Returns true if the object composes in the passed role.
 313
 314 =head1 IMPORTED SUBROUTINES
 315
 316 =head2 extends
 317
 318  extends 'Parent::Class';
 319
 320 Declares base class. Multiple superclasses can be passed for multiple
 321 inheritance (but please use roles instead).
 322
 323 Calling extends more than once will REPLACE your superclasses, not add to
 324 them like 'use base' would.
 325
 326 =head2 with
 327
 328  with 'Some::Role1';
 329
 330 or
 331
 332  with 'Some::Role1', 'Some::Role2';
 333
 334 Composes one or more L<Moo::Role> (or L<Role::Tiny>) roles into the current
 335 class.  An error will be raised if these roles have conflicting methods.
 336
 337 =head2 has
 338
 339  has attr => (
 340    is => 'ro',
 341  );
 342
 343 Declares an attribute for the class.
 344
 345 The options for C<has> are as follows:
 346
 347 =over 2
 348
 349 =item * is
 350
 351 B<required>, may be C<ro>, C<rw>, C<lazy> or C<rwp>.
 352
 353 C<ro> generates an accessor that dies if you attempt to write to it - i.e.
 354 a getter only - by defaulting C<reader> to the name of the attribute.
 355
 356 C<rw> generates a normal getter/setter by defaulting C<accessor> to the
 357 name of the attribute.
 358
 359 C<lazy> generates a reader like C<ro>, but also sets C<lazy> to 1 and
 360 C<builder> to C<_build_${attribute_name}> to allow on-demand generated
 361 attributes.  This feature was my attempt to fix my incompetence when
 362 originally designing C<lazy_build>, and is also implemented by
 363 L<MooseX::AttributeShortcuts>.
 364
 365 C<rwp> generates a reader like C<ro>, but also sets C<writer> to
 366 C<_set_${attribute_name}> for attributes that are designed to be written
 367 from inside of the class, but read-only from outside.
 368 This feature comes from L<MooseX::AttributeShortcuts>.
 369
 370 =item * isa
 371
 372 Takes a coderef which is meant to validate the attribute.  Unlike L<Moose> Moo
 373 does not include a basic type system, so instead of doing C<< isa => 'Num' >>,
 374 one should do
 375
 376  isa => quote_sub q{
 377    die "$_[0] is not a number!" unless looks_like_number $_[0]
 378  },
 379
 380 L<Sub::Quote aware|/SUB QUOTE AWARE>
 381
 382 Since L<Moo> does B<not> run the C<isa> check before C<coerce> if a coercion
 383 subroutine has been supplied, C<isa> checks are not structural to your code
 384 and can, if desired, be omitted on non-debug builds (although if this results
 385 in an uncaught bug causing your program to break, the L<Moo> authors guarantee
 386 nothing except that you get to keep both halves).
 387
 388 If you want L<MooseX::Types> style named types, look at
 389 L<MooX::Types::MooseLike>.
 390
 391 To cause your C<isa> entries to be automatically mapped to named
 392 L<Moose::Meta::TypeConstraint> objects (rather than the default behaviour
 393 of creating an anonymous type), set:
 394
 395   $Moo::HandleMoose::TYPE_MAP{$isa_coderef} = sub {
 396     require MooseX::Types::Something;
 397     return MooseX::Types::Something::TypeName();
 398   };
 399
 400 Note that this example is purely illustrative; anything that returns a
 401 L<Moose::Meta::TypeConstraint> object or something similar enough to it to
 402 make L<Moose> happy is fine.
 403
 404 =item * coerce
 405
 406 Takes a coderef which is meant to coerce the attribute.  The basic idea is to
 407 do something like the following:
 408
 409  coerce => quote_sub q{
 410    $_[0] + 1 unless $_[0] % 2
 411  },
 412
 413 Note that L<Moo> will always fire your coercion - this is to permit
 414 isa entries to be used purely for bug trapping, whereas coercions are
 415 always structural to your code. We do, however, apply any supplied C<isa>
 416 check after the coercion has run to ensure that it returned a valid value.
 417
 418 L<Sub::Quote aware|/SUB QUOTE AWARE>
 419
 420 =item * handles
 421
 422 Takes a string
 423
 424   handles => 'RobotRole'
 425
 426 Where C<RobotRole> is a role (L<Moo::Role>) that defines an interface which
 427 becomes the list of methods to handle.
 428
 429 Takes a list of methods
 430
 431  handles => [ qw( one two ) ]
 432
 433 Takes a hashref
 434
 435  handles => {
 436    un => 'one',
 437  }
 438
 439 =item * trigger
 440
 441 Takes a coderef which will get called any time the attribute is set. This
 442 includes the constructor. Coderef will be invoked against the object with the
 443 new value as an argument.
 444
 445 If you set this to just C<1>, it generates a trigger which calls the
 446 C<_trigger_${attr_name}> method on C<$self>. This feature comes from
 447 L<MooseX::AttributeShortcuts>.
 448
 449 Note that Moose also passes the old value, if any; this feature is not yet
 450 supported.
 451
 452 L<Sub::Quote aware|/SUB QUOTE AWARE>
 453
 454 =item * default
 455
 456 Takes a coderef which will get called with $self as its only argument
 457 to populate an attribute if no value is supplied to the constructor - or
 458 if the attribute is lazy, when the attribute is first retrieved if no
 459 value has yet been provided.
 460
 461 Note that if your default is fired during new() there is no guarantee that
 462 other attributes have been populated yet so you should not rely on their
 463 existence.
 464
 465 L<Sub::Quote aware|/SUB QUOTE AWARE>
 466
 467 =item * predicate
 468
 469 Takes a method name which will return true if an attribute has a value.
 470
 471 If you set this to just C<1>, the predicate is automatically named
 472 C<has_${attr_name}> if your attribute's name does not start with an
 473 underscore, or <_has_${attr_name_without_the_underscore}> if it does.
 474 This feature comes from L<MooseX::AttributeShortcuts>.
 475
 476 =item * builder
 477
 478 Takes a method name which will be called to create the attribute - functions
 479 exactly like default except that instead of calling
 480
 481   $default->($self);
 482
 483 Moo will call
 484
 485   $self->$builder;
 486
 487 If you set this to just C<1>, the predicate is automatically named
 488 C<_build_${attr_name}>.  This feature comes from L<MooseX::AttributeShortcuts>.
 489
 490 =item * clearer
 491
 492 Takes a method name which will clear the attribute.
 493
 494 If you set this to just C<1>, the clearer is automatically named
 495 C<clear_${attr_name}> if your attribute's name does not start with an
 496 underscore, or <_clear_${attr_name_without_the_underscore}> if it does.
 497 This feature comes from L<MooseX::AttributeShortcuts>.
 498
 499 =item * lazy
 500
 501 B<Boolean>.  Set this if you want values for the attribute to be grabbed
 502 lazily.  This is usually a good idea if you have a L</builder> which requires
 503 another attribute to be set.
 504
 505 =item * required
 506
 507 B<Boolean>.  Set this if the attribute must be passed on instantiation.
 508
 509 =item * reader
 510
 511 The value of this attribute will be the name of the method to get the value of
 512 the attribute.  If you like Java style methods, you might set this to
 513 C<get_foo>
 514
 515 =item * writer
 516
 517 The value of this attribute will be the name of the method to set the value of
 518 the attribute.  If you like Java style methods, you might set this to
 519 C<set_foo>
 520
 521 =item * weak_ref
 522
 523 B<Boolean>.  Set this if you want the reference that the attribute contains to
 524 be weakened; use this when circular references are possible, which will cause
 525 leaks.
 526
 527 =item * init_arg
 528
 529 Takes the name of the key to look for at instantiation time of the object.  A
 530 common use of this is to make an underscored attribute have a non-underscored
 531 initialization name. C<undef> means that passing the value in on instantiation
 532 is ignored.
 533
 534 =back
 535
 536 =head2 before
 537
 538  before foo => sub { ... };
 539
 540 See L<< Class::Method::Modifiers/before method(s) => sub { ... } >> for full
 541 documentation.
 542
 543 =head2 around
 544
 545  around foo => sub { ... };
 546
 547 See L<< Class::Method::Modifiers/around method(s) => sub { ... } >> for full
 548 documentation.
 549
 550 =head2 after
 551
 552  after foo => sub { ... };
 553
 554 See L<< Class::Method::Modifiers/after method(s) => sub { ... } >> for full
 555 documentation.
 556
 557 =head1 SUB QUOTE AWARE
 558
 559 L<Sub::Quote/quote_sub> allows us to create coderefs that are "inlineable,"
 560 giving us a handy, XS-free speed boost.  Any option that is L<Sub::Quote>
 561 aware can take advantage of this.
 562
 563 =head1 INCOMPATIBILITIES WITH MOOSE
 564
 565 There is no built in type system.  C<isa> is verified with a coderef, if you
 566 need complex types, just make a library of coderefs, or better yet, functions
 567 that return quoted subs. L<MooX::Types::MooseLike> provides a similar API
 568 to L<MooseX::Types::Moose> so that you can write
 569
 570   has days_to_live => (is => 'ro', isa => Int);
 571
 572 and have it work with both; it is hoped that providing only subrefs as an
 573 API will encourage the use of other type systems as well, since it's
 574 probably the weakest part of Moose design-wise.
 575
 576 C<initializer> is not supported in core since the author considers it to be a
 577 bad idea but may be supported by an extension in future. Meanwhile C<trigger> or
 578 C<coerce> are more likely to be able to fulfill your needs.
 579
 580 There is no meta object.  If you need this level of complexity you wanted
 581 L<Moose> - Moo succeeds at being small because it explicitly does not
 582 provide a metaprotocol. However, if you load L<Moose>, then
 583
 584   Class::MOP::class_of($moo_class_or_role)
 585
 586 will return an appropriate metaclass pre-populated by L<Moo>.
 587
 588 No support for C<super>, C<override>, C<inner>, or C<augment> - override can
 589 be handled by around albeit with a little more typing, and the author considers
 590 augment to be a bad idea.
 591
 592 The C<dump> method is not provided by default. The author suggests loading
 593 L<Devel::Dwarn> into C<main::> (via C<perl -MDevel::Dwarn ...> for example) and
 594 using C<$obj-E<gt>$::Dwarn()> instead.
 595
 596 L</default> only supports coderefs, because doing otherwise is usually a
 597 mistake anyway.
 598
 599 C<lazy_build> is not supported; you are instead encouraged to use the
 600 C<is => 'lazy'> option supported by L<Moo> and L<MooseX::AttributeShortcuts>.
 601
 602 C<auto_deref> is not supported since the author considers it a bad idea.
 603
 604 C<documentation> will show up in a L<Moose> metaclass created from your class
 605 but is otherwise ignored. Then again, L<Moose> ignores it as well, so this
 606 is arguably not an incompatibility.
 607
 608 Since C<coerce> does not require C<isa> to be defined but L<Moose> does
 609 require it, the metaclass inflation for coerce-alone is a trifle insane
 610 and if you attempt to subtype the result will almost certainly break.
 611
 612 Handling of warnings: when you C<use Moo> we enable FATAL warnings.  The nearest
 613 similar invocation for L<Moose> would be:
 614
 615   use Moose;
 616   use warnings FATAL => "all";
 617
 618 Additionally, L<Moo> supports a set of attribute option shortcuts intended to
 619 reduce common boilerplate.  The set of shortcuts is the same as in the L<Moose>
 620 module L<MooseX::AttributeShortcuts> as of its version 0.009+.  So if you:
 621
 622     package MyClass;
 623     use Moo;
 624
 625 The nearest L<Moose> invocation would be:
 626
 627     package MyClass;
 628
 629     use Moose;
 630     use warnings FATAL => "all";
 631     use MooseX::AttributeShortcuts;
 632
 633 or, if you're inheriting from a non-Moose class,
 634
 635     package MyClass;
 636
 637     use Moose;
 638     use MooseX::NonMoose;
 639     use warnings FATAL => "all";
 640     use MooseX::AttributeShortcuts;
 641
 642 Finally, Moose requires you to call
 643
 644     __PACKAGE__->meta->make_immutable;
 645
 646 at the end of your class to get an inlined (i.e. not horribly slow)
 647 constructor. Moo does it automatically the first time ->new is called
 648 on your class.
 649
 650 =head1 SUPPORT
 651
 652 IRC: #web-simple on irc.perl.org
 653
 654 =head1 AUTHOR
 655
 656 mst - Matt S. Trout (cpan:MSTROUT) <mst@shadowcat.co.uk>
 657
 658 =head1 CONTRIBUTORS
 659
 660 dg - David Leadbeater (cpan:DGL) <dgl@dgl.cx>
 661
 662 frew - Arthur Axel "fREW" Schmidt (cpan:FREW) <frioux@gmail.com>
 663
 664 hobbs - Andrew Rodland (cpan:ARODLAND) <arodland@cpan.org>
 665
 666 jnap - John Napiorkowski (cpan:JJNAPIORK) <jjn1056@yahoo.com>
 667
 668 ribasushi - Peter Rabbitson (cpan:RIBASUSHI) <ribasushi@cpan.org>
 669
 670 chip - Chip Salzenberg (cpan:CHIPS) <chip@pobox.com>
 671
 672 ajgb - Alex J. G. Burzyński (cpan:AJGB) <ajgb@cpan.org>
 673
 674 doy - Jesse Luehrs (cpan:DOY) <doy at tozt dot net>
 675
 676 perigrin - Chris Prather (cpan:PERIGRIN) <chris@prather.org>
 677
 678 =head1 COPYRIGHT
 679
 680 Copyright (c) 2010-2011 the Moo L</AUTHOR> and L</CONTRIBUTORS>
 681 as listed above.
 682
 683 =head1 LICENSE
 684
 685 This library is free software and may be distributed under the same terms
 686 as perl itself.
 687
 688 =cut