closure | Serialize closures

In Rust (as in e.g. C++) every closure has its own anonymous type.

Since c2 is a local, the compiler knows exactly what its concete type is, and thus can know all its traits, including that it's Send (because it closes over nothing that's !Send... since it's not closing over anything).

However c1 is returned as dyn Fn, meaning as far as the compiler is concerned the only trait it can rely on is Fn. The compiler only has local visibility, and that's what you're telling it to rely on.

The way to make it sendable is to assert and guarantee that it is:

Go to android/app/build.gradle and change the minSdkVersion and targetSdkVersion to integer values.

When performing a function call on an object, not only the call operators are considered. There is a special exception if a non-explicit conversion function to a function pointer type (or function reference type) with suitable cvref-qualifiers exists.

In these situations [over.call.object]/2 says that an additional overload is generated, a surrogate call function which takes the converted implicit object pointer as first argument and the function pointer/reference's parameters as further parameters. If this overload is chosen, it will use the conversion function to convert this to the function pointer/reference and then call it with the remaining provided arguments.

std::integral_constant has a non-explicit conversion function to value_type and so if value_type is a function pointer/reference, and only then, will this surrogate call exist, which essentially forwards the object function call to a call to the stored function pointer/reference.

In the context you ask about you can think that closure is a function that references to some variables that are defined in its outer scope (for other cases see the answer by @phipsgabler). Here is a minimal example:

The bug has been fixed and the example now compiles.

It's not a feature of lambda and more is a feature of implicit type conversion.

What happens there is stemming from the fact that a captureless lambda can be implicitly converted to a pointer to function with same signature as lambda's operator(). +[]{} is an expression where unary + is a no-op , so the only legal result of expression is a pointer to function.

In result auto funcPtr would be a pointer to a function, not an instance of an object with anonymous type returned by lambda expression. Not much of advantage in provided code, but it can be important in type-agnostic code, e.g. where some kind of decltype expression is used. E.g.

Not with a dput(), no. The dput() function will not create text representations of environments.

If you want to save the function, you could do

If I understand correctly, returning an impl would result in slower code, calling function pointers instead of compiling things down to simple loops. Right?

Nope. Returning impl Iterator is exactly the same, codegen-wise, as returning Map<...>>>.¹ The difference is twofold:

• Changing the return type of neighbours does not require changing its signature, so impl Iterator is forward-compatible with changes to its return type.
• impl Iterator won't unify with other opaque impl Iterator types, even if they happen to have the same underlying type. (In simple terms: the compiler won't allow you to make a Vec of impl Iterators from different sources, even if all those opaque types are the same concrete type.)

Neither of these differences has any influence on code generation or the compiler's ability to inline anything, so go ahead and use impl Iterator.

There is one case where you must still use indirect dispatch (dyn Iterator): when the function neighbours is itself part of a trait, the impl Trait syntax is not yet available (as of 1.59). The best way to solve this at the moment is to return Box. (Note, however, that doesn't mean every call will be dynamically dispatched; the call to .next() will be, but everything "inside" that still uses easily-optimized static dispatch.)

• What is the correct way to return an Iterator (or any other trait)?
• How do I return an instance of a trait from a method?
• https://stackoverflow.com/a/39490692/3650362 (when the method is part of a trait)

¹ Note that in order to actually return Map<...>>>, you would still have to use impl Trait to represent the closures, since they have anonymous types.

To achieve this, we need to implement a recursive function to remove all empty string in all nested arrays and objects.