Hacker News Reader

Comment by kccqzy | Hacker News Reader

Deep copy is pedagogically and semantically the right choice for any mutable containers. You either make containers immutable or copies deep. Otherwise it's just an invitation for subtle bugs.

View on HN

I'm not sure about that - every time I copy an object I have to think through what happens, no matter the default semantics. C++ makes the deep copy case easier than other programming languages without top-level built-in support.

No, it should move properly when passing by value (as in, essentially the rust move semantics). If you want a copy, that should be explicit.

Moving by default would be too much of a footgun without a borrow checker imo.

I think using a language without a borrow checker is already a massive footgun (albeit less of one for GC/RC languages). More sensible move semantics would still be a big ergonomic improvement.

I think the language allowing use-after-move is honestly a smaller footgun than allowing using uninitialized memory or use-after-free. C++ already has the latter.

Then explain that const isn’t deep and a const container can end up mutating state? Pretending like c++ has a consistent philosophy is amusing and pretending this happened because of pedagogy is amusing. It happened because in c assignment is a copy and c++ inherited this regardless of how dumb it is as a default for containers.

In C++ regular types have the property that const is deep. If you have a const std::vector<int> the you can't modify any of the integers contained in this container. Naturally for flexibility reasons not all types are regular, pointers being the prominent exception, and things like std::string_view being modern examples of non-regular types.

I feel like you could benefit from watching Scott Meyers about the silliness in C++ if you feel like there’s a consistent and logical feel to the language. A lot of this is c++-isms masquerading sensible ideas through official terms (regular and non-regular types)

Oh I certainly do not feel like there's consistency in the language. The C++ language is such that everyone picks a subset that makes sense to them and is relatively consistent.

Regular and non-regular types are however a basic idea that transcends languages. I can write a snippet in Python too:

    import copy
    from some.random.module.on.pypi import foo
    a = foo()
    b = copy.copy(a)
    assert a == b

If that assertion fails it implies the type isn't regular.

Can you point me to terminology other than the c++ spec (preferably literature) that defines regular types? I can only find references to this concept in c++ land.

I think this terminology was originally invented by Stepanov. And he used C++ to explain the concept. That's why you can only find references to this concept in C++ land.

https://stepanovpapers.com/DeSt98.pdf is probably the original paper. Others have over time refined and redefined the idea of a regular type.

It certainly makes things easier. But it also makes some things very, very, very inefficient. I want a list with millions/billions of elements. I want to regularly change one of the elements somewhere in the middle. Good luck with the copying.

Why would you copy a whole list to modify a single element?

A very good question indeed. But maybe you should read the post I am responding to.....

Reply on news.ycombinator.com