expressive | A simple and small boilerplate for NodeJS with Express | Runtime Evironment library

Is there a algorithm in STL that will sweep two (equally sized) ranges and call a function for each pair of entries?

std::equal() and std::transform() seem to follow this notion, but they are not that expressive when the intention is to, say, calculate the sum of difference squares of two vectors:

The official documentation recommands to use the same receiver name everywhere. But does it really make sense to comply with that?

I mean, I imagine something like func (first Foo) concat(second Foo) (combinded Foo) to be more expressive, while first does only make sense in that very context of concatenation. If we don't go that route, we're basically forced to resort to some agnostic but useless receiver naming like f, wasting an opportuniy for self-documenting code.

_{This is probably an AB mistake on my part.}

While reading my dataset usually some files are NOT a part of it. I want to be robust against that - to just ignore them, simply log the omission.

But I am in love with exceptions thus Spectrum read_csv( const fs:path & dataset ); throws.

I want to keep it that way because the .pdf and other files my supervisor has embedded into the data structure should stay there.

The following implementation seems elegant. But fails at the first wrong file. A try/catch alternative works. But is not as expressive. Can this work somehow while read_csv() throws; those exceptions to be at most logged?

Intro:

Some of you may have noticed that something has broken in relation to the querySelectorAll method of MSHTML.HTMLDocument from MSHTML.Dll (via a Microsoft HTML Document Library reference). This, I believe, has happened in the last month. It may not affect all users and I will update this Q&A as I get more info on which versions etc are affected. Please feel free to comment below with your set-up and whether working or not for both late-bound and early-bound (as per code in answer)

Accessing DispStaticNodeList methods:

Traditionally, at least in my experience, it has been the norm to hold a reference to the DispStaticNodeList, which is what querySelectorAll returns, in a generic late-bound Object type:

E.g.

Is there a quick and expressive way to make a copy of an existing object and pass it into r-value reference? I've an existing API that takes r-value references as parameter. But I can't change it due to backwards compatibility nor I can overload it because of the shear amount of overloads it have already. For example, foo is my existing API.:

I was plotting a scatter plot to show null values in dataframe. As you can see the plt.scatter() function is not expressive enough. Relation between list(range(0,1200)) and 'a' is not clear unless you see the previous lines. Can the plt.scatter(x,y) be written in a more explicit way where it could be easily understood how x and y is related. Like if somebody only see the plt.scatter(x,y) , they would understand what it is about.

I have an array of objects whose interfaces all extend a base interface.

I want to map these objects onto a React component which will route to specialised components for each of the supported child interfaces -- but first, I want to map over the array and extend each object with an onClick handler, whose signature is a generic which I want to specialise to suit whichever child interface it's being mapped onto.

I've come up with a solution that looks as though it should work, but I can't shake this TS error: Type 'AWithClick' is not assignable to type 'IntrinsicAttributes. I see plenty of references in SO and elsewhere to TS errors related to that interface, but none quite seems to apply here.

I checked my solution against this helpful article, and I think the main difference in my implementation is that I'm trying to extend items from the union with specialised onClicks, rather than defining the specialised onClicks in the individual interfaces in the original union. The array of objects comes from a store, and I'm basically mapping its entities to component props, so I want to keep component props interfaces separate from the store interfaces.

npx create-react-app repro --template typescript

Replace App.tsx with the following:

I've been getting into Automata theory, compilers and the fundamentals of CS, but there is something fundamental that I don't understand.

I have seen the Chomsky Hierarchy of languages where different classes of languages that have different expressive power are "associated" with an equivalently powerful automaton.

From Wikipedia :

GRAMMAR LANGUAGE AUTOMATON

• Type-0 Recursively enumerable Turing machine
• Type-1 Context-sensitive Linear-bounded non-deterministic Turing machine-
• Type-2 Context-free Non-deterministic pushdown automaton
• Type-3 Regular Finite state automaton

I've seen that every programming language are Turing Complete and that the grammar specifications of programming languages (formalised in BNF, etc..) can be expressed as a Context-free Grammar.

Context-free grammars dont have an "associated" Turing Machine as equivalent.

During interpretation / compilation, the string of the source code of a program written in a programming language (like C, python, etc..) is parsed/translated into an Abstract Syntax Tree.

(As I understand, this is like extracting an array from a string when matching the string against a regular expression, except that the pattern here is not a regular expression, it is a context-free grammar, which is more powerful, hence the tree structure extracted which contain more information that a linear array (coming from capture groups of a regex).)

So the program written, potentially implementing a Turing Machine, is converted into an Abstract Syntax Tree, and all the information contained into the original program is now incorporated into the tree. And later, during execution, the program will accompished some computation that can be as complex as a Turing Machine.

My question is : How can a string expressed within the confines of the rules dictated by what a Context-free Grammar can be, be implementing a Turing Machine while the equivalence grammar/language/automata and the Chomsky Hierarchy say a Context-free Grammar isn't expressive enough to do so ?

Is one of my assumptions wrong ? Or is the fact that memory plays a role in this, and that there is a theorem that says something like : a Turing Machine can be implemented "using" a Tree + a Stack ?

This is really bugging me.

Anything that can enlighten me is really appreciated !

EDIT :

Here's a DUPLICATE of my question :

chomsky hierarchy and programming languages

Why I mistakenly thought that the syntax specification of a programming language defines its semantics ?

Because of what YACC does : (syntax-directed translation)

https://en.wikipedia.org/wiki/Syntax-directed_translation

which associates the rules of the context-free grammar used to parse the programming language (which is used to make the abstract syntax tree) with an action. This is the source of my confusion.

For example, here's a copy paste of an extract of the source code of the perl5 interpreter. This is the file perly.y which is used to by yacc to make the first pass of compilation.