I still don’t understand why parameters can be silently changed in function calls and why there is not a const or mutable like keyword to warn us if this is happening? Running this example will silently change the content of the vector w/o knowing that. a = [1, 2] f(v) = v[2] = 3 f(a) I found tha…

But Julia functions don’t know anything about parameters or variables. They just see the values passed to them, and those values are either mutable or immutable. So the only avenue is to change the mutability state of the value. So if you want foo(const a::MyType) = ... foo(a::MyType) = ... that w…

[image] DNF: But Julia functions don’t know anything about parameters or variables. Julia is like many other languages, the parameters that you pass have a type and that type is used to specialise various implementations of a function. Julia is like C++ at compile time. [image] running thi…

[image] Dan_Micsa: the parameters that you pass have a type But that’s the thing: they don’t. The parameters have no type, only the values do. That’s the main difference between static and dynamic typing. I increasingly get the impression that this is a root of the confusion here: Variables d…

Indeed they don’t but 100% of the time variables that you declare have a type. You should learn a bit at least about the types in Julia before writing. They are very cool. [image]

That’s not the type of the variable a, it is the type of the value that a refers to. I have been using Julia since 2014, or so, so I would appreciate it if you take a slightly less condescending tone (I have seen this through the entire thread, btw, not just now.)

At any given moment in time a declared variable has a type. If it has a type or reffers too is the same thing. Maybe you want to say that sometimes is a reference to a storage that store a type is correct too. But for simple types is NOT so! Simple types are passed by value so is not a “reffers to” …

No. This is (at least one of) the main difference between static and dynamic languages: that in static languages the variables have types, in dynamic ones they do not. This is apparently a deep (but understandable) confusion that you hold, due to having primarily experience with static typing. Until…

I haven’t read this long thread, but I do agree that C++ does const a lot better than Julia’s mutable struct vs struct. const also transitively applying to the fields of a struct and to pointers is great. It’s silly that MArray and SArray should be two separate types in Julia IMO. Rust does it eve…

[image] DNF: No. This is (at least one of) the main difference between static and dynamic languages I think you are a bit confused by the “dynamic” buzzed word. With this powerful exprimation C is a “dynamic” language because has void*, macros and unions exactly how C++ is a “dynamic” languag…

[image] Elrod: Rust does it even better. From this call site, can you guess which is a mutable borrow, which is immutable, and which is passed by value (which gives ownership in Rust, invalidating it in this scope): foo(&mut x, &y, z) Yes this is what I like more in Rust vs C++ too. Everythi…

Why I can't set what parameters are mutable explicitly?

Offtopic

lmiq August 23, 2022, 12:02pm 166

Can we revive this comment? I think the path possible to Julia is more or less non-controversial, though not easy:

Topic		Replies	Views
Make function paramaters immutable by default Internals & Design proposal	31	4824	May 10, 2017
[ANN] MutableArgumentContracts.jl (experimental, not yet registered) Package Announcements package , announcement	23	972	February 1, 2024
Explicit denotation of variability and immutability Internals & Design proposal	97	9454	November 5, 2018
! notation for individual modified variables Internals & Design proposal	39	3603	April 11, 2019
Why is bang(!) indicating argument mutation a convention, but not enforced? Internals & Design	15	2672	November 18, 2020

Why I can't set what parameters are mutable explicitly?

Related topics