Article: Why Const Sucks
Atila Neves
atila.neves at gmail.com
Mon Mar 5 14:49:27 UTC 2018
On Monday, 5 March 2018 at 13:49:43 UTC, Jonathan M Davis wrote:
> On Monday, March 05, 2018 11:38:05 Atila Neves via
> Digitalmars-d-announce wrote:
>> I used to use `immutable`, but gradually came around to only
>> using it if I have to send data to another thread, otherwise
>> it's too much of a hassle.
>
> Aside from the whole std.concurrency situation, I generally use
> immutable in the places where the semantics are the same as
> const, so it doesn't generally cause a problem for me. I just
> prefer immutable in the cases where it and const are the same,
> because immutable clearly indicates that the value never
> changes, so immutable more closely fits the idea even if const
> happens to mean that in that particular case. I agree that
> using immutable where you have to do stuff like design objects
> in a particular way in order to make immutable work is
> generally too much of a pain to be worth it, but at least in
> those cases, the data can then be shared across threads, and
> it's data that doesn't need mutable backdoors, because it only
> makes sense to use immutable in that fashion when the object is
> really designed to never change state.
>
> I think that the only time that I've programmed heavily in a
> way that involves immutability everywhere is when I programmed
> in Haskell, and that combined with the fact that Haskell is
> lazy and completely functional such that you can't use
> imperative idioms anywhere made it so that each line of Haskell
> code took me more time to write than is the case with any other
> language I've used (except maybe batch, because of how insanely
> error-prone it is). I think that I'm a better programmer for
> it, but I'd hate to program that way normally, and using
> immutable all over the place would head too heavily in that
> direction - though at least D, unlike Haskell, is a
> multi-paradigm language and allows you to choose to use a
> particular idiom when you think it makes the most sense instead
> of forcing it everywhere.
>
> - Jonathan M Davis
I prefer const over immutable because this compiles:
string[] arr;
const _ = arr;
While this does not:
string[] arr;
immutable _ = arr;
Basically, const just works and immutable is a hassle unless
threads are involved. There are other situations where immutable
is needed / should be preferred as well, notably:
struct Foo {
const(ubyte)[] bytes;
}
Construct Foo from a mutable buffer that you're reusing to get
network traffic and you're going to have a bad time.
Atila
More information about the Digitalmars-d-announce
mailing list