tidies | A Grammar of Data Manipulation for Omics Data | Data Manipulation library

If the std::future is created via std::async, the destructor waits for end of the task. This does not mean that the task does not run in parallel - it just waits for the end of the task at the end of scope of variable. Yet it makes usage of std::async without storing a std::future a bit tricky and I would generally recommend storing the future somewhere to avoid nasty surprises. Take a look at page about std::future destructor (emphasis mine):

these actions will not block for the shared state to become ready, except that it may block if all of the following are true: the shared state was created by a call to std::async, the shared state is not yet ready, and this was the last reference to the shared state.

If we need to do this for each row, an option is c_across after doing rowwise

Both methods seems to be a bad practice in most cases (favorize composition over inheritance). If you can avoid it by using design patterns (facade, composite, adapter,decorator...). If it can't be done in your case the principle of encapsulation and inheritance is what I would apply. So, when necessary chain inheritance.

Assuming you do want to insert a row under every instance of a cell in column B containing "_dup" this should work.

The problem with your code was that it wasn't looping and so only ever found one instance.

It's advisable not to specify a fixed range as you are inserting rows and the range will expand; however, you could do this and set the search direction as "previous".

Note that the parameter of Objects.hash is Object.... This has two main consequences:

• Primitive values used in the hash code calculation have to be boxed, e.g. this.id is converted from long to Long.
• An Object[] has to be created to invoke the method.

The cost of creating of these "unnecessary" objects may add up if hashCode is called frequently.

This seems to be one way: convert the output (a list of stuff) to a tibble of list columns and then unnest.

C came from B which in turn came from a language called BCPL.

A superior statement separator was required for B as the grammar became more complex, and the semicolon was a good candidate. The colon was already in use by then and the period used as a decimal separator.

After that, with the introduction of C, the semicolon became the standard.

Trying to form my own answer based on some research. I think the approximate order of severity is; mostlyclean, clean, maintainer-clean, mrproper, distclean and finally clobber (which is combined distclean and uninstall).

make clean

make clean is the most basic level. It cleans up most generated files but not anything that records configuration. GNU Make Manual's Goals page states:

Delete all files that are normally created by running make.

Further, the GNU Make Manual's Standard Targets page stages:

Delete all files in the current directory that are normally created by building the program. Also delete files in other directories if they are created by this makefile. However, don’t delete the files that record the configuration. Also preserve files that could be made by building, but normally aren’t because the distribution comes with them. There is no need to delete parent directories that were created with ‘mkdir -p’, since they could have existed anyway.

Delete .dvi files here if they are not part of the distribution.

make mostlyclean

make mostlyclean is the only gentler form of clean I have found, it behaves like clean but leaves behind files that would take a long time to compile and do not often need to be regenerated.

The GNU Make Manual's Standard Targets page stages:

Like ‘clean’, but may refrain from deleting a few files that people normally don’t want to recompile. For example, the ‘mostlyclean’ target for GCC does not delete libgcc.a, because recompiling it is rarely necessary and takes a lot of time.

make distclean

make distclean is the first step up from the basic make clean on many GNU Make systems. It seems to be pseudonymous or at least very similar to with make realclean and make clobber in many, but not all cases. It will delete everything that make clean does and remove the configuration.

In the Linux system this is one step beyond make mrpropper, see the section below for details.

I am not sure if the name implies that things are being made clean enough for distribution (the forming of a tar archive) or that the process is returning them to the state equal to what was distributed (just as things were immediately after unpacking a tar archive).

GNU Make Manual's Goals page states:

Any of these targets might be defined to delete more files than ‘clean’ does. For example, this would delete configuration files or links that you would normally create as preparation for compilation, even if the makefile itself cannot create these files.

Further, the GNU Make Manual's Standard Targets page stages:

Delete all files in the current directory (or created by this makefile) that are created by configuring or building the program. If you have unpacked the source and built the program without creating any other files, ‘make distclean’ should leave only the files that were in the distribution. However, there is no need to delete parent directories that were created with ‘mkdir -p’, since they could have existed anyway.

make uninstall

make uninstall will uninstall software installed via make install or one of the install-* variants. This is similar to part of the behaviour to make clobber on some systems but make uninstall should not touch the build area as make clobber will.

The GNU Make Manual's Standard Targets page stages:

Delete all the installed files—the copies that the ‘install’ and ‘install-*’ targets create.

This rule should not modify the directories where compilation is done, only the directories where files are installed.

make maintainer-clean

make maintainer-clean seems to be one step back from the more common make distclean. It deletes almost everything apart from the configuration. This makes it very similar to make clean.

The GNU Make Manual's Standard Targets page stages:

Delete almost everything that can be reconstructed with this Makefile. This typically includes everything deleted by distclean, plus more: C source files produced by Bison, tags tables, Info files, and so on.

It is also highlighted that this is not a commonly used target as it is for a specific set of users:

The ‘maintainer-clean’ target is intended to be used by a maintainer of the package, not by ordinary users.

make mrproper

make mrproper seems to be a Linux Kernel version of make distclean or make clobber. that stops short of removing backup and patch files. It does everything that the make clean target does and strips out configuration.

I believe the name comes from a cleaning product known in the USA as Mr. Clean and the UK as Flash (which is why I had not heard of the product as named). Linus Torvalds being Finnish-American was presumably familiar with the Mr. Propper brand name.

The Linux Kernel Makefile states:

If you are willing to use a metaclass then yes, it is possible: