ð[å·ð[å·{
      my ($logger)  = shift;
      my ($level)   = pop;
      my $message;
      my $appenders_fired = 0;
      
      # Evaluate all parameters that need to evaluated. Two kinds:
      #
      # (1) It's a hash like { filter => "filtername",
      #                        value  => "value" }
      #     => filtername(value)
      #
      # (2) It's a code ref
      #     => coderef()
      #

      $message   = [map { ref $_ eq "HASH" && 
                           exists $_->{filter} && 
                           ref $_->{filter} eq 'CODE' ?
                               $_->{filter}->($_->{value}) :
                           ref $_ eq "CODE" ?
                               $_->() : $_ 
                          } @_];                  
      
      print("coderef: $logger->{category}
") if _INTERNAL_DEBUG;

              print "exe_watch_code:
" if _INTERNAL_DEBUG;
                       
        # more closures here
        if(time() > $Log::Log4perl::Config::Watch::NEXT_CHECK_TIME 
              and $Log::Log4perl::Config::WATCHER->change_detected()) {
            if(!defined $logger) {
                $logger  = shift;
                $level   = pop;
            }
           
            Log::Log4perl->init_and_watch();
                       
            my $methodname = lc($level);

                # Bump up the caller level by two, since
                # we've artifically introduced additional levels.
            local($Log::Log4perl::caller_depth);
            $Log::Log4perl::caller_depth += 2;

            $logger->$methodname(@_); # send the message
                                         # to the new configuration
            return;        #and return, we're done with this incarnation
        }
;  #note interpolation here
      
      foreach my $a (@$appenders) {   #note the closure here
          my ($appender_name, $appender) = @$a;

          print("  Sending message '<$message>' ($level) " .
                "to $appender_name
") if _INTERNAL_DEBUG;
                
          $appender->log(
              #these get passed through to Log::Dispatch
              { name    => $appender_name,
                level   => $Log::Log4perl::Level::L4P_TO_LD{
                               $level},   
                message => $message,
              },
              #these we need
              $logger->{category},
              $level,
          ) and $appenders_fired++;
              # Only counting it if it returns a true value. Otherwise
              # the appender threshold might have suppressed it after all.
    
      } #end foreach appenders
    
      return $appenders_fired;

    }; #end coderef


;