Hi,

As someone who has used const very little in my life, I want to learn and ask: What are consts used in function parameters for; isn't there a copy already?

/*
 * Here's we have a class (Foo is partially simple):
 */
class Foo(T) {
  T x; // <----------- Because gonna just an int field!

  this(T n) { x = n; }

  override
  string toString() {
    import std.conv : text;
    return x.text;
  }
}
alias Int = Foo!int; // more simple...

import std.stdio : writeln;
import std.traits: isMutable;

/*
 * Let's simply use and test it!
 */
void main()
{
  auto n = new Int(41);
  auto r = (new Int(1)).inConst(n);/*
  auto r = (new Int(1)).outConst(n);
  assert( r.x == 42 &&
    !isMutable!( typeof(r) )
  );//*/

  n.writeln; // "41": It still has a value of 41.
  r.writeln; // "43": Added an extra 1 as expected!
}


// A, we can get its to guarantee us that parameters
// won't change:

auto inConst(T)(T a, const T b) // const
{ // it's not needed --^     but     ^-- why can't this be used

  a.x += 1; /* suppose it happened accidentally!
  ^-- it's already a new copy, right?//*/

  return new T(a.x + b.x); // Foo!int(43)
}


// B is used to guarantee that the returned result
// doesn't change:

const(T) outConst(T)(T a, T b)
{
  return new T(a.x + b.x);
}

In summary, we can use it in several places (in/out data, body, etc.) in a function. Is const needed if the compiler is copying? So why can't at the beginning of the body also be used and we get this error:

I appreciate the answers given because they hold a very important place in my life, thank you.

SDB@79

On Sunday, 12 March 2023 at 15:09:45 UTC, Salih Dincer wrote:

Const is used for you not be able to change your values inside references. This is why we have const methods for example:

    class Test
    {
        private int a;
        int getA() const {return a;}
    }
    ```

By having this property in your method, it says you're guaranteeing that Test won't be changed when this method is called, then, it'll be less time trying to find what mutated the object, so, use it as much as you can, but never overuse it since it is a pain to deal with.

Const for value types is also used for not mutating them inside the function also leading to less debugging.

Another use case for them is for compiler being able to infer some optimizations. If your variable is `immutable`, it becomes implicitly `__gshared`, which does not uses Thread Local Storage, another good thing for optimization in both memory and access.

On Sunday, 12 March 2023 at 19:09:13 UTC, Ali Çehreli wrote:

In this case, using ref will increase performance while reducing the number of copies. Would it be wise to use const ref to protect the routine from ourselves or someone else? For example:

auto inConst(
  //const
  ref Int a, const ref Int b)
{
  a.x += 1;
  return Int(a.x + b.x);
}

struct Foo(T) {
  T x;
  alias x this;
  this(T n) { x = n; }
}
alias Int = Foo!int;

SDB@79

On Sunday, 12 March 2023 at 15:09:45 UTC, Salih Dincer wrote:

Well you got the great answers to your questions already but I like to add a comment that is that

const parameters without ref are really moot.

I whish at least that they could give the guarantee to be rvalues (i.e have no address) but this is actually not the case. All the D compilers will actually copy const parameters to locals, making them lvalues, unless optimizations are requested(1).

See codegen : https://godbolt.org/z/vev1PGWh3.

This brings the idea that maybe a rvalue storage class could be added to the language.

(1): Actually DMD does not drop the copy at all, even with -O.

On Friday, 17 March 2023 at 22:41:18 UTC, Ali Çehreli wrote:

Let's increase the level one bit...

Again we will remain within the boundaries of -preview=in, but we will learn other hidden information. Because you get interesting results when you raise the issue to function overloading. Here's what happens when you compile the following example:

https://wandbox.org/permlink/XvInUjEtMKOS0CVD

1. I guess none of objects are created copy. Because Apple has already ref and Pineapple didn't execute ctor because of in keyword. Isn't Quince also a const but it was created when it is not a copyible object:

2. If there is no function that takes ref, Apple prefers const. Please just hide the function under the version block. In this case, ctor will run once:

3. If you replace in with scope (function 3) then pineapple and quince will also select different functions:

With this example, it is possible to obtain dozens of results like these. I love D, D is a very powerful language.

SDB@79