boo | Android Experiment that uses face detection

You could use list comprehension with np.split + np.flatnonzero:

Yes, the code is safe. Flows are sequential by default.

Each individual collection of a flow is performed sequentially unless special operators that operate on multiple flows are used. The collection works directly in the coroutine that calls a terminal operator (collect). No new coroutines are launched by default. Each emitted value is processed by all the intermediate operators from upstream to downstream and is then delivered to the terminal operator after.

Kotlin Flows are based on suspending functions and they are completely sequential, but not single-threaded.

Therefore it seems kotlin flow ensures publication between coroutine invocations but is this intentional (or even documented) or implementation side effect?

Here it says:

a flow is a type that can emit multiple values sequentially

According to this I understand that no new value will be collected until previous value is processed, no matter how much Threads are involved.

As Roman mention in his comment, here is a good article about sequential execution. A great quote from there:

Even though a coroutine in Kotlin can execute on multiple threads it is just like a thread from a standpoint of mutable state. No two actions in the same coroutine can be concurrent. And just like with threads you should avoid sharing your mutable state between coroutines or you’ll have to worry about synchronization yourself. Avoid sharing mutable state. Confine each mutable object to either a single thread or to a single coroutine and sleep well.

And this is applicable to Flows, because collection of Flow works directly in the coroutine that calls a terminal operator. No new coroutines are launched by default.

The key difference is indeed that methods are methods on generic functions. They are not methods on classes.

This may sound like words for words' sake. But it should highly influence your naming choices. "Action" is a pretty bland name for a generic function. When foo acts, what does it actually do? When bar acts, what does it actually do?

If action truly is the best name, would having a foo:action and a bar:action make sense (that is, an action in the foo package, and one in the bar package)? They are different GF's. With, of course, the drawback that it is no longer as easy as just calling action on them.

And that hints towards "you don't need a method, you can just use a function", because you don't need a method to do things with classes in CL.

Don't bind your code to the enum bind your code to an interface. Then have your enum provide the standard implementations of the interface.

Can v->cntr, in the controlling expression, be considered as a synchronization

No.

From https://port70.net/~nsz/c/c11/n1570.html#5.1.2.4p5 :

The library defines a number of atomic operations (7.17) and operations on mutexes (7.26.4) that are specially identified as synchronization operations.

So basically, functions from stdatomic.h and mtx_* from thread.h are synchronization operations.

since v may be a pointer to a global structure which can be modified externally (for example by another thread)?

Does not matter. Assumptions like sound to me like they would disallow many sane optimizations, I wouldn't want my compiler to assume that.

If v were modified in another thread, then it would be unsequenced, that would just result in undefined behavior https://port70.net/~nsz/c/c11/n1570.html#5.1.2.4p25 .

Is the compiler allowed not to re-read v->cntr on each iteration if v is not defined as volatile?

Yes.

tl;dr: This is how. c# doesn't need to be aware of the async and it should work.

I just made a little test using

Assets/Plugins/mylib.jslib

when you want to get correct username based on false flag you doesnt init a value to user. you should write something like this with bob.nextLine :

The & syntax does not mean "the address of" or "pointer to" like in C. In Swift, it is an in-out expression.

These can be used to create implicit pointer conversions as a convenience, and that can seem like C's "pointer to" meaning, but it has very different rules and behaviors. For example, there is no promise that obj even has an address. It may be a tagged pointer. Passing it via an in-out expression may allocate memory and copy the value to make the call possible. Similarly, when passing a "pointer to an array," Swift will actually pass a pointer to a contiguous block of values (which may have been copied to make them contiguous) which is not the same as the actual Array struct.

It is not meaningful to say var pointer = &obj. There is no in-out reference there.

There is no general way to take long-lived pointers to objects in Swift without allocating your own memory (and this is rare). The memory model doesn't promise the kinds of lifetimes you'd need to make that sensible. If your code did compile the way you expect it to, the call to foo(pointer) would still be invalid because there's no promise that obj exists at that point and the pointer could be dangling. (There are no references to obj after the first line, so Swift can and often will destroy it, even though it's still "in scope.")

The foo(&obj) syntax is basically a shorthand for: