hop | routing helpers for single page applications | Router library

The documentation says the type should implement ToOwned. The following works:

Instead of prev() or next(), use .prevAll(":has(p[contenteditable])").first() and .nextAll(":has(p[contenteditable])").first():

You can try to use LEAD window function.

Transparent proxies don’t exist.

As far as the HTTP RFC is concerned, there is simply no such thing. The specification does not recognise the concept. A client (A) may connect to a server (C) to fetch or modify a resource, or it may connect to a proxy (B) to have the latter do so on its behalf. In the former case, the hop-by-hop headers regulate the connection between the client and the server; in the latter, they regulate the connection between the client and the proxy. If the proxy connects to the server to serve the request, it has to manage its own hop-by-hop headers for the proxy–server link.

Anything else you add beyond that is simply not a party to the protocol and its presence should not influence how it operates. Whether (A)’s connection to either (B) or (C) (or (B)’s connection to (C)) is mediated by something else is immaterial. All that matters is that when (A) chooses to send a request to (B), it should receive the same resource that it would if it chose to make a request to (C) directly. (B) or (C) don’t even have to be single hosts; they may themselves pass requests though any number of intermediary layers.

For all it matters, the ‘transparent proxy’ may as well be a SOCKS proxy, in which case it will not modify any HTTP headers at all, because it cannot even be sure whether what it forwards is HTTP in the first place.

To solve your specific issue, you can generate dummy variables to run your desired clustering.

One way to do it is using the dummy_columns() function from the fastDummies package.

The problem here is that you need a properly defined type if you to want to access these members publicly.

For private properties, the syntax val foo = object { ... } is sufficient, but for publicly exposed properties these are inferred as Any and it makes them unusable.

One option is obviously to define an interface for these types, but it's even more boilerplate than what you came up with already, so I am pretty sure this won't suit your needs:

No, there's not a way - not even if one were willing to write a module that depends on unsupported Rakudo internals.

State variables are currently handled all the way down in the runtime (typically, MoarVM), where they are attached to a bytecode handle. Cloning a Block in turn clones the underlying bytecode handle, which explicitly does not clone the state variables.

Usually it's not recommended to have a proxy before Cassandra - the TokenAware load balancing policy will work just out of box (if you're using prepared statements). Besides the selecting correct replicas, it will take into account the status of the node, etc.

The problem with proxy is that after the first contact, the driver will receive the list of the all nodes in the cluster, so driver will try to use these nodes anyway, not the proxy node (until you're using whitelist code load balancing policy, or you implemented the address translation functionality).

Somehow, answering the questions parts in the opposite order felt more natural to me. :-)

Second, does auto-flattening allow any behavior that would be impossible if the left hand side were non-flattening?

It's relatively common to want to assign the first (or first few) items of a list into scalars and have the rest placed into an array. List assignment descending into iterables on the left is what makes this work: