combine | A parser combinator library for Rust | Parser library

A std::map combined with a std::vector gives you all the information you want.

When performing a function call on an object, not only the call operators are considered. There is a special exception if a non-explicit conversion function to a function pointer type (or function reference type) with suitable cvref-qualifiers exists.

In these situations [over.call.object]/2 says that an additional overload is generated, a surrogate call function which takes the converted implicit object pointer as first argument and the function pointer/reference's parameters as further parameters. If this overload is chosen, it will use the conversion function to convert this to the function pointer/reference and then call it with the remaining provided arguments.

std::integral_constant has a non-explicit conversion function to value_type and so if value_type is a function pointer/reference, and only then, will this surrogate call exist, which essentially forwards the object function call to a call to the stored function pointer/reference.

This is an interesting problem. The short answer: Yes, it's possible. But I don't see a way around hard coding the position of table and legend, which is ugly.

The suggestion below requires hard coding in three places. I am using {ggpubr} for the table, and {cowplot} for the stitching.

Another problem arises from the legend key spacing for vertical legends. This is still a rather unresolved issue for other keys than polygons, to my knowledge. The associated GitHub issue is closed The legend spacing is not a problem any more. Ask teunbrand, and he knows the answer.

Some other relevant comments in the code.

We can get the expected result using split like so :

The logic of comparing files seems alright, I don't find any outstanding problem with it, it is ok to prepend the "/" to match what you need. Could be even better if you could use the System.IO.Path.DirectorySeparatorChar for the directory root path as well, so if you run on windows or Linux you will have no issues.

But there may be a conceptual problem with what you are doing. To my understanding you aim to verify existence of specific configuration files required for your program to work right, if those files are missing than the program should fail. But that kind of failure due to missing configuration files, is an expected and valid result of your code. Yet, you unit-test this as if missing files should fail the test, as if missing files are an indication that something wrong with your code, this is wrong.

Missing files are not indication of your code not working correct and Unit-test should not be used as a validator to make sure the files exist prior executing the program, you will likely agree that unit-test is not part of the actual process and it should only aim to test your code and not preconditions, the test should compare an expected result (mock result of your code) vs. actual result and certainly not meant to become part of the code. That unit test looks like a validator that should be in the code.

So unless those files are produced by your specific code (and not the deployment) there is no sense testing that. In such case you need to create a configuration validator code - and your unit test could test that instead. So it will test that the validator expected result with a mock input you provide. But the thing here is that you would know that you only testing the validation logic and not the actual existence of the files.

If you provide the applicative functor to liftA3, then the following typechecks:

dplyr developers recommend rbindlist() for this apparently: https://github.com/tidyverse/dplyr/issues/1162

Given you mentioned Supply.merge, let's start with that. Imagine it wasn't in the Raku standard library, and we had to implement it. What would we have to take care of in order to reach a correct implementation? At least:

1. Produce a Supply result that, when tapped, will...
2. Tap (that is, subscribe to) all of the input supplies.
3. When one of the input supplies emits a value, emit it to our tapper...
4. ...but make sure we follow the serial supply rule, which is that we only emit one message at a time; it's possible that two of our input supplies will emit values at the same time from different threads, so this isn't an automatic property.
5. When all of our supplies have sent their done event, send the done event also.
6. If any of the input supplies we tapped sends a quit event, relay it, and also close the taps of all of the other input supplies.
7. Make very sure we don't have any odd races that will lead to breaking the supply grammar emit* [done|quit].
8. When a tap on the resulting Supply we produce is closed, be sure to close the tap on all (still active) input supplies we tapped.

Good luck!

So how does the standard library do it? Like this:

Try with groupby and agg: