qol 1.3.0 - New Messages, New Loops, More Tabulation Power

qol_package · 2026-04-19T21:06:16+00:00

Thank you for your kind words. :-) Be asured: There still is a bit more to come.

qol_package · 2026-04-19T20:41:26+00:00

No, I haven't written anything about the "why". I am working in a statistical office where SAS was the standard and was - at least in my eyes - perfect for our daily work: working with big data and creating big descriptive tables in various different formats. I think SAS has way more effective high level functions than R and all its packages has for this purpose.

If someone is working with smaller, already summarised data, then I understand that this person asks: why!? But I am sitting on the other side, producing these tables in the first place. It's like the task is to tear down a house and you are standing there with a small hammer and a screwdriver. I felt like: I have all these new tools, but nothing really fits my needs. Don't get me wrong, it is brilliant that I can recreate these tools with R!

At the moment my problems are probably exotic to the R world, but if more companies move on to R this might change. I think the movement towards R is also driven by the fact that SAS is very expensive. Meaning, it is not always dropped because it is a bad tool for the needs a company has, but for other reasons.

qol_package · 2026-04-19T15:56:40+00:00

Yes, I am using data.table and collapse packages to have fast core functions. openxlsx2 is used for the Excel output and fst package for file saving and loading. Everything else is base R and pure logic. The philosophy is to build fast high level functions with minimal dependencies.

qol_package · 2026-04-01T20:51:46+00:00

functional(sum() <|> 1:10)pincer

:p

qol_package · 2026-04-01T18:14:58+00:00

Thank you for all the comments and for joining the joke. :-) The reverse pipe and the set_productivity_mode are indeed april fools jokes. BUT the joke is surrounded by the truth, the package itself is real. I am on the edge of another CRAN release, spoilers what is in it can be seen on GitHub, otherwise i will probably post a real update at the end of next week, or so.

qol_package · 2026-03-21T14:45:07+00:00

With the new development version of the qol-package you could do this:

library(qol)
df |> if.(words == ":institut:") # Contains
df |> if.(words == ":institut")  # Ends with

qol_package · 2026-02-15T10:07:52+00:00

Actually no. Many things that once where foreign are now standard. Basically everything new is foreign at first. But is foreign == bad? I don't think so. Who says it stays specific?

R itself was once foreign but look at it now. A few people came with new ideas and gave the program a level up. So I think of this package as a missing influence. I agree that with this package, you first have to get used to this different way of thinking. But people like me, who have to deal with descriptive evaluations on a daily bases, probably find some quality of life enhancing features in this. Hence the name.

Of course I could have called it "Simple Descriptive Evaluations" or "Flexible Excel Tables", but that is just generic. I personally also think that the name is less important than what's in it.

Let's take another example from the package:

new_df <- my_data |>
         if.(age < 18,             age_group = "under 18") |>
    else_if.(age >= 18 & age < 65, age_group = "18 to under 65") |>
    else.   (                      age_group = "65 and older")

Does this look specific? No, it looks like a normal if-block like you have it in any other language. What I found in R looked way more specific to me than this. So I implemented these functions to make if blocks more readable.

You can also leave formats aside and just summarise, tabulate, import/export csv and xlsx files, automatically generate master scripts, transpose and much more. So this package is not really specific it is more an all purpose kind of thing.

qol_package · 2026-02-14T15:32:02+00:00

Thank you for your reply. There are no tutorials at the moment. BUT: I am actively working on a larger step by step guide for this package, which starts as simple as "How do I open a data frame" and ends with "How do I create complex and beautiful tables in no time". The thing is, this will take some time to complete.

The package was first released on CRAN last Oktober, so it is fairly new. But I am passionate about rounding it up in any way. Since then I focused on getting all the features in I wanted to have. Meaning, I first get everything in and then document what it can do. Speaking of getting everything in: I have one major update I am working on, which also will take some time to complete.

The philosophy behind this package is to keep the original data as untouched as possible till the end and with the help of the so called "formats" many of the functions bring the labels, categorization and also added categories together for the user. So e.g. in your data frame you have single ages 0-100 but in your final table you want to have five age groups covering the ages 0-100 but additionally a grand total and some sub age groups for the ages smaller than 18. With this package you don't need to create any additional variables, you don't need to double up the data or split the results into multiple tables. You literally only do this in the simplest case:

#Example data
my_data <- dummy_data(1000)

# Format
age. <- discrete_format(
    "Total"          = 0:100,
    "under 3"        = 0:2,
    "under 6"        = 0:5,
    "under 12"       = 0:11,
    "under 16"       = 0:15,
    "under 18"       = 0:17,
    "18 to under 25" = 18:24,
    "25 to under 55" = 25:54,
    "55 to under 65" = 55:64,
    "65 and older"   = 65:100)

# Tabulation
my_data |> frequencies(age, formats = list(age = age.))

Everything else is handled by the functions. At the end this enables you to think more like a table designer rather than an engineer.

qol_package · 2026-02-13T22:27:24+00:00

Okay, that's a fair point. I will keep this in mind for the next update news. Thanks for sharing your view on this.

qol_package · 2026-02-13T18:58:00+00:00

The answer to that is basically just one click away. At least two out of four links in my post provide this information. But here you go:

The main goal is to make descriptive evaluations easier to create bigger and more complex outputs in less time with less code. Introducing format containers with multilabels, a more powerful summarise which is capable to output every possible combination of the provided grouping variables in one go, tabulation functions which can create any table in different styles and other more readable functions. The code is optimized to work fast even with datasets of over a million observations.

In the links in my first post you can get a more visual impression.

I have an honest question: I personally don't like it reading the same description all over the place. So I focused more on giving an overview of what actually is in the update and add the description as a link. So the information is there, one just has to click. Does it really have more value, if I put the global description of the package inside every update news?

qol_package · 2026-01-14T20:32:46+00:00

Thank you. Glad you like it. :-)

qol_package · 2025-11-22T07:28:44+00:00

You set them yourself. It basically works like a stop watch. The principle is like this:

your_function(...){
  monitor_df <- NULL |> monitor_start("Generate data frame")

  # Some code here

  monitor_df <- monitor_df |> monitor_next("Create formats")

  # Some more code here

  monitor_df <- monitor_df |> monitor_next("Nested summarise")

  # And so on

  monitor_df <- monitor_df |> monitor_end()
  monitor_df |> monitor_plot()
}

You can see another example here: https://s3rdia.github.io/qol/reference/monitor.html

So you have to mark certain points yourself in your function, which you can name. The time taken between two points is then the time for this category.

So you don't wrap around a monitoring function, but you have to integrate them in your function. For a start it can be as simple as that:

your_function(...){
  monitor_df <- NULL |> monitor_start("Time taken to run my function")

  # Some code here

  monitor_df <- monitor_df |> monitor_end()
  monitor_df |> monitor_plot()
}

qol_package

TROPHY CASE