Table | Need to display tables | Grid library

It all makes sense and has a simple pattern besides () -> null being a Callable I think. The Runnable is clearly different from the Supplier/Callable as it has no input and output values. The difference between Callable and Supplier is that with the Callable you have to handle exceptions.

The reason that () -> null is a Callable without an exception is the return type of your definition Callable. It requires you to return the reference to some object. The only possible reference to return for Void is null. This means that the lambda () -> null is exactly what your definition demands. It would also work for your Supplier example if you would remove the Callable definition. However, it uses Callable over Supplier as the Callable has the exact type.

Callable is chosen over Supplier as it is more specific (as a comment already suggested). The Java Docs state that it chooses the most specific type if possible:

Type inference is a Java compiler's ability to look at each method invocation and corresponding declaration to determine the type argument (or arguments) that make the invocation applicable. The inference algorithm determines the types of the arguments and, if available, the type that the result is being assigned, or returned. Finally, the inference algorithm tries to find the most specific type that works with all of the arguments.

Option 1: Maybe by using UITableViewCellSeparatorStyleNone with the table view and replacing the system background view of the cell with a custom view which only features a bottom line?

Option 2: Using hint from https://developer.apple.com/forums/thread/684706

I think this gets you pretty close; might just need to adjust the various name columns and drop the extra data (I kept the grouping column).

The main idea is to recursively use pd.json_normalize with pd.concat for all availalable children levels.

EDIT: Put everything into a single function and added section to collapse the name columns like the expected output.

Update the Rust to satisfy the new edition 2021.

rustup default nightly && rustup update

Thanks to @ken. Yes, you can use the stable channel too!

But I love nightly personally.

You can use Keyset Pagination for this. It's far more efficient than using Rowset Pagination (paging by row number).

In Rowset Pagination, all previous rows must be read, before being able to read the next page. Whereas in Keyset Pagination, the server can jump immediately to the correct place in the index, so no extra rows are read that do not need to be.

In this type of pagination, you cannot jump to a specific page number. You jump to a specific key and read from there. For this to perform well, you need to have a unique index on that key, which includes any other columns you need to query.

One big benefit, apart from the obvious efficiency gain, is avoiding the "missing row" problem when paginating, caused by rows being removed from previously read pages. This does not happen when paginating by key, because the key does not change.

Here is an example:

Let us assume you have a table called TableName with an index on Id, and you want to start at the latest Id value and work backwards.

You begin with:

Maybe I'm wrong, but it seems that last part:

There is an update to mini-css-extract-plugin in version 2.5.0. I temporarily fixed it by adding in package.json:

Attention:

Here is an inspiring idea which is not fully satisfy OP's requirement (e.g., ID.new and number order) but I think it worth to be recoreded here.

You can turn DT into long format by melt firstly. Then to shift value with the step -nrow(DT) in order to do the minus operation, i.e. NAME1 - NAME2, NAME2 - NAME3, NAME3 - NAME1.

Take a look at the recursive formula for combinations:

Suppose you have a combination space C(n,k). You can divide that space into two subspaces:

• C(n-1,k-1) all combinations, where the first element of the original set (of length n) is present
• C(n-1, k) where first element is not preset

If you have an index X that corresponds to a combination from C(n,k), you can identify whether the first element of your original set belongs to the subset (which corresponds to X), if you check whether X belongs to either subspace:

• X < C(n-1, k-1) : belongs
• X >= C(n-1, k-1): doesn't belong

Then you can recursively apply the same approach for C(n-1, ...) and so on, until you've found the answer for all n elements of the original set.

Python code to illustrate this approach: