moar | Moar is a pager It's designed to just do the right thing without any configuration | Command Line Interface library

[EDIT 2021-03-06: thanks to a series of commits over the past ~day (thanks, Liz!), this slowdown is now largely fixed on HEAD; these performance gains should show up in the next monthly release. I'm leaving the answer below as an example of how to dig into this sort of issue, but the specific problems it diagnosed have largely been resolved.]

Building on @Elizabeth Mattijsen's comment: The slow performance here is mostly due to the Rakudo compiler not properly optimizing the generated code (as of 2021-03-05). As the compiler continues to improve, the (idiomatic) code you wrote above should perform much better.

However, for today we can use a few workarounds to speed up this calculation. While it's still true that Raku's performance won't be particularly competitive with R here, some profiling-driven refactoring can make this code nearly an order of magnitude faster.

Here's how we do it:

First, we start by profiling the code. If you run your script with raku --profile=, then you'll get a profile written to . By default, this will be an HTML file that allows you to view the profile in your browser. My preference, however, is to specify an .sql extension, which generates an SQL profile. I then view this profile with MoarProf, the revised profiler that Timo Paulssen is building.

Looking at this profile shows exactly the issue that Liz mentioned: Calls that should be getting inlined are not. To fix this, let's create our own sorting function, which the JIT compiler will happily optimize:

tl;dr;

this is what you want:

• moar is the vm (not very useful without a bytecode file)
• nqp is for NQP (Not Quite Perl6). Which is a small subset of Raku that is faster / easier to optimize. (No = op for example)
  It is the bootstrap compiler for Rakudo.

For the others like rakudo-m

• *-m means on MoarVM
• *-j means on JVM (not installed here)
• *-js means on JavaScript (not installed here)

• *-debug means, use the version with debugging information
• *-gdb means use the version with GNU Debugger information
• *-lldb means use the version with LLDB debugging information
• *-valgrind means use the Valgrind instrumentation framework (find memory leaks)

So then rakudo-valgrind-m means use Rakudo compiler with Valgrind instrumentation on MoarVM.

About the only ones I would use is rakudo-m, and rakudo-j or rakudo-js, and that is only if I had more than just the MoarVM version installed.

Mainly the rest are for people that are working on Rakudo/NQP/MoarVM projects themselves.

The reason was painfully simple.

I had by mistake pinned a really old version of 'sphinx-rtd-theme' in my 'requirements.txt' file.

I had pinned version 0.1.5 instead of the latest 0.5.1
My local env simply had a more recent version.

Doh! 🤦

File::Find is not built into Raku or distributed with Rakudo Star; to my knowledge, it never has been.

It is a module in the ecosystem that you can install with Zef (use the command zef install File::Find).

It is also a very short library. If you are interested in fixing your script without adding a dependency, you may want to check out the source code for File::Find; it is short enough that you could easily implement the same functionality yourself.

Your listitem elements are using which is an inline element and why the words display next to each other instead of on top of each other. You can use a different element or add a class to the listitem elements to make the display:block. In this example, I chose to add CSS for the listitem class. I also added a hover effect for fun.

I'm afraid the REPL in its current state, has several deficiencies regarding several Raku features, such as native variables and operator definition, IF these are executed in more than one line.

Currently the REPL is basically executing an EVAL statement for each line, with not enough information shared between invocations. This will not change in the short run. It might get better when the rakuast branch lands, sometime next year.

you might try using dangerouslySetInnerHtml.

Something like this:

This attribute is named like that with a reason, so be careful about what you send in there, as it might lead to XSS injections.

Learn more about it here: https://reactjs.org/docs/dom-elements.html#dangerouslysetinnerhtml

I took a quick look:

The warning about conversion from 'int' to 'HANDLE' of greater size are probably due to a missing #include , which leads to the compiler assuming that _get_osfhandle() returns int instead of intptr_t. This is potentially a bug (though it might not manifest in practice depending on the range of values windows actually returns from that function).

The warnings about 'FARPROC' differs in parameter lists are due to missing casts from the generic pointer returned by GetProcAddress() to the specific type. However, because all pointer types have compatible representation, nothing bad can happen if ignored.

The warnings about the pragmas can be ignored as well, and could be suppressed with a judicious use of #ifdef __GNUC__.

The warnings about unrecognized character escape sequence are due to not properly escaping backslashes in paths in generated code. Should be fixed, but can be ignored as well.

Regarding zstd, the configuration script uses pkg-config to find the library, so no windows support. Someone should fix that. However, I believe this will only affect the profiler, not regular operation of MoarVM.

I did not investigate the Command line warning stuff, though it looks like something thinks it's compiling on a *nix system and hence passes incorrect flags. Should be fixed, but might not break the build.