expressions | include lambda expressions | Reflection library

You can not turn arbitrary classes into hidden classes.

The documentation of defineHiddenClass contains the sentence

• On any attempt to resolve the entry in the run-time constant pool indicated by this_class, the symbolic reference is considered to be resolved to C and resolution always succeeds immediately.

What it doesn’t spell out explicitly is that this is the only place where a type resolution ever ends up at the hidden class.

But it has been said unambiguously in bug report JDK-8222730:

For a hidden class, its specified hidden name should only be accessible through the hidden class's 'this_class' constant pool entry.

The class should not be accessible by specifying its original name in, for example, a method or field signature even within the hidden class.

Which we can check. Even a simple case like

I suspect this may have been an accident, though I prefer the new behavior.

The new behavior is a consequence of a change to how the bytecode for * arguments works. The change is in the changelog under Python 3.9.0 alpha 3:

bpo-39320: Replace four complex bytecodes for building sequences with three simpler ones.

The following four bytecodes have been removed:

• BUILD_LIST_UNPACK
• BUILD_TUPLE_UNPACK
• BUILD_SET_UNPACK
• BUILD_TUPLE_UNPACK_WITH_CALL

The following three bytecodes have been added:

• LIST_TO_TUPLE
• LIST_EXTEND
• SET_UPDATE

On Python 3.8, the bytecode for f(*a, a.pop()) looks like this:

In C++11 and newer you can use template parameter packs to create a recursive implementation, like this:

It's as you said: It can't be done at the moment as Github Actions doesn't support expressions with uses attributes.

There is no workaround (yet?) because the workflow interpreter (that also checks the workflow syntax when you push the workflow to the repository) can't get the value from the expression at that moment.

It could maybe work if the workflow was recognized by the interpreter, but it doesn't event appear on the Actions tab as it's considered invalid.

For the moment, you can only use tag, branch ref or commit hash after the @ symbol, the same way you use any action.

Note that someone else had the same issue here

For your first point, the relaxed value restriction is triggered as soon as any computation happens in any sub-expression. Thus neither

Here is the C++20 solution I came up with:

The problem here is related to inlining. I do not understand it completly, but here is what I understand.

First we find that copy&pasting the definition of replicateM into the Submission 1 yields the same bad performance as Submission 2 (submission). However if we replace the INLINABLE pragma of replicateM with a NOINLINE pragma things work again (submission).

The INLINABLE pragma on replicateM is different from an INLINE pragma, the latter leading to more inlining than the former. Specifically here if we define replicateM in the same file Haskells heuristic for inlining decides to inline, but with replicateM from base it decides against inlining in this case even in the presence of the INLINABLE pragma.

sequenceA and traverse on the other hand both have INLINE pragmas leading to inlining. Taking a hint from the above experiment we can define a non-inlinable sequenceA and indead this makes Solution 2 work (submission).

You could update the pattern to:

Open your terminal and type this command --> gedit .bashrc

Ensure that you are added the native after lib as shown below