risky | A lightweight Ruby ORM for Riak | Functional Programming library

You are sending a string object that indeed doesn't have a subs property
Use eval(expr).subs(.....) to convert the string to the math expression.
However eval() is a risky stuff to use as it will execute pretty much anything. So be sure to properly secure the user input or you could get you system destroyed by malicious user input. See this answer for a detailed explanation.

I think best practice usually comes down to what style suits you best. I don't particularly think there's a noticeable performance difference between these two methods, but perhaps someone can do some simple benchmarking for us.

In a very subjective answer to your question, I personally prefer with-statements. It indicates that you're executing code with a resource that will dispose itself once completed. This is also usually how you execute built-in contexts like when opening a file, etc.

One more added benefit is that you don't need to define a method to run in the with-statement.

However, you can save yourself some effort by using contextlib to generate your context:

Any await I used along the way could cause the awaited function to execute in a different thread

To clarify, await doesn't cause code to run on a different thread. However, when the code resumes executing after the await, it will run on a "context", which may be the thread pool context, in which case it will continue running on a potentially different thread.

so I must ensure all functions are side effect free or access ressources synchronized.

The purpose of await is to free up the calling thread so it can do other things. If those "other things" are accessing the same objects, then yes, you will need synchronization.

As you adopt async, you'll find it is more natural to return results instead of causing side effects. Asynchronous code in general (including async code) gently pushes you towards a functional programming style.

So suddenly each member variable of any class must be synchronized. Static variables are suddenly a no-go... Passing reference types to functions becomes risky. In essence you have to double check and think about each variable in your code.

No, this does not necessarily follow.

An async method may change threads during its execution, but await inserts proper thread synchronization barriers so that you don't have to think about it at that level. All variable access works the same way as synchronous code.

I must use something like SemaphoreSlim, which is not re-entrance able.

IMO that's a feature.

Per the JNA API, the final modifier will make a field read-only with the exception of JNA's read() method to populate that structure from native memory.

Structure fields may additionally have the following modifiers:

final JNA will overwrite the field via read(), but otherwise the field is not modifiable from Java. Take care when using this option, since the compiler will usually assume all accesses to the field (for a given Structure instance) have the same value. This modifier is invalid to use on J2ME.

The caution regards whether the field can change value; it can if the underlying memory changes and it is re-read. In theory, a user could use this to bypass the read-only nature by:

• Calling the structure's getPointer() value
• Directly writing to native memory at the appropriate offset
• Calling the structure's read() method.

Is this immutable? Probably not, but it's no different than the existing non-modular limitations where reflective access can bypass the final modifier. It should at least prevent "accidentally" modifying the value, which I think is the intent of immutability.

One possible thought with very little overhead would be subclassing Structure with something like an ImmutableStructure where you override read(); initially it allows reading values into final fields but then you can change a boolean before returning it to the user, turning read() into a no-op. This still allows reflective access (like any Java class) but adds a further step preventing unintentional modification.

If you don't want to go that route and want a true defensive copy, you somewhat have to give up the convenience of the Structure API and go low-level and deal directly with the array/buffer of bytes that are returned from native methods. You can do things similar to the Structure class by calculating field orders, getting offsets of fields (even caching them in a map for later use), and directly reading the byte values at offsets you care about with read-only getters.

Field-by-field copy (or reading from native) via reflection happens under the hood in the Structure's pointer constructor, so creating a defensive copy could be as simple as reading a byte array of the structure's size, creating a new Memory object and writing those bytes to it, and passing the pointer to that Memory to the new copy's constructor to use via super(p). There are probably more efficient ways to do that.

You might also consider simply serializing the object and deserializing it into a new object.

Conda re-solves when removing. When installing, Conda first attempts a frozen solve, which amounts to keeping all installed packages fixed and just searching for a version of the requested package(s) that are compatible. In this specific case, xlrd (v2.1.0) is a noarch with only a python>=3.6 constraint. So this installs in this frozen solve pass.

The constraint xlrd will also be added to the explicit specifications.¹

When removing, Conda will first remove the constraint, and then re-solves the environment with the new set of explicit specifications. It is in this solve that Conda identifies that newer versions of packages and then proposes updating then.

So, the asymmetry is that the frozen solve explicitly avoids checking for any new packages, but the removal will trigger such a check. There is not currently a way to avoid this without bypassing dependency checking.

Actually, mamba, a compiled (fast!) drop-in replacement for conda, will remove only the specified package if it doesn't have anything depending on it. That is its default behavior in my testing.

I replicated your experience by first creating an environment with two specs:

If you are creating namespace while doing deployment or before then can use following option. Using this you can use runAsUser : 1001121001 (or any other user) define the yaml file

Project parameter "Multibyte character set" defines, how generic text mappings are expanded. For example, SetWindowText is defined as SetWindowTextA in multibyte project, and SetWindowTextW in Unicode project. This doesn't prevent you to use Unicode function in Multibyte project, by specifying its full name, like SetWindowTextW.

Example. MFC project, Multibyte.

Unfortunately, it's not supported to configure Identity Protection policies programmatically with Microsoft Graph API.

Currently Microsoft Graph only supports querying these policies.

See details from identityProtectionRoot resource type (V1.0) and Use the Azure AD identity protection API (Beta).

A similar post here for your reference.

Despite your request, I guess that a lot is opinion based; nonetheless, here is my take.

It really depends on the use case. Even your question might hide ambiguity; here I see two different tasks:

1. find (the position of) the first element of a list that obeys a condition
2. find (the position of) the first TRUE value inside a logical vector.

Of course, the second task solves also the first, but with the cost of applying the predicate for each element of the list.

A lot has to do with vectorization in R: for many tasks, even if "algorithmically" wrong, it's more convenient to evaluate the predicate for each element of the list and then find the TRUE position. This is certainly the case of your examples: there is no doubt that, given how isFour and the other are defined that match is to prefer: we don't mind to check each element of data since the operation is very fast, even if one could stop before the end to get the answer. This because, if we "devectorize" your function, on average we are going to slow things a lot since subsetting and checking a single element is way slower. Consider that here I'm using list not in the R-meaning (list object), but just as a collection of values.

On the other hand, Position is thought to be used when your data is list and/or the f function is not vectorized and very expensive. Imagine for instance that f consists in training a machine learning model, evaluate it against some data and grabbing some performance statistics. We have a list of algorithms we want to train and we want to stop when we reach a nice performance. In this case, we don't want to train every possible model in the list (super expensive), but stop as soon as we can. So, we are going to use Position (see also its source code to understand why).

Regarding the two tasks that I outlined at the beginning, all your solutions deal with the second task, while only Position solve exactly only the first.

So, in general:

• if the predicate is vectorized and efficient, go with match;
• if the predicate is very expensive, go with Position.

Don't see much of a reason to use the other two solutions in any case: which and which.max are used mainly for other tasks and not to determine the position of a TRUE value (even if they can, of course).

Just to outline better the differences between the match solution and the Position one, here is a recap.

• For match the isFour function is applied to each element of the input and only after match actually acts. Of course, for the specific task of the example a better way is match(4, data), since match will stop internally as soon as a 4 is found. But the important point is that isFour is applied to the whole input in your implementation.
• For Position instead, you pass the function, not the result of its application. Then, the function is applied element by element and when the condition is met it exits, without necessarily processing the whole input.

Now it should be clear what's to prefer: it depends on the cost of "devectorize" the function against the gain of not processing the whole input.