How to have strongly typed numerical values?

[anonymous]

On Wednesday, 5 September 2012 at 00:55:12 UTC, Nicholas Londey 
wrote:
> Hello.
> I am trying to work out if there is existing support for 
> strongly typed numerical values for example degrees west and 
> kilograms such that they cannot be accidentally mixed in an 
> expression. I have vague recollection of seeing a presentation 
> by Walter talking about this but I cannot seem to find it. I 
> have looked at std.typecons.Typedef and Proxy but neither seem 
> to do what I want or at least fail to compile for the 
> expression n =  n + n;. I could easily implement my own as I 
> have done in C++ in the past but assume there is a standard 
> implementation which I would prefer.
> Any help or links to examples much appreciated.
>
> Regards,
>
> Nicholas

I don't know about any standard (or wide-spread) solution. I did 
my own and it works well for me.
Code follows, no rights reserved:

module quantity;

/// Examples:
unittest {
	mixin BasicUnit!"ampere";
	mixin BasicUnit!"second";
	
	// multiplication of different quantity types yields a new type
	auto coulomb = ampere * second;
	static assert(!is(typeof(coulomb) == typeof(ampere)));
	static assert(!is(typeof(coulomb) == typeof(second)));
	static assert(is(typeof(coulomb / second) == typeof(ampere)));
	real dimensionless = second / second;
	
	// quantities of the same type can be added, quantities can be 
multiplied
	// with dimensionless values
	assert(coulomb + coulomb == coulomb * 2);
	
	// can't add different types
	static assert(!__traits(compiles, ampere + second));
	static assert(!__traits(compiles, ampere + coulomb));
	static assert(!__traits(compiles, ampere + 1));
}

import std.traits: isIntegral;
import std.typetuple;

debug import std.stdio;

