Richard, That is a nice summary of some differences among various Callables.
Rob On Tue, Aug 30, 2022 at 09:34:01PM +0100, Richard Hainsworth wrote: > Hi Todd, > > Long time no see. > > Re your 'keeper'. There is a reason why things are called the way they are > in Raku (aka Perl6). BEGIN is NOT a special subroutine. > > BEGIN is a phaser. And it introduces a block. Blocks are not subroutines > (subs). Even though blocks and subs (and methods and callables) are code > related things, a sub can take a signature, but a block cannot. You can pass > arguments to a block using pointy syntax, eg -> $x, %y { ... }, which is > why it is possible to do things like 'for %some-hash.kv -> $key, $value { > .... }'. The 'for' takes a block, which can be pointy. 'for' does not take a > special subroutine. > > But a sub can have a parameter list, eg., 'sub (Int $b where *>= 10) { say > %b }; ' The 'where' bit means that the compiler will put in checks that $b > is always greater-equal to 10. So subs are far far more than blocks. > > Also you cannot return from a block, but you can return from a sub. > > So, by putting in your keeper that BEGIN is a special subroutine, you are > ignoring a whole world of Raku goodness, as well as making it difficult for > yourself to understand other phasers. > > And talking of phasers, there are some really useful ones, like FIRST and > LAST, that are in loops. So if you want something to happen first time in a > loop, put it in FIRST { }. > > Also I see you are on the compile time whine again. When perl6 first became > available as 'pugs', it did take FOREVER. Then as more of perl6 became > implemented as rakudo, startup times became slower. > > Things changed when modules were precompiled. I really do not understand > what you are talking about when you say you don't think precompile is useful > everywhere. > > For example, when I write something that is called from the command line > (for example in my raku-collection-raku-documentation distribution), I have > a one-liner raku program 'RakuDoc' that just says 'use Collection::RakuDoc'. > > EVERYTHING else is in the module Collection::RakuDoc, all the MAIN > subroutines, and stuff. That then only gets compiled once. So, the first > time RakuDoc is called from the command line, there is a startup delay > because the whole module is compiled. Every other time RakuDoc is called, > its really so fast I don't notice a problem. Only the *one* line is compiled > each time the program is called. All the rest is in precompiled form. > > Same with my Extractor program, which is in the raku-extraction module. This > is a GUI program that takes the rakudoc (aka POD6) files and converts them > into markdown. For example, I write the README's for my github repos as > README.rakudoc, then use Extractor to turn it into a README.md. The result > is far better because the rakudoc renderer I use (from my pod-render > distribution) automatically collects all the headers and puts them into a > Table of Contents. If you've tried to do a TOC in markdown, you know what a > hassle it is. > > But Extractor is a GTK::Simple program. And GTK::Simple takes forever to > precompile. But once done, I don't notice any startup time. > > And I change my software quite a lot, so every time I change something, yes, > startup is slow the first time, but not the next time. Surely, you use a > piece of software more than once. > > Compared to the OLD days, rakudo programs react like lightning. Design your > software properly, and you wont - as a human - notice much of a delay. > > I think the startup complaint (not the compile time for something) has been > effectively relegated to the days when rakudo was young. So whilst in the > past I truly sympathised with your rants about compile times, I am now quite > confused and I find sympathy hard to come by. > > Since you continue for ever to complain about 'compile' time issues, rather > than startup times, I wonder whether the programs you write are massive > monolithic lines of code with thousands of lines, much like most standard > software when FORTRAN or COBOL were the high level languages, or whether you > design things to make each section more manageable. > > If the programs you write to be run from the command line are thousands of > lines long, then yes!! you will suffer!!! from long!!!! startup times > because the program is re-compiled EVERY time. However, if you redesign the > code, putting things into classes, roles, subroutines, and Raku-y goody > things, you can push stuff into modules, and reduce your calling program to > a single line. > > When you change your software, do you change every part of it every time? Or > do you change some client related interface part? Put the interface part > into one module, and the other more stable functionality into other modules. > Then when you change the interface part, you dont change the other modules. > They have already been compiled. So the first time you start up your > program, only the section you have changed gets recompiled, not the entire > monolith. > > By the way, I assume that you understand the Raku meaning of 'module', as > opposed to a 'distribution'. When I write a large piece of software, I may > have three or four different modules under the lib/ directory. The top level > program (I try to make it one line only), uses one module, which then may > use other modules, all of them in the same directory, under the lib/ > subdirectory. The distribution can then also contain simple tests under t/ > and development tests under xt/ > > Regards, > > Richard > > On 30/08/2022 2:38 am, ToddAndMargo via perl6-users wrote: > > On 8/28/22 15:58, ToddAndMargo via perl6-users wrote: > > > Hi All, > > > > > > I am thinking of using > > > > > > BEGIN {} > > > > > > to fire up a splash screen (libnotify). > > > > > > Question: is what happens between the brackets > > > isolated from the rest of the code? If I set > > > variable values or declare variables, are they > > > wiped out, etc.? > > > > > > Many thanks, > > > -T > > > > > > > > > > > > > > My keeper on BEGIN. That you for all the help > > and tips! > > > > > > > > Perl6: BEGIN {} > > > > > > BEGIN is a special subroutine that runs at compile time. > > It will see any code above it, such as variables and > > imported modules, but not below it. > > > > The idea is to run something at the start of compile before > > the rest of compile completes. A splash screen for example. > > > > Perl 6's compile can take a very long time and users may not > > realize it started and restart it several times. > > > > Note that a space is required between `BEGIN and the `{}` > > > > > > BEGIN { > > # Splash Screen > > > > ( my $ProgramName = $?FILE ) ~~ s|.*"/"||; > > my Str $NotifyStr = "\nStarting $ProgramName\n"; > > my Str $Icon = "/home/linuxutil/Images/Info.png"; > > my Str $Title = "$ProgramName Splash Screen"; > > my Str $Timeout = "8"; # zenity = seconds > > > > # Note: zenity seems to not detach when run without a shell > > shell "zenity --info --title \"$Title\" --text \"$NotifyStr\" > > --width=220 --timeout=$Timeout &"; > > } > >