equivalence | implementing object equality | Dataset library

I have tried out many ideas from SO. One of them worked (output was DEC 49 for HEX 31) when I tested it in here onlinegdb. But, when I implemented it in my application, it didn't produce same results. (output was 31 for 31 again).

The idea is to use a string value (full of HEX pairs); An example; 313030311b5b324a1b5b324a534f495f303032371b

I need to convert each integer pair (HEX) into equivalence decimal value. e.g.

I have been working on an algorithm (Dafny cannot prove function-method equivalence, with High-Order-Polymorphic Recursive vs Linear Iterative) to count the number of subsequences of a sequence that hold a property P. For instance, how many subsequences hold that 'the number of positives on its left part are more that on its right part'.

But this was just to offer some context.

The important function is this CountAux function below. Given a proposition P (like, x is positive), a sequ sequence of sequences, an index i to move through the sequences, and an upper bound j:

I'm implementing a VBScript dialect and want to equally support VBScript Eqv (logical equivalence) and Imp (logical implication).

When Eqv/Imp have number operands, they perform a bitwise comparison. While I may able to simulate their behavior bit-by-bit, there must be a more efficient way than that. For example, I can do Eqv from JavaScript like this, given two integers x and y:

C++20 introduced ranges::elements_view, which accepts a view of tuple-like values, and issues a view with a value-type of the Nth element of the adapted view's value-type, where N is the non-type template parameter.

In [range.elements.view], the synopsis of ranges::elements_view is defined as:

new Map([[1, [2, 3]] ].map(e => e[1])); is perfectly valid javascript. But typescript gives the following error:

I want to sort my Github Repos by Clones in Typescript
The equivalence in plain js would be

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.

I understand that many of the names in Haskell are inspired by category theory terminology, and I'm trying to understand exactly where the analogy begins and ends.

I already know that Hask is not (necessarily) a category due to some technical details about strictness/laziness and seq, but let's put that aside for now. For clarity,

• The objects of Hask are concrete types, that is, types of kind *. This includes function types like Int -> [Char], but not anything that requires a type parameter like Maybe :: * -> *. However, the concrete type Maybe Int :: * belongs to Hask. Type constructors / polymorphic functions are more like natural transformations (or other more general maps from Hask to itself), rather than morphisms.
• The morphisms of Hask are Haskell functions. For two concrete types A and B, the hom-set Hom(A,B) is the set of functions with signature A -> B.
• Function composition is given by f . g. If we are worried about strictness, we might redefine composition to be strict or be careful about defining equivalence classes of functions.

I don't think the technicalities above have anything to do with my confusion below. I think I understand it means to say that every instance of Functor is an endofunctor in the category Hask. Namely, if we have

I have an inductive type Env that is a snoclist with multiple cons constructors