destruct | ES6 style object destructuring in Ruby | Script Programming library

EDIT: Disclaimer - I don't mean deletion in the sense that applies to languages that aren't memory-managed (e.g. free in C++). Deletion here is to be understood as the fact that the superclass doesn't have the subclass as one of its subclasses anymore after its been deleted.

In Python, you can delete a class (yes I do mean a class, not an instance) by doing the following:

I'm a c++ beginner and now reading the C++ Primer. I have some problem about the destrucor:

1. in chapter 13.1.3: "In a destructor, there is nothing akin to the constructor initializer list to control how members are destroyed; the destruction part is implicit. What happens when a member is destroyed depends on the type of the member. Members of class type are destroyed by running the member’s own destructor. The built-in types do not have destructors, so nothing is done to destroy members of built-in type."

   So if I have such a class:

My application consists of calling dozens of functions millions of times. In each of those functions, one or a few temporary std::vector containers of POD (plain old data) types are initialized, used, and then destructed. By profiling my code, I find the allocations and deallocations lead to a huge overhead.

A lazy solution is to rewrite all the functions as functors containing those temporary buffer containers as class members. However this would blow up the memory consumption as the functions are many and the buffer sizes are not trivial.

A better way is to analyze the code, gather all the buffers, premeditate how to maximally reuse them, and feed a minimal set of shared buffer containers to the functions as arguments. But this can be too much work.

I want to solve this problem once for all my future development during which temporary POD buffers become necessary, without having to have much premeditation. My idea is to implement a container port, and take the reference to it as an argument for every function that may need temporary buffers. Inside those functions, one should be able to fetch containers of any POD type from the port, and the port should also auto-recall the containers before the functions return.

I have the following definitions for type precision:

Related: How does =delete on destructor prevent stack allocation?

First, I realize this sort of thing is playing with fire, tempting UB. I'm asking to get a better understanding of corner-cases of unions.

As I understand it, if I have a class with a c'tor and d'tor and put it in a union, the compiler will force me to tell it what to do about construction and destruction. As in

I try to create custom hook to validate my inputs. But if custom hook returns an object, it re-creates on every change on the page

I am trying to get to grips with the specifics of the (C++20) standards requirements for container classes with a view to writing some container classes that are compatible with the standard library. To begin looking into this matter I have looked up the references for named requirements, specifically around container requirements, and have only found one general container requirement called Container given by the standard. Reading this requirement has given my two queries that I am unsure about and would like some clarification on:

1. The requirement for the expression a == b for two container type C has as precondition on the element type T that it is equality comparable. However, noted later on the same page under the header 'other requirements' is the explicitly requirement that T be always equality comparable. Thus, on my reading the precondition for the aforementioned requirement is redundant and need not be given. Am I correct in this thinking, or is there something else at play here that I should take into account?

2. I was surprised to see explicit requirements on T at all: notably the equality comparable requirement above and the named requirement destructible. Does this mean it is undefined behaviour to ever construct standard containers of types failing these requirements, or only to perform certain standard library function calls on them?

Apologies if these two questions sound asinine, I am currently trying to transition my C++ knowledge from a place of having a basic understanding of how to use features to a robust understanding so that I may write good generic code. Whilst I am trying to use (a draft of) the standard to look up behaviour where possible, its verbiage is oft too verbose for me to completely understand what is actually being said.

In an attempt to seek the answer I cooked up a a quick test .cpp file to try an compile, given below. All uncommented code compiles with MSVC compiler set to C++20. All commented code will not compile, and visa versa all uncommented code will. It seems that what one naively thinks should work does In particular:

• We cannot construct any object without a destructor, though the objects type is valid and can be used for other things (for example as a template parameter!)
• We cannot create an object of vector, where T has no destructor, even if we don't attempt to create any objects T. Presumably because creating the destructor for vector tries to access a destructor for T.
• We can create an object of type vector, T where T has no operator ==, so long as we do not try to use operator ==, which would require T to have operator ==.

However, just because my compiler lets me make an object of vector where T is not equality-comparable does not mean I have achieved standards compliant behaviour/ all of our behaviour is not undefined - which is what I want I concerned about, especially as at least some of the usual requirements on the container object have been violated.

Code:

I am trying to encode a small lambda calculus with algebraic datatypes in Scheme. I want it to use lazy evaluation, for which I tried to use the primitives delay and force. However, this has a large negative impact on the performance of evaluation: the execution time on a small test case goes up by a factor of 20x.

While I did not expect laziness to speed up this particular test case, I did not expect a huge slowdown either. My question is thus: What is causing this huge overhead with lazy evaluation, and how can I avoid this problem while still getting lazy evaluation? I would already be happy to get within 2x the execution time of the strict version, but faster is of course always better.

Below are the strict and lazy versions of the test case I used. The test deals with natural numbers in unary notation: it constructs a sequence of 2^24 sucs followed by a zero and then destructs the result again. The lazy version was constructed from the strict version by adding delay and force in appropriate places, and adding let-bindings to avoid forcing an argument more than once. (I also tried a version where zero and suc were strict but other functions were lazy, but this was even slower than the fully lazy version so I omitted it here.)

I compiled both programs using compile-file in Chez Scheme 9.5 and executed the resulting .so files with petite --program. Execution time (user only) for the strict version was 0.578s, while the lazy version takes 11,891s, which is almost exactly 20x slower.

In vanilla Coq, I'd write