/** Mixin to define a basic unit with the given name.
	
	Params:
		name = must be a valid identifier
*/
mixin template BasicUnit(string name, Value = real) {
	struct Id {}
	enum q = Quantity!(UnitSpec!(Id, 1), Value)(make!Value(1));
	mixin("
		static if(is(typeof(" ~ name ~ "))) {
			static assert(false);
				//TODO: better error message
		} else {
			alias q " ~ name ~ ";
		}
	");
}
/// Examples:
unittest {
	mixin BasicUnit!"ampere";
	static assert(isQuantity!(typeof(ampere)));
}

/** A physical quantity, i.e. a numerical value and a unit of 
measurement.
	
	Do not instantiate Quantity directly. Use BasicUnit instead.
*/
private struct Quantity(UnitSpec, Value) {
	Value value; /// the (dimensionless) numerical value of the 
quantity
	
	static assert(isUnitSpec!UnitSpec);
	static assert(UnitSpec._Spec.length >= 2);
	private alias UnitSpec _UnitSpec;
	private alias Value _Value;
	
	/** Overloads for arithmetic operators.
		
		Quantities can be added to other quantities of the same type.
		Dimensionsless quantities can also be added to scalars, 
resulting in a
		scalar.
		Quantities can be multiplied by other quantities and by scalars.
	*/
	Quantity opBinary(string op)(in Quantity right) const
	if(op == "+" || op == "-") {
		mixin("return Quantity(value " ~ op ~ " right.value);");
	}
	
	/// ditto
	void opOpAssign(string op)(in Quantity right) if(op == "+" || op 
== "-") {
		mixin("value " ~ op ~ "= right.value;");
	}
	
	Quantity opUnary(string op)() const if(op == "-" || op == "+") {
		mixin("return Quantity(" ~ op ~ "value);");
	}
	
	/// ditto
	auto opBinary(string op, R)(in R right) const
	if(op == "*" || op == "/") {
		static if(is(R == Quantity)) { // => dimensionsless
			mixin("return value " ~ op ~ " right.value;");
			
		} else static if(isQuantity!R) {
			alias _UnitSpec.Binary!(op, R._UnitSpec) ResultUnitSpec;
			mixin("Value v = value " ~ op ~ " right.value;");
			return Quantity!(ResultUnitSpec, Value)(v);
			
		} else static if(is(R : Value)) {
			mixin("return Quantity(value " ~ op ~ " right);");
			
		} else {
			static assert(false);
		}
	}
	
	/// ditto
	Quantity opBinaryRight(string op)(in Value left) const
	if(op == "*" || op == "/") {
		mixin("return Quantity(left " ~ op ~ " value);");
	}
	
	/// ditto
	void opOpAssign(string op)(in Value right) if(op == "*" || op == 
"/") {
		mixin("value " ~ op ~ "= right;");
	}
	
	/** comparison with other quantities of the same type
	*/
	bool opEquals(ref const(Quantity) other) const {
		return typeid(Value).equals(&value, &other.value);
	}
	
	/// ditto
	bool opEquals(const(Quantity) other) const {
		return opEquals(other); // forward to the ref version
	}
	
	/// ditto
	int opCmp(ref const(Quantity) other) const {
		return typeid(Value).compare(&value, &other.value);
	}
	
	/// ditto
	int opCmp(const(Quantity) other) const {
		return opCmp(other); // forward to the ref version
	}
	
	///
	hash_t toHash() const nothrow @safe {
		return typeid(Value).getHash(&value);
	}
	
	///
	static @property Quantity zero() {
		return Quantity(make!Value(0));
	}
}
unittest {
	static assert(!is(Quantity!(UnitSpec!(), real)));
	mixin BasicUnit!"ampere";
	mixin BasicUnit!"second";
	auto coulomb = ampere * second;
	real dimensionless = second / second;
	static assert(!__traits(compiles, 1 + ampere));
	coulomb += coulomb;
	assert(coulomb.value == 2);
	coulomb *= 2;
	assert(coulomb.value == 4);
	assert(-ampere == -1 * ampere);
	assert(+ampere == ampere);
}

///
alias Curry!(isTemplatedType, Quantity) isQuantity;

/*
	Params:
		Spec = Alternating basic types and exponents. Basic types must 
be sorted
			by their mangled names. No duplicates allowed.
	
	This is a struct just because a type is easier to work with than 
a template.
*/
private struct UnitSpec(Spec ...) {
	private alias Spec _Spec;
	
	private template less(Lhs, Rhs) {
		enum bool less = Lhs.mangleof < Rhs.mangleof;
	}
	
	static if(Spec.length >= 2) {
		static assert(is(Spec[0]));
		static assert(is(typeof(Spec[1])));
		static assert(isIntegral!(typeof(Spec[1])));
		static if(Spec.length > 2) {
			static assert(less!(Spec[0], Spec[2]));
		}
		
		alias Spec[0 .. 2] Head;
		alias Spec[0] HeadId;
		enum headExp = Spec[1];
		alias UnitSpec!(Spec[2 .. $]) Tail;
		
		// Merges U's Spec with the current one.
		template Binary(string op, U) if(op == "*") {
			static assert(isUnitSpec!U);
			static if(U._Spec.length == 0) {
				alias UnitSpec Binary;
			} else static if(less!(HeadId, U.HeadId)) {
				alias UnitSpec!(Head, Tail.Binary!("*", U)._Spec) Binary;
			} else static if(less!(U.HeadId, HeadId)) {
				alias UnitSpec!(U.Head, Binary!("*", U.Tail)._Spec) Binary;
			} else {
				static assert(is(HeadId == U.HeadId));
				private alias Tail.Binary!("*", U.Tail) BinaryTail;
				private enum expSum = headExp + U.headExp;
				static if(expSum == 0) {
					alias BinaryTail Binary;
				} else {
					alias UnitSpec!(HeadId, expSum, BinaryTail._Spec) Binary;
				}
			}
		}
		
	} else {
		static assert(Spec.length == 0);
		
		// see above
		template Binary(string op, U) if(op == "*") {
			static assert(isUnitSpec!U);
			alias U Binary;
		}
	}
	
	// Division is multiplication by the inverse.
	template Binary(string op, U) if(op == "/") {
		static assert(isUnitSpec!U);
		alias Binary!("*", U.Inverse) Binary;
	}
	
	// Exponentiation is repeated multiplication.
	template Pow(int e) {
		static assert(e > 0);
		static if(e == 1) {
			alias UnitSpec Pow;
		} else {
			alias Binary!("*", Pow!(e - 1)) Pow;
		}
	}
	
	// Negates the exponents.
	static if(Spec.length == 0) {
		alias UnitSpec Inverse;
	} else {
		alias UnitSpec!(_Spec[0], -1 * _Spec[1], Tail.Inverse._Spec) 
Inverse;
	}
}
unittest {
	static struct AmpereId {}
	static struct SecondId {}
	alias UnitSpec!(AmpereId, 1) Ampere;
	alias UnitSpec!(SecondId, 1) Second;
	alias UnitSpec!(SecondId, -1) Hertz;
	alias UnitSpec!(AmpereId, 1, SecondId, 1) Coulomb;
	
	static assert(is(Second.Binary!("*", Ampere).Binary!("*", Ampere)
		== UnitSpec!(AmpereId, 2, SecondId, 1)));
	
	static assert(is(Second.Inverse == Hertz));
	
	// no types
	version(none) static assert(!__traits(compiles, UnitSpec!(1, 
1)));
		/*NOTE: dmd 2.060 complains even though this is supposed to fail
		compilation */
	
	// no exponents
	static assert(!__traits(compiles, UnitSpec!(SecondId, 
AmpereId)));
	
	// not ordered alphabetically
	static assert(!__traits(compiles, UnitSpec!(SecondId, 1, 
AmpereId, 1)));
}

private alias Curry!(isTemplatedType, UnitSpec) isUnitSpec;

/** Exponentiation for quantities.
	
	The exponent has to be known at compile time, because it changes 
the
	result type.
*/
auto pow(int exponent, Q)(Q quantity) if(isQuantity!Q) {
	alias Q._UnitSpec.Pow!exponent U;
	return Quantity!(U, Q._Value)(quantity.value ^^ exponent);
}
/// Examples:
unittest {
	mixin BasicUnit!"meter";
	assert(pow!3(meter) == pow!2(meter) * meter);
}
/// the same as pow!2(quantity)
auto square(Q)(Q quantity) if(isQuantity!Q) {
	return pow!2(quantity);
}
/// the same as pow!3(quantity)
auto cubic(Q)(Q quantity) if(isQuantity!Q) {
	return pow!3(quantity);
}
unittest {
	mixin BasicUnit!"meter";
	assert(cubic(meter) == square(meter) * meter);
}


// below: various assorted helper functions

// initialize an assignable type to x
T make(T)(int x) {
	T result;
	result = x;
	return result;
}

/**
	Doesn't work on function templates.
*/
template Curry(alias Template, Args ...) {
	template Curry(MoreArgs ...) {
		alias Template!(Args, MoreArgs) Curry;
	}
}
/// Examples:
unittest {
	static int foo(int a, int b)() {
		return a + b;
	}
	alias Curry!(foo, 42) bar;
	assert(bar!1() == 43);
}

/** If Type is an instance of Template, get the template 
parameters.
*/
template TemplateParameters(alias Template, Type) {
	static if(is(Type _ == Template!Args, Args ...)) {
		alias Args TemplateParameters;
	} else {
		alias void TemplateParameters;
	}
}
/// Examples:
unittest {
	struct S(P ...) {}
	static assert(is(TemplateParameters!(S, S!(int, float)) ==
		TypeTuple!(int, float)));
	
	struct T(P ...) {}
	static assert(is(TemplateParameters!(T, S!(int, float)) == 
void));
}

/** true if Type is an instance of Template
*/
template isTemplatedType(alias Template, Type) {
	enum isTemplatedType = !is(TemplateParameters!(Template, Type) 
== void);
}
/// Examples:
unittest {
	struct A() {}
	struct B() {}
	
	static assert(isTemplatedType!(A, A!()));
	static assert(!isTemplatedType!(A, B!()));
	
	alias Curry!(isTemplatedType, A) isA;
	
	static assert(isA!(A!()));
	static assert(!isA!(B!()));
}