import std.traits : isCallable;

​

template isStronglyPure(F...)

if (F.length == 1 && isCallable!F)

{

    import std.traits : arity, isDelegate, isAssociativeArray, isPointer,

        hasAliasing, Parameters, ParameterStorageClassTuple, ReturnType,

        ParameterStorageClass, FunctionAttribute, functionAttributes;

​

    bool isStronglyPure()

    {

        alias STC = ParameterStorageClass;

​

        if (!(functionAttributes!F & FunctionAttribute.pure_))

            return false;

​

        static foreach (i; 0 .. arity!F)

        {

            if (is(Parameters!F[i] == immutable))

            {}

            else if (isRefType!(Parameters!F[i]) || hasAliasing!(Parameters!F[i])

                    || ParameterStorageClassTuple!F[i] == STC.ref_

                    || ParameterStorageClassTuple!F[i] == STC.out_)

                return false;

        }

​

        if (!is(ReturnType!F : immutable(ReturnType!F)))

            return false;

​

        return true;

    }

​

    private bool isRefType(T)()

    {

        if(is(T == class) || isDelegate!T || isAssociativeArray!T || isPointer!T)

            return true;

        return false;

    }

}

​

template isStronglyPure(string funcName, T ...)

if (isCallable!(mixin(funcName)))

{

    import std.traits : arity, isDelegate, isAssociativeArray, isPointer,

        hasAliasing, Parameters, ParameterStorageClassTuple, ReturnType,

        ParameterStorageClass, FunctionAttribute, functionAttributes,

        moduleName;

    import std.typecons : Tuple;

    bool isStronglyPure()

    {

        foreach(t; __traits(getOverloads,

                            mixin(moduleName!(mixin(funcName))),

                            funcName))

            if (is(Parameters!t == T))

                return isStronglyPure!t;

        assert(0, "None of the overloads match the given function argurments!");

    }

}