Const Variables

[H. S. Teoh]

On Mon, Apr 04, 2022 at 11:20:31AM -0700, Ali Çehreli via Digitalmars-d-learn wrote:
> On 4/3/22 17:42, H. S. Teoh wrote:
> 
> > In some sense, this is like an extension of ctors initializing
> > immutable values. The compiler tracks whether the variable has been
> > initialized yet, and inside the ctor you can assign to immutable
> > because the uninitialized value is not observable from outside
> > before that. Once assigned, the compiler enforces no subsequent
> > changes.
> 
> These ideas make sense to me.
> 
> I remember reading somewhat similar requests in the past: Assign to a
> variable freely but at some point say "no more mutation to this
> variable".
[...]

It's not just "assign freely"; it's "assign once". Or rather, "assign
before the outside world sees it".

In fact, now that I think of it, I wonder if this could actually be
implementable in the current language. Here's a first stab at it:

	struct LazyValue(T) {
		private class Impl
		{
			immutable T value;
			this(immutable T v) { value = v; }
		}
		private Impl impl;
		private T delegate() pure generate;
	
		this(T delegate() pure _generate)
		{
			generate = _generate;
		}
	
		immutable(T) get() {
			if (impl is null)
				impl = new Impl(generate());
			return impl.value;
		}
		alias get this;
	}
	
	void main() {
		import std;
		auto lazyInt = LazyValue!int({ return 123; });
		writeln(lazyInt.get);
	}

Currently generate() has to be pure, which limits the utility somewhat
(you couldn't load the value from a file, say).  But in principle, the
approach seems to work.


T

-- 
Obviously, some things aren't very obvious.