It seems to me that you can get the same thing in C++ with classes <> modules ; templated classes <> functors. What am I missing?
For example, let us say you have a module satisfying this signature:
module M : sig
type sorted
val import : int array -> sorted
end = struct
type sorted = int array
let import = Array.sort
end
The c++ version of your example would be, if I understood your code correctly, to take an std::vector as an constructor parameter, copy it to an private field and sort it.
However, you say that it is "not something people do" ... well maybe not in C++ (I highly doubt that), but it's very common in many languages. In C, it's common to look inside structs directly and change things. Javascript libraries do it all the time: They inspect their arguments, look at the types and change their behavior depending on it. It's a common programming practice to poke deep into the data-structures and do things. In Java, they made it an art with reflection and monstrosity such as Spring.
Abstraction is a bit like immutability: Sure, you can try to fake it in languages that don't have it, but then you are just praying that everyone plays by your rules. :)
I admit that I kinda pushed you into it, but you are moving the goal post. People indeed use public fields in languages like C and Javascript.
In C it's often done for the sake of performance. Hiding data behind a pointer has a cost.
In Javascript I would say it's lazyness above all. Front end programs often aren't that big nor pinacles of code quality.
But it is possible to define abstract data types in both languages. ML makes it a bit easier and some times even more performant, but it doesn't "own" the idea.
Abstractions are quite like immutability. You can enforce both in many languages, some just give you better tools for it.
You say that, even when the language doesn't enforce it, people don't break it ..... except when they do. It doesn't really matter why, it simply makes every thing else more brittle as a consequence and limits how you can reason about your code.
You seem to trust that programmers will play by the rules, even if the compiler doesn't enforce them. We will simply have to agree to disagree. :)
I've been trying to say the exact oppisite. C, C++, Javascript, all those languages provide ways to define abstract datatypes that cannot be circumvented (by "normal" code. Even Haskell has unsafePerformeIO). My latest argument was that people decide not to use those abstractions not because they are unavailable, but because it is more ergonomical or performant not to. The same happens even in ML, not all data is abstracted as an abstract data type.
Could you expand on this? I'm pretty sure the OCaml compiler isn't sophisticated enough to make guarantees like this - i.e. I could pass in a function that satisfies the interface constraints, but doesn't actually do any sorting.
class M
{
// This is private
std::vector<int> _sorted;
public:
// This is your "import"
M(const std::vector<int>& v) : _sorted(v) {
std::sort(_sorted.begin(), _sorted.end());
}
// Add other ADT operations that preserve the invariant
}
struct M
{
// Everything private; but as M is "friend" it can access all members
class Sorted {
friend M;
std::vector<int> value;
}
static Sorted import(std::vector<int> v) {
std::sort(v.begin(), v.end());
return Sorted{v};
}
}
auto s = M::import(std::vector<int>{4, 3, 2, 1});
++s.value[0]; // ERROR: value is private
As a side note: the argument, I can do X with Y so why use Z is somewhat misleading, when Y and Z are both Turing complete ;).