Provide slightly faster, lower memory use, safe constructors

[oconnor0]

Compile for .NET 10, prefer params ReadOnlySpan when possible, cleanup some method internals, use ref struct to allow creation of the backing collection for an ImmArray/Dict/Set without leaking any values, improves runtime perf slightly and memory pressure a little more, .NET 10 adds allows ref struct to Action so the additional delegate Fill types are not needed in .NET 10, but required before that.

Anyway, we can adjust the APIs however makes sense, but the structure should be solid.

[Benchmark]
public ImmArray<string> Array_ToImmArray() {
	var arr = new string[N];
	for (int i = 0; i < arr.Length; ++i) {
		arr[i] = Guid.NewGuid().ToString();
	}
	return arr.ToImmArray();
}

[Benchmark]
public ImmArray<string> List_ToImmArray() {
	var xs = new List<string>();
	for (int i = 0; i < N; ++i) {
		xs.Add(Guid.NewGuid().ToString());
	}
	return xs.ToImmArray();
}

[Benchmark]
public ImmArray<string> ImmArray_NewSized() {
	return ImmArray.NewSized<string>(N, xs => {
		for (int i = 0; i < xs.Length; ++i) {
			xs[i] = Guid.NewGuid().ToString();
		}
	});
}

[Benchmark]
public ImmSet<string> Set0_ToImmSet() {
	var set = new HashSet<string>();
	for (int i = 0; i < N; ++i) {
		set.Add(Guid.NewGuid().ToString());
	}
	return set.ToImmSet();
}

[Benchmark]
public ImmSet<string> SetN_ToImmSet() {
	var set = new HashSet<string>(N);
	for (int i = 0; i < N; ++i) {
		set.Add(Guid.NewGuid().ToString());
	}
	return set.ToImmSet();
}


[Benchmark]
public ImmSet<string> ImmSet_New0() {
	return ImmSet.New<string>(set => {
		for (int i = 0; i < N; ++i) {
			set.Add(Guid.NewGuid().ToString());
		}
	});
}

[Benchmark]
public ImmSet<string> ImmSet_NewN() {
	return ImmSet.New<string>(N, set => {
		for (int i = 0; i < N; ++i) {
			set.Add(Guid.NewGuid().ToString());
		}
	});
}

[Benchmark]
public ImmDict<string, int> Dict0_ToImmDict() {
	var dict = new Dictionary<string, int>();
	for (int i = 0; i < N; ++i) {
		dict.Add(Guid.NewGuid().ToString(), r.Next());
	}
	return dict.ToImmDict();
}

[Benchmark]
public ImmDict<string, int> DictN_ToImmDict() {
	var dict = new Dictionary<string, int>(N);
	for (int i = 0; i < N; ++i) {
		dict.Add(Guid.NewGuid().ToString(), r.Next());
	}
	return dict.ToImmDict();
}

[Benchmark]
public ImmDict<string, int> ImmDict_New0() {
	return ImmDict.New<string, int>(dict => {
		for (int i = 0; i < N; ++i) {
			dict.Add(Guid.NewGuid().ToString(), r.Next());
		}
	});
}

[Benchmark]
public ImmDict<string, int> ImmDict_NewN() {
	return ImmDict.New<string, int>(N, dict => {
		for (int i = 0; i < N; ++i) {
			dict.Add(Guid.NewGuid().ToString(), r.Next());
		}
	});
}

[oconnor0]

The performance differences between the various runtimes is enlightening:

[isaksky]

Looks compelling. For the naming, it feels like we are trying to disagree with C#'s choice of having new as a keyword. Maybe there is a good reason though, I think we should discuss.

[oconnor0]

ImmArray benchmarks:

ImmSet benchmarks:

I haven't had a chance to write the reflection/compiled tests for ImmSet/Dict. I can do those tommorrow if desired. I can run the ImmDict benchmark tomorrow as well.

It looks like, at least in these benchmarks, .NET 10 is faster than .NET 8. Tho I did see that creating an array/ImmArray of length 0 was slower in .NET 10 than in .NET 8.

It also looks like calling new ImmArray(T[]) allocates more than calling ImmArray.Build when it's done dynamically or via the expression API. It is not obvious to me why that might be.

[oconnor0]

ImmDict benchmark:

[oconnor0]

It turns out that my previous reflection test was using the wrong constructor so made Expression.New look way worse than it is. I've found & fixed that. It now appears there is no significant difference between using the no-copy new or using the Build method.

ImmArray reflection benchmark:

[oconnor0]

ImmSet reflection benchmark:

[oconnor0]

ImmDict reflection benchmark:

[isaksky]

👍