tcr | Get going with 'test & & commit revert ' in seconds | Runtime Evironment library

The name/result fields are:
in an object that is
in an array that is
embedded in an object that is
embedded in another object that is
in an array that is
embedded in the document.

Thats a lot of layers to peel.

So to get to the name/result pairs:

• unwind array in the document
• convert the embedded objects to arrays
• unwind the converted arrays
• reach into the last document and unwind the deep array

Then to combine them

• group by the name part, push all the pass/fail results into an array
• reduce over the constructed array to determine the overall pass/fail value
• group by the key (K1, K2, etc) and push the name/result into an array
• group by null (i.e. no group making a single document) push they keys into a results array
• reconstruct the document structure

Through all of those steps, maintain the global fields like Name and Time.

That might look like:

Assuimng you have that values in a list named _list, here's what you could do:

To get you going in the right direction at least, here are some high level ideas:

1. When the radio button gets toggled, there are two possible ways you can leverage that to apply a style: a. events like click and change are fired that you can respond to with your JavaScript. b. The :checked CSS pseudo-class selector applies to the element if it's toggled on

2. either by adding/removing an attribute (usually a class attribute like 'active-cell') on the event, or leveraging the native pseudo-class, you'll need to add the styles to represent a border. (Here's a breakdown of why I say 'represent' a border: Applying borders to a single table cell when using border-collapse - it's not quite as simple as adding a css border property.)

Usually toggling a class is going to dramatically simplify your HTML and CSS because you can do a bit of DOM traversal to select a parent element of the input to apply the class and it's styles to.

Using the pseudo class is nifty in that it doesn't require JavaScript, but since CSS doesn't have a 'parent' selector, and you want to style the cell containing the input you have to get creative with your selectors...that would likely be done by having the element right after the input be selected, (or maybe a :before pseduo element) and adding some positioning and other styling to make it look like a border. for example:

This looks like a call optimization — sometimes called tail call optimization, which is useful in reducing the stack depth on recursion — but also useful in the general case.

The way this optimization works, a caller, A, calls a function, B, which calls another function, C.  If B was going to return directly to A after calling C, then B can jump to C instead!  Being none the wiser, C returns to its caller, which appears to be A.  By doing this, B doesn't need a stack frame and doesn't have to save the link register — it simply passes its return address on to C.

This optimization skips the otherwise normal return of C to B, making C return directly to A. This transformation is only enabled (i.e. correct) under certain circumstances:

• If there is no work for B to do upon C's return, B can setup C to return directly to A.
• From a logical perspective (e.g. in C or pseudo code), this means that either:
  • B and C are both void functions, or,
  • B ignores C's return value, or,
  • B returns C's return value to A, unmodified.
• B also cannot cleanup a stack frame after C's return, since C returns directly to A; if B has a stack frame, it would have to be released before calling C.  (And also see @PeterCordes comment below.)

From a hardware perspective, when the optimization is used (it is coded in B and then B is invoked), it is as if B & C were merged:  Function A calls "BC" if you will.  Dynamically, there is one bl (A->BC) and one ret (BC->A) — nicely balanced, which is good for the hardware branch predictor's call-stack handling.

We cannot express the tail call optimization in most high level languages, as most have only "call subroutine" and do not have a "jump to subroutine" feature.  So, at best, we can write code that does no work upon return as per the above, and let the language/compiler perform the optimization, if it knows the optimization.

In A calls B calls C, B & C are functions, but A may or may not be a function (it could just some assembly code — while it is a caller of B, A itself doesn't need to be invoked or invokable as a function.  While the call chain can be deep, the first code at the very top a call chain is not a function (e.g. it is _start or sometimes main) and has no where to return to (so doesn't use ret to exit; it doesn't have a return address parameter provided by a caller).  (If code has a place to return, i.e. a return address to use, then by definition it is not the top of the call chain (it is nominally a function).)

This initial code can play the role of A but not of B or C in the pattern.  Tail call is precluded for A's call to B when A is not a function because there is no caller of A for B to return to.  This is why the pattern must be A calls B calls C, B & C must be functions, and we consider applying the optimization to B.  If A is a function, it must have a caller, so then can play the role of the middle function in the pattern (as can C, e.g. if C calls D).

You problem is that you did not escape the | so it was interpreted as alternative (same as "or") and your full match would not include the second hexa. You just need to escape it to match it literally:

Take out all .w-100 on the tables and the selects, and set those selects' width as fit-content. You can create a custom class for that:

You don't need to go down the ggplot_build route. The function ggcompetingrisks returns a ggplot object, which itself contains the aesthetic mappings. You can overwrite these with aes:

Your calls to filter() do not have a data.frame object matched to their .data formal argument.

When you "pipe into" a function call by using the magrittr pipe infix operator %>%, the pipe constructs a new function call that is based on the function call on the RHS of the pipe (i.e, the rhs formal argument to the pipe). The pipe either implicitly or explicitly supplies the value of the LHS expression (the lhs argument) as an argument to one of the RHS function's formal operators, depending on whether the symbol . is supplied by the user as a whole argument to the rhs function call. It will also substitute lhs for any occurrence of the symbol . within user supplied arguments to the rhs call.

The value of .data in any dplyr verb that has been piped to (i.e., that is the rhs argument to the pipe function,) will be matched to the value of the lhs formal argument to the pipe function, long as the value of .data is not otherwise specified by the user by providing it as a named argument.) Your function calls to filter() occur within the arguments to mutate(). They are not the rhs argument to the function call %>%, they just occur within the rhs argument to %>%. The pipe will NOT recursively construct new function calls from function calls that are supplied as arguments to the function that the pipe is modifying. The pipe is not going to try to supply the LHS object to them as an argument unless you explicitly provide it by specifying that the value of .data should be the symbol ., either positionally or by name.

adjusted = (filter(treatment!="MOCK")$value)-(filter(treatment=="MOCK")$value) is an argument that you are providing to the mutate() function, which is the rhs argument to the pipe function. The enclosing pipe function will substitute the value of . anywhere that . occurs in the arguments to the function call that constitutes the rhs argument but it will not otherwise modify the arguments. That means the pipe will NOT try to implicitly supply the value of the lhs argument as an argument to the calls to filter() that occur within this argument.

You are getting an error about logical values because e.g. your call to filter(treatment!="MOCK") is evaluated as filter(.data = treatment!="MOCK"), not as filter(.data = ., treatment != "MOCK"). There is only one argument supplied to filter so it gets positionally matched to the first formal argument, which is .data. treatment!="MOCK" evalutes to a logical value, so you get your error, because there is no S3 method filter.logical. You would need to express it as filter(., treatment!="MOCK") in order for these function calls to be able access the data.frame object being piped in.

In any case, using dplyr verbs in arguments to other dplyr verbs will almost always yield code that is extremely hard to reason about. There's a reason you never see this performed in the dplyr vignettes. This kind of operation also can't be performed against a dbplyr SQL backend.

You should consider performing a join instead. I don't have full insight into the structure of your data but it seems like there are only one MOCK record per group? if so something like this is safe:

You only need set once, with the columns separated by commas: