[markasoftware]

Their example of why Ada has better strong typing than Rust is that you can have floats for miles and floats for kilometers and not get them mixed up. News flash, Rust has newtype structs, and you can also do basically the same thing in C++.

I don't know much about Ada. Is its type system any better than Rust's?

[forthac]

This was posted to about a day ago: https://github.com/johnperry-math/AoC2023/blob/master/More_D...

But a noteworthy excerpt: ```

Ada programs tend to define types of the problem to be solved. The compiler then adapts the low-level type to match what is requested. Rust programs tend to rely on low-level types.

That may not be clear, so two examples may help:

    Ada programmers prefer to specify integer types in terms of the ranges of values they may take and/or the precision of floating-point types in terms of digits. I ended up doing this at least once, where on Day 23 I specified a floating-point type in terms of the number of digits it should reproduce accurately: Digits 18. The compiler automatically chose the most appropriate machine type for that.

    Ada arrays don't have to start from 0, nor even do they have to be indexed by integers. An example of this appears below.

By contrast, the Rust programs I've seen tend to specify types in terms of low-level, machine types. Thus, I tried to address the same problem using an f64. In this particular case, there were repercussions, but usually that works fine as long as you know what the machine types can do. You can index Rust types with non-integers, but it takes quite a bit more work than Ada.

```

[Pet_Ant]

> By contrast, the Rust programs I've seen tend to specify types in terms of low-level, machine types.

This seems to be an artifact of the domain that Rust is currently being used in. I don't think it's anathema to Rust to evolve to be able to add some of these features. char indexed arrays are something I've used a lot (most via `char c - 'a'`\, but native support for it would be nice).

[bestouff]

You can use TiVec to index with something other than usize. https://crates.io/crates/typed-index-collections

[sgsjchs]

You very rarely would actually want scalar types which don't map directly to hardware supported ones anyway.

[TheRealKing]

Ada's mechanism is what Fortran has been using and doing for decades.

[bitwize]

You can actually do this in C as well. The Windows API has all sorts of handle types that were originally all one type: HANDLE; but by wrapping a HANDLE in various one-member structs were able to derive different handle types that couldn't be intermixed with each other in a type-safe way without some casting jiggery-pokery.

It's just much, much easier and more ergonomic in Ada.

[pjmlp]

Fun fact, that many are not aware, mostly because this is Windows 3.x knowledge and one needed the right source to learn about this.

There was a header only library on the Windows SDK that would wrap those HANDLEs into more specific types, that would still be compatible, while providing a more high level API to use them from C.

Unfortunely there is not much left on the Internet about it, but this article provides some insight,

https://www.codeguru.com/windows/using-message-crackers-in-t...

Naturally it was saner just to use TP/C++ alongside OWL, C++ with MFC back then, or VB.

[citbl]

Yes and no, you need to look deeper into Ada to find that it can have compile time guarantees higher than what you can get from a struct named km and miles.

[wolvesechoes]

There is no elegant solution in Rust to make something like

  type Temperature_K is digits 6 range 0 .. <whatever is reasonable upper bound in your domain>;

[bluGill]

at least that is an unsigned (though there are no usigned hardware floats). If you said tempemerature C there you range starts at -273.15 and you want errors of some sort to happen if you go below that.

[dlahoda]

newtypes are not as good as native low level types. after typing a lot of code, one will find out that he needs nightly to get decent integration to avoid casting to low level and back all time.

[112233]

I'm super interested how you can do this in C++. Say, I need aggregate struct with a few 16 and 32 bit fields, some are little endian and some big endian. I do not want C++ to let me mix up endianness. How do I do it?

[platinumrad]

C: struct be32_t { uint32_t _ }; struct le32_t { uint32_t _ };

C++: That, but with a billion operator overloads and conversion operators so they feel just like native integers.

[graealex]

There's several libraries, including some supporting units and mathematical operations yielding the correct result types.

And as usual, it mostly comes with zero overhead, beyond optional runtime range checking and unit conversions.

But C++ is a meta-programming language. Making up your own types with full operator overloading and implicit and explicit conversions is rather easy.

And the ADA feature of automatically selecting a suitable type under the hood isn't actually that useful, since computers don't really handle that many basic types on a hardware level. (And just to be clear, C++ templates can do the same either way)

[boxed]

Aside from technical factors, there are social factors involved. For example, both Python and C++ has operator overloading. But in C++ that's horrible and you run screaming from it, while in Python land it's perfectly fine. What is the difference? Culture and taste.

[HelloNurse]

It isn't the same operator overloading.

In C++ operator overloading can easily mess with fundamental mechanisms, often intentionally; in Python it is usually no more dangerous than defining regular functions and usually employed purposefully for types that form nice algebraic structures.

[quotemstr]

> Culture and taste.

You mean accumulated prejudices, myths, and superstitions that most in any given community (programming language related or not) won't challenge for fear of being cast out of the group for heresy.