This is a non-blocking-delay (shown to me by muppet), and it will solve your particular problem in the example.

#sleep 10;
&non_blocking_delay( 10000 );

sub non_blocking_delay {
   my $milliseconds = shift;
   my $mainloop     = Glib::MainLoop->new;
   Glib::Timeout->add(
      $milliseconds,
      sub {
         print time, "\n";
         $mainloop->quit;
         FALSE;
      }
   );
   $mainloop->run;
   ;
}
[download]

However, you give a very simple and arbitrary example, and the above sub won't generally work. Depending on your needs, you might be able to use a piped-open to run your command( which basically forks it off ), then use a filehandle watch on it to collect results.

Glib::IO->add_watch( fileno $fh, [ qw/in/ ], \&watch_callback, $fh );


sub watch_callback {

   my ( $fd, $condition, $fh ) = @_;
   my @lines = $fh->getlines;
   print @lines;

#always return TRUE to continue the callback
   return TRUE;
}
                                                                
}
[download]

Also see Gtk2::Helper->add_watch, which is a bit easier. You can also use IPC::Open3 instead of a piped open. The only other thing you can do, is fork off the long process and communicate thru Shared Memory Segments.

But after all that, it is often easiest just to use threads and shared variables. :-) Don't let the anti-thread hype get you down. If done properly, threads work great, and I'm sure threads will be in Perl6's future.