lexical | Lexicon Learning for Few-Shot Neural Sequence Modeling | Machine Learning library

Answer from Richard Smith:

This is an error in the standard wording. See http://www.open-std.org/jtc1/sc22/wg21/docs/cwg_active.html#1436 for details and a proposed fix -- though that fix is known to be wrong too (it permits lambda-expressions).

The code of lexer_lexbuf_to_supplier is as follows:

A decidedly non-authoritative answer. Curiously, like jnthn in your prior Q, it feels natural to answer your questions in reverse order:

Is there any way to tell Raku "don't rebind this name to a new value, no-really-I-mean-it"?

As far as I can tell so far -- purely by testing variations, not by checking roast or the compiler source -- you can and must declare a sigil free symbol, and it must not be one declared with my \symbol ...:

That's not how it works with class. The construction parts of it would be close to correct with the old function-based setup, but class works slightly differently in this regard.

When you do new C, the object isn't created until the A constructor is called. Here's what happens:

1. new calls C's [[Construct]] internal method with new.target set to C.
   1. Any code in C prior to super() runs. this is inaccessible at this point.
   2. C's code calls B's [[Construct]] (via super()) with new.target still set to C.
      1. Any code in B prior to super() runs. this is still in accessible.
      2. B calls A's [[Construct]] (via super()) with new.target still set to C.
         1. Since A is the base constructor, A's [[Construct]] creates the object, setting its prototype from the prototype property of new.target (which is C).
         2. Any code in the A constructor runs, and has access to this.
      3. Any code in B after super() runs (and has access to this).
   3. Any code in C after super() runs (and has access to this).
2. The object created by A is the result of the new expression.

(I'm skipping over some minor details above for clarity.)

This is how the class construct ensures that the new object is initialized in order from the base constructor (A) to the first derived constructor (B) and the finally the new target (C). That way, A has access to the new object first, followed by B, followed by C.

More in in the specification link above.

After investigating a little deeper I came up with my own conclusion that I'd like to share with all interrested CFML developers. If any experienced OOP CFML developer has more precise information, I'd be really glad to know.

I've created a component named Cube.cfc that may answer the question for itself. My conclusion basically is that "pseudo constructors" allow to create some kind of "static" functions, because these fucntions can make use of these variables without instantiation of an object. Note that I didn't want to use the term "static" because these functions lacks of the naming attribute "static" (as far as I'm aware, only Lucee supports real "static" functions at the moment). Also, the example I'm showing only seems to work with createObject() and not the implicit constructors e.g. new Component(), because new Component() would instantiate the object immediately. But: using createObject and the pseudo constructor will at least allow to mimic static functions. Please note that my example component is just to be descriptive.

In the following example im using available functions that won't need any object instantiation. These functions can be used to retrieve some usefull informations that are not bound to any created/instantiated object.

Cube.cfc: a simple component to create cube objects

With possible comments (/* ... */) that need be omitted:

Note: When referring to documentation and source code, I provide links to an unofficial GitHub mirror of R's official Subversion repository. The links are bound to commit 97b6424 in the GitHub repo, which maps to revision 81461 in the Subversion repo (the latest at the time of this edit).

substitute is a "special" whose arguments are not evaluated (doc).

Your code is different from the policy example. Your code assigns a value to $bicycle outside the loop, whereas the policy example does not.

The following is code that more closely represents the intention of the policy example:

first: No the article does not says it allows initializer in catch statement.

It says to refer to the function specification for

• type-specifier-seq
• declarator
• abstract-declarator

or the initializer is a different element.

Second:

An initializer in a catch statement is pointless since a value is required for actualy going into a catch statement. which means that the initializer value would never be used, and it would jeopardize the program flow since the initalization could raise an exception that will at best terminate.

MSVC probably tolerate it out of pointlessness since it cannot affect the program