mirror of
https://github.com/dlang/phobos.git
synced 2025-04-27 13:40:20 +03:00
52bf1876f7
Make std.functional.memoize accept functions whose return type or parameters are head const.
1755 lines
49 KiB
D
1755 lines
49 KiB
D
// Written in the D programming language.
|
|
|
|
/**
|
|
Functions that manipulate other functions.
|
|
|
|
This module provides functions for compile time function composition. These
|
|
functions are helpful when constructing predicates for the algorithms in
|
|
$(MREF std, algorithm) or $(MREF std, range).
|
|
|
|
$(SCRIPT inhibitQuickIndex = 1;)
|
|
$(BOOKTABLE ,
|
|
$(TR $(TH Function Name) $(TH Description)
|
|
)
|
|
$(TR $(TD $(LREF adjoin))
|
|
$(TD Joins a couple of functions into one that executes the original
|
|
functions independently and returns a tuple with all the results.
|
|
))
|
|
$(TR $(TD $(LREF compose), $(LREF pipe))
|
|
$(TD Join a couple of functions into one that executes the original
|
|
functions one after the other, using one function's result for the next
|
|
function's argument.
|
|
))
|
|
$(TR $(TD $(LREF forward))
|
|
$(TD Forwards function arguments while saving ref-ness.
|
|
))
|
|
$(TR $(TD $(LREF lessThan), $(LREF greaterThan), $(LREF equalTo))
|
|
$(TD Ready-made predicate functions to compare two values.
|
|
))
|
|
$(TR $(TD $(LREF memoize))
|
|
$(TD Creates a function that caches its result for fast re-evaluation.
|
|
))
|
|
$(TR $(TD $(LREF not))
|
|
$(TD Creates a function that negates another.
|
|
))
|
|
$(TR $(TD $(LREF partial))
|
|
$(TD Creates a function that binds the first argument of a given function
|
|
to a given value.
|
|
))
|
|
$(TR $(TD $(LREF reverseArgs))
|
|
$(TD Predicate that reverses the order of its arguments.
|
|
))
|
|
$(TR $(TD $(LREF toDelegate))
|
|
$(TD Converts a callable to a delegate.
|
|
))
|
|
$(TR $(TD $(LREF unaryFun), $(LREF binaryFun))
|
|
$(TD Create a unary or binary function from a string. Most often
|
|
used when defining algorithms on ranges.
|
|
))
|
|
)
|
|
|
|
Copyright: Copyright Andrei Alexandrescu 2008 - 2009.
|
|
License: $(HTTP boost.org/LICENSE_1_0.txt, Boost License 1.0).
|
|
Authors: $(HTTP erdani.org, Andrei Alexandrescu)
|
|
Source: $(PHOBOSSRC std/functional.d)
|
|
*/
|
|
/*
|
|
Copyright Andrei Alexandrescu 2008 - 2009.
|
|
Distributed under the Boost Software License, Version 1.0.
|
|
(See accompanying file LICENSE_1_0.txt or copy at
|
|
http://www.boost.org/LICENSE_1_0.txt)
|
|
*/
|
|
module std.functional;
|
|
|
|
import std.meta : AliasSeq, Reverse;
|
|
import std.traits : isCallable, Parameters;
|
|
|
|
|
|
private template needOpCallAlias(alias fun)
|
|
{
|
|
/* Determine whether or not unaryFun and binaryFun need to alias to fun or
|
|
* fun.opCall. Basically, fun is a function object if fun(...) compiles. We
|
|
* want is(unaryFun!fun) (resp., is(binaryFun!fun)) to be true if fun is
|
|
* any function object. There are 4 possible cases:
|
|
*
|
|
* 1) fun is the type of a function object with static opCall;
|
|
* 2) fun is an instance of a function object with static opCall;
|
|
* 3) fun is the type of a function object with non-static opCall;
|
|
* 4) fun is an instance of a function object with non-static opCall.
|
|
*
|
|
* In case (1), is(unaryFun!fun) should compile, but does not if unaryFun
|
|
* aliases itself to fun, because typeof(fun) is an error when fun itself
|
|
* is a type. So it must be aliased to fun.opCall instead. All other cases
|
|
* should be aliased to fun directly.
|
|
*/
|
|
static if (is(typeof(fun.opCall) == function))
|
|
{
|
|
enum needOpCallAlias = !is(typeof(fun)) && __traits(compiles, () {
|
|
return fun(Parameters!fun.init);
|
|
});
|
|
}
|
|
else
|
|
enum needOpCallAlias = false;
|
|
}
|
|
|
|
/**
|
|
Transforms a `string` representing an expression into a unary
|
|
function. The `string` must either use symbol name `a` as
|
|
the parameter or provide the symbol via the `parmName` argument.
|
|
|
|
Params:
|
|
fun = a `string` or a callable
|
|
parmName = the name of the parameter if `fun` is a string. Defaults
|
|
to `"a"`.
|
|
Returns:
|
|
If `fun` is a `string`, a new single parameter function
|
|
|
|
If `fun` is not a `string`, an alias to `fun`.
|
|
*/
|
|
template unaryFun(alias fun, string parmName = "a")
|
|
{
|
|
static if (is(typeof(fun) : string))
|
|
{
|
|
static if (!fun._ctfeMatchUnary(parmName))
|
|
{
|
|
import std.algorithm, std.conv, std.exception, std.math, std.range, std.string;
|
|
import std.meta, std.traits, std.typecons;
|
|
}
|
|
auto unaryFun(ElementType)(auto ref ElementType __a)
|
|
{
|
|
mixin("alias " ~ parmName ~ " = __a ;");
|
|
return mixin(fun);
|
|
}
|
|
}
|
|
else static if (needOpCallAlias!fun)
|
|
{
|
|
// Issue 9906
|
|
alias unaryFun = fun.opCall;
|
|
}
|
|
else
|
|
{
|
|
alias unaryFun = fun;
|
|
}
|
|
}
|
|
|
|
///
|
|
@safe unittest
|
|
{
|
|
// Strings are compiled into functions:
|
|
alias isEven = unaryFun!("(a & 1) == 0");
|
|
assert(isEven(2) && !isEven(1));
|
|
}
|
|
|
|
@safe unittest
|
|
{
|
|
static int f1(int a) { return a + 1; }
|
|
static assert(is(typeof(unaryFun!(f1)(1)) == int));
|
|
assert(unaryFun!(f1)(41) == 42);
|
|
int f2(int a) { return a + 1; }
|
|
static assert(is(typeof(unaryFun!(f2)(1)) == int));
|
|
assert(unaryFun!(f2)(41) == 42);
|
|
assert(unaryFun!("a + 1")(41) == 42);
|
|
//assert(unaryFun!("return a + 1;")(41) == 42);
|
|
|
|
int num = 41;
|
|
assert(unaryFun!"a + 1"(num) == 42);
|
|
|
|
// Issue 9906
|
|
struct Seen
|
|
{
|
|
static bool opCall(int n) { return true; }
|
|
}
|
|
static assert(needOpCallAlias!Seen);
|
|
static assert(is(typeof(unaryFun!Seen(1))));
|
|
assert(unaryFun!Seen(1));
|
|
|
|
Seen s;
|
|
static assert(!needOpCallAlias!s);
|
|
static assert(is(typeof(unaryFun!s(1))));
|
|
assert(unaryFun!s(1));
|
|
|
|
struct FuncObj
|
|
{
|
|
bool opCall(int n) { return true; }
|
|
}
|
|
FuncObj fo;
|
|
static assert(!needOpCallAlias!fo);
|
|
static assert(is(typeof(unaryFun!fo)));
|
|
assert(unaryFun!fo(1));
|
|
|
|
// Function object with non-static opCall can only be called with an
|
|
// instance, not with merely the type.
|
|
static assert(!is(typeof(unaryFun!FuncObj)));
|
|
}
|
|
|
|
/**
|
|
Transforms a `string` representing an expression into a binary function. The
|
|
`string` must either use symbol names `a` and `b` as the parameters or
|
|
provide the symbols via the `parm1Name` and `parm2Name` arguments.
|
|
|
|
Params:
|
|
fun = a `string` or a callable
|
|
parm1Name = the name of the first parameter if `fun` is a string.
|
|
Defaults to `"a"`.
|
|
parm2Name = the name of the second parameter if `fun` is a string.
|
|
Defaults to `"b"`.
|
|
Returns:
|
|
If `fun` is not a string, `binaryFun` aliases itself away to
|
|
`fun`.
|
|
*/
|
|
template binaryFun(alias fun, string parm1Name = "a",
|
|
string parm2Name = "b")
|
|
{
|
|
static if (is(typeof(fun) : string))
|
|
{
|
|
static if (!fun._ctfeMatchBinary(parm1Name, parm2Name))
|
|
{
|
|
import std.algorithm, std.conv, std.exception, std.math, std.range, std.string;
|
|
import std.meta, std.traits, std.typecons;
|
|
}
|
|
auto binaryFun(ElementType1, ElementType2)
|
|
(auto ref ElementType1 __a, auto ref ElementType2 __b)
|
|
{
|
|
mixin("alias "~parm1Name~" = __a ;");
|
|
mixin("alias "~parm2Name~" = __b ;");
|
|
return mixin(fun);
|
|
}
|
|
}
|
|
else static if (needOpCallAlias!fun)
|
|
{
|
|
// Issue 9906
|
|
alias binaryFun = fun.opCall;
|
|
}
|
|
else
|
|
{
|
|
alias binaryFun = fun;
|
|
}
|
|
}
|
|
|
|
///
|
|
@safe unittest
|
|
{
|
|
alias less = binaryFun!("a < b");
|
|
assert(less(1, 2) && !less(2, 1));
|
|
alias greater = binaryFun!("a > b");
|
|
assert(!greater("1", "2") && greater("2", "1"));
|
|
}
|
|
|
|
@safe unittest
|
|
{
|
|
static int f1(int a, string b) { return a + 1; }
|
|
static assert(is(typeof(binaryFun!(f1)(1, "2")) == int));
|
|
assert(binaryFun!(f1)(41, "a") == 42);
|
|
string f2(int a, string b) { return b ~ "2"; }
|
|
static assert(is(typeof(binaryFun!(f2)(1, "1")) == string));
|
|
assert(binaryFun!(f2)(1, "4") == "42");
|
|
assert(binaryFun!("a + b")(41, 1) == 42);
|
|
//@@BUG
|
|
//assert(binaryFun!("return a + b;")(41, 1) == 42);
|
|
|
|
// Issue 9906
|
|
struct Seen
|
|
{
|
|
static bool opCall(int x, int y) { return true; }
|
|
}
|
|
static assert(is(typeof(binaryFun!Seen)));
|
|
assert(binaryFun!Seen(1,1));
|
|
|
|
struct FuncObj
|
|
{
|
|
bool opCall(int x, int y) { return true; }
|
|
}
|
|
FuncObj fo;
|
|
static assert(!needOpCallAlias!fo);
|
|
static assert(is(typeof(binaryFun!fo)));
|
|
assert(unaryFun!fo(1,1));
|
|
|
|
// Function object with non-static opCall can only be called with an
|
|
// instance, not with merely the type.
|
|
static assert(!is(typeof(binaryFun!FuncObj)));
|
|
}
|
|
|
|
// skip all ASCII chars except a .. z, A .. Z, 0 .. 9, '_' and '.'.
|
|
private uint _ctfeSkipOp(ref string op)
|
|
{
|
|
if (!__ctfe) assert(false);
|
|
import std.ascii : isASCII, isAlphaNum;
|
|
immutable oldLength = op.length;
|
|
while (op.length)
|
|
{
|
|
immutable front = op[0];
|
|
if (front.isASCII() && !(front.isAlphaNum() || front == '_' || front == '.'))
|
|
op = op[1..$];
|
|
else
|
|
break;
|
|
}
|
|
return oldLength != op.length;
|
|
}
|
|
|
|
// skip all digits
|
|
private uint _ctfeSkipInteger(ref string op)
|
|
{
|
|
if (!__ctfe) assert(false);
|
|
import std.ascii : isDigit;
|
|
immutable oldLength = op.length;
|
|
while (op.length)
|
|
{
|
|
immutable front = op[0];
|
|
if (front.isDigit())
|
|
op = op[1..$];
|
|
else
|
|
break;
|
|
}
|
|
return oldLength != op.length;
|
|
}
|
|
|
|
// skip name
|
|
private uint _ctfeSkipName(ref string op, string name)
|
|
{
|
|
if (!__ctfe) assert(false);
|
|
if (op.length >= name.length && op[0 .. name.length] == name)
|
|
{
|
|
op = op[name.length..$];
|
|
return 1;
|
|
}
|
|
return 0;
|
|
}
|
|
|
|
// returns 1 if `fun` is trivial unary function
|
|
private uint _ctfeMatchUnary(string fun, string name)
|
|
{
|
|
if (!__ctfe) assert(false);
|
|
fun._ctfeSkipOp();
|
|
for (;;)
|
|
{
|
|
immutable h = fun._ctfeSkipName(name) + fun._ctfeSkipInteger();
|
|
if (h == 0)
|
|
{
|
|
fun._ctfeSkipOp();
|
|
break;
|
|
}
|
|
else if (h == 1)
|
|
{
|
|
if (!fun._ctfeSkipOp())
|
|
break;
|
|
}
|
|
else
|
|
return 0;
|
|
}
|
|
return fun.length == 0;
|
|
}
|
|
|
|
@safe unittest
|
|
{
|
|
static assert(!_ctfeMatchUnary("sqrt(ё)", "ё"));
|
|
static assert(!_ctfeMatchUnary("ё.sqrt", "ё"));
|
|
static assert(!_ctfeMatchUnary(".ё+ё", "ё"));
|
|
static assert(!_ctfeMatchUnary("_ё+ё", "ё"));
|
|
static assert(!_ctfeMatchUnary("ёё", "ё"));
|
|
static assert(_ctfeMatchUnary("a+a", "a"));
|
|
static assert(_ctfeMatchUnary("a + 10", "a"));
|
|
static assert(_ctfeMatchUnary("4 == a", "a"));
|
|
static assert(_ctfeMatchUnary("2 == a", "a"));
|
|
static assert(_ctfeMatchUnary("1 != a", "a"));
|
|
static assert(_ctfeMatchUnary("a != 4", "a"));
|
|
static assert(_ctfeMatchUnary("a< 1", "a"));
|
|
static assert(_ctfeMatchUnary("434 < a", "a"));
|
|
static assert(_ctfeMatchUnary("132 > a", "a"));
|
|
static assert(_ctfeMatchUnary("123 >a", "a"));
|
|
static assert(_ctfeMatchUnary("a>82", "a"));
|
|
static assert(_ctfeMatchUnary("ё>82", "ё"));
|
|
static assert(_ctfeMatchUnary("ё[ё(ё)]", "ё"));
|
|
static assert(_ctfeMatchUnary("ё[21]", "ё"));
|
|
}
|
|
|
|
// returns 1 if `fun` is trivial binary function
|
|
private uint _ctfeMatchBinary(string fun, string name1, string name2)
|
|
{
|
|
if (!__ctfe) assert(false);
|
|
fun._ctfeSkipOp();
|
|
for (;;)
|
|
{
|
|
immutable h = fun._ctfeSkipName(name1) + fun._ctfeSkipName(name2) + fun._ctfeSkipInteger();
|
|
if (h == 0)
|
|
{
|
|
fun._ctfeSkipOp();
|
|
break;
|
|
}
|
|
else if (h == 1)
|
|
{
|
|
if (!fun._ctfeSkipOp())
|
|
break;
|
|
}
|
|
else
|
|
return 0;
|
|
}
|
|
return fun.length == 0;
|
|
}
|
|
|
|
@safe unittest
|
|
{
|
|
|
|
static assert(!_ctfeMatchBinary("sqrt(ё)", "ё", "b"));
|
|
static assert(!_ctfeMatchBinary("ё.sqrt", "ё", "b"));
|
|
static assert(!_ctfeMatchBinary(".ё+ё", "ё", "b"));
|
|
static assert(!_ctfeMatchBinary("_ё+ё", "ё", "b"));
|
|
static assert(!_ctfeMatchBinary("ёё", "ё", "b"));
|
|
static assert(_ctfeMatchBinary("a+a", "a", "b"));
|
|
static assert(_ctfeMatchBinary("a + 10", "a", "b"));
|
|
static assert(_ctfeMatchBinary("4 == a", "a", "b"));
|
|
static assert(_ctfeMatchBinary("2 == a", "a", "b"));
|
|
static assert(_ctfeMatchBinary("1 != a", "a", "b"));
|
|
static assert(_ctfeMatchBinary("a != 4", "a", "b"));
|
|
static assert(_ctfeMatchBinary("a< 1", "a", "b"));
|
|
static assert(_ctfeMatchBinary("434 < a", "a", "b"));
|
|
static assert(_ctfeMatchBinary("132 > a", "a", "b"));
|
|
static assert(_ctfeMatchBinary("123 >a", "a", "b"));
|
|
static assert(_ctfeMatchBinary("a>82", "a", "b"));
|
|
static assert(_ctfeMatchBinary("ё>82", "ё", "q"));
|
|
static assert(_ctfeMatchBinary("ё[ё(10)]", "ё", "q"));
|
|
static assert(_ctfeMatchBinary("ё[21]", "ё", "q"));
|
|
|
|
static assert(!_ctfeMatchBinary("sqrt(ё)+b", "b", "ё"));
|
|
static assert(!_ctfeMatchBinary("ё.sqrt-b", "b", "ё"));
|
|
static assert(!_ctfeMatchBinary(".ё+b", "b", "ё"));
|
|
static assert(!_ctfeMatchBinary("_b+ё", "b", "ё"));
|
|
static assert(!_ctfeMatchBinary("ba", "b", "a"));
|
|
static assert(_ctfeMatchBinary("a+b", "b", "a"));
|
|
static assert(_ctfeMatchBinary("a + b", "b", "a"));
|
|
static assert(_ctfeMatchBinary("b == a", "b", "a"));
|
|
static assert(_ctfeMatchBinary("b == a", "b", "a"));
|
|
static assert(_ctfeMatchBinary("b != a", "b", "a"));
|
|
static assert(_ctfeMatchBinary("a != b", "b", "a"));
|
|
static assert(_ctfeMatchBinary("a< b", "b", "a"));
|
|
static assert(_ctfeMatchBinary("b < a", "b", "a"));
|
|
static assert(_ctfeMatchBinary("b > a", "b", "a"));
|
|
static assert(_ctfeMatchBinary("b >a", "b", "a"));
|
|
static assert(_ctfeMatchBinary("a>b", "b", "a"));
|
|
static assert(_ctfeMatchBinary("ё>b", "b", "ё"));
|
|
static assert(_ctfeMatchBinary("b[ё(-1)]", "b", "ё"));
|
|
static assert(_ctfeMatchBinary("ё[-21]", "b", "ё"));
|
|
}
|
|
|
|
//undocumented
|
|
template safeOp(string S)
|
|
if (S=="<"||S==">"||S=="<="||S==">="||S=="=="||S=="!=")
|
|
{
|
|
import std.traits : isIntegral;
|
|
private bool unsafeOp(ElementType1, ElementType2)(ElementType1 a, ElementType2 b) pure
|
|
if (isIntegral!ElementType1 && isIntegral!ElementType2)
|
|
{
|
|
import std.traits : CommonType;
|
|
alias T = CommonType!(ElementType1, ElementType2);
|
|
return mixin("cast(T)a "~S~" cast(T) b");
|
|
}
|
|
|
|
bool safeOp(T0, T1)(auto ref T0 a, auto ref T1 b)
|
|
{
|
|
import std.traits : mostNegative;
|
|
static if (isIntegral!T0 && isIntegral!T1 &&
|
|
(mostNegative!T0 < 0) != (mostNegative!T1 < 0))
|
|
{
|
|
static if (S == "<=" || S == "<")
|
|
{
|
|
static if (mostNegative!T0 < 0)
|
|
immutable result = a < 0 || unsafeOp(a, b);
|
|
else
|
|
immutable result = b >= 0 && unsafeOp(a, b);
|
|
}
|
|
else
|
|
{
|
|
static if (mostNegative!T0 < 0)
|
|
immutable result = a >= 0 && unsafeOp(a, b);
|
|
else
|
|
immutable result = b < 0 || unsafeOp(a, b);
|
|
}
|
|
}
|
|
else
|
|
{
|
|
static assert(is(typeof(mixin("a "~S~" b"))),
|
|
"Invalid arguments: Cannot compare types " ~ T0.stringof ~ " and " ~ T1.stringof ~ ".");
|
|
|
|
immutable result = mixin("a "~S~" b");
|
|
}
|
|
return result;
|
|
}
|
|
}
|
|
|
|
@safe unittest //check user defined types
|
|
{
|
|
import std.algorithm.comparison : equal;
|
|
struct Foo
|
|
{
|
|
int a;
|
|
auto opEquals(Foo foo)
|
|
{
|
|
return a == foo.a;
|
|
}
|
|
}
|
|
assert(safeOp!"!="(Foo(1), Foo(2)));
|
|
}
|
|
|
|
/**
|
|
Predicate that returns $(D_PARAM a < b).
|
|
Correctly compares signed and unsigned integers, ie. -1 < 2U.
|
|
*/
|
|
alias lessThan = safeOp!"<";
|
|
|
|
///
|
|
pure @safe @nogc nothrow unittest
|
|
{
|
|
assert(lessThan(2, 3));
|
|
assert(lessThan(2U, 3U));
|
|
assert(lessThan(2, 3.0));
|
|
assert(lessThan(-2, 3U));
|
|
assert(lessThan(2, 3U));
|
|
assert(!lessThan(3U, -2));
|
|
assert(!lessThan(3U, 2));
|
|
assert(!lessThan(0, 0));
|
|
assert(!lessThan(0U, 0));
|
|
assert(!lessThan(0, 0U));
|
|
}
|
|
|
|
/**
|
|
Predicate that returns $(D_PARAM a > b).
|
|
Correctly compares signed and unsigned integers, ie. 2U > -1.
|
|
*/
|
|
alias greaterThan = safeOp!">";
|
|
|
|
///
|
|
@safe unittest
|
|
{
|
|
assert(!greaterThan(2, 3));
|
|
assert(!greaterThan(2U, 3U));
|
|
assert(!greaterThan(2, 3.0));
|
|
assert(!greaterThan(-2, 3U));
|
|
assert(!greaterThan(2, 3U));
|
|
assert(greaterThan(3U, -2));
|
|
assert(greaterThan(3U, 2));
|
|
assert(!greaterThan(0, 0));
|
|
assert(!greaterThan(0U, 0));
|
|
assert(!greaterThan(0, 0U));
|
|
}
|
|
|
|
/**
|
|
Predicate that returns $(D_PARAM a == b).
|
|
Correctly compares signed and unsigned integers, ie. !(-1 == ~0U).
|
|
*/
|
|
alias equalTo = safeOp!"==";
|
|
|
|
///
|
|
@safe unittest
|
|
{
|
|
assert(equalTo(0U, 0));
|
|
assert(equalTo(0, 0U));
|
|
assert(!equalTo(-1, ~0U));
|
|
}
|
|
/**
|
|
N-ary predicate that reverses the order of arguments, e.g., given
|
|
$(D pred(a, b, c)), returns $(D pred(c, b, a)).
|
|
|
|
Params:
|
|
pred = A callable
|
|
Returns:
|
|
A function which calls `pred` after reversing the given parameters
|
|
*/
|
|
template reverseArgs(alias pred)
|
|
{
|
|
auto reverseArgs(Args...)(auto ref Args args)
|
|
if (is(typeof(pred(Reverse!args))))
|
|
{
|
|
return pred(Reverse!args);
|
|
}
|
|
}
|
|
|
|
///
|
|
@safe unittest
|
|
{
|
|
alias gt = reverseArgs!(binaryFun!("a < b"));
|
|
assert(gt(2, 1) && !gt(1, 1));
|
|
}
|
|
|
|
///
|
|
@safe unittest
|
|
{
|
|
int x = 42;
|
|
bool xyz(int a, int b) { return a * x < b / x; }
|
|
auto foo = &xyz;
|
|
foo(4, 5);
|
|
alias zyx = reverseArgs!(foo);
|
|
assert(zyx(5, 4) == foo(4, 5));
|
|
}
|
|
|
|
///
|
|
@safe unittest
|
|
{
|
|
alias gt = reverseArgs!(binaryFun!("a < b"));
|
|
assert(gt(2, 1) && !gt(1, 1));
|
|
int x = 42;
|
|
bool xyz(int a, int b) { return a * x < b / x; }
|
|
auto foo = &xyz;
|
|
foo(4, 5);
|
|
alias zyx = reverseArgs!(foo);
|
|
assert(zyx(5, 4) == foo(4, 5));
|
|
}
|
|
|
|
///
|
|
@safe unittest
|
|
{
|
|
int abc(int a, int b, int c) { return a * b + c; }
|
|
alias cba = reverseArgs!abc;
|
|
assert(abc(91, 17, 32) == cba(32, 17, 91));
|
|
}
|
|
|
|
///
|
|
@safe unittest
|
|
{
|
|
int a(int a) { return a * 2; }
|
|
alias _a = reverseArgs!a;
|
|
assert(a(2) == _a(2));
|
|
}
|
|
|
|
///
|
|
@safe unittest
|
|
{
|
|
int b() { return 4; }
|
|
alias _b = reverseArgs!b;
|
|
assert(b() == _b());
|
|
}
|
|
|
|
// @@@DEPRECATED_2.089@@@
|
|
/**
|
|
Binary predicate that reverses the order of arguments, e.g., given
|
|
$(D pred(a, b)), returns $(D pred(b, a)).
|
|
|
|
$(RED DEPRECATED: Use $(LREF reverseArgs))
|
|
|
|
Params:
|
|
pred = A callable
|
|
Returns:
|
|
A function which calls `pred` after reversing the given parameters
|
|
*/
|
|
deprecated("Use `reverseArgs`. `binaryReverseArgs` will be removed in 2.089.")
|
|
template binaryReverseArgs(alias pred)
|
|
{
|
|
auto binaryReverseArgs(ElementType1, ElementType2)
|
|
(auto ref ElementType1 a, auto ref ElementType2 b)
|
|
{
|
|
return pred(b, a);
|
|
}
|
|
}
|
|
|
|
///
|
|
deprecated
|
|
@safe unittest
|
|
{
|
|
alias gt = binaryReverseArgs!(binaryFun!("a < b"));
|
|
assert(gt(2, 1) && !gt(1, 1));
|
|
}
|
|
|
|
///
|
|
deprecated
|
|
@safe unittest
|
|
{
|
|
int x = 42;
|
|
bool xyz(int a, int b) { return a * x < b / x; }
|
|
auto foo = &xyz;
|
|
foo(4, 5);
|
|
alias zyx = binaryReverseArgs!(foo);
|
|
assert(zyx(5, 4) == foo(4, 5));
|
|
}
|
|
|
|
/**
|
|
Negates predicate `pred`.
|
|
|
|
Params:
|
|
pred = A string or a callable
|
|
Returns:
|
|
A function which calls `pred` and returns the logical negation of its
|
|
return value.
|
|
*/
|
|
template not(alias pred)
|
|
{
|
|
auto not(T...)(auto ref T args)
|
|
{
|
|
static if (is(typeof(!pred(args))))
|
|
return !pred(args);
|
|
else static if (T.length == 1)
|
|
return !unaryFun!pred(args);
|
|
else static if (T.length == 2)
|
|
return !binaryFun!pred(args);
|
|
else
|
|
static assert(0);
|
|
}
|
|
}
|
|
|
|
///
|
|
@safe unittest
|
|
{
|
|
import std.algorithm.searching : find;
|
|
import std.functional;
|
|
import std.uni : isWhite;
|
|
string a = " Hello, world!";
|
|
assert(find!(not!isWhite)(a) == "Hello, world!");
|
|
}
|
|
|
|
@safe unittest
|
|
{
|
|
assert(not!"a != 5"(5));
|
|
assert(not!"a != b"(5, 5));
|
|
|
|
assert(not!(() => false)());
|
|
assert(not!(a => a != 5)(5));
|
|
assert(not!((a, b) => a != b)(5, 5));
|
|
assert(not!((a, b, c) => a * b * c != 125 )(5, 5, 5));
|
|
}
|
|
|
|
/**
|
|
$(LINK2 http://en.wikipedia.org/wiki/Partial_application, Partially
|
|
applies) $(D_PARAM fun) by tying its first argument to $(D_PARAM arg).
|
|
|
|
Params:
|
|
fun = A callable
|
|
arg = The first argument to apply to `fun`
|
|
Returns:
|
|
A new function which calls `fun` with `arg` plus the passed parameters.
|
|
*/
|
|
template partial(alias fun, alias arg)
|
|
{
|
|
import std.traits : isCallable;
|
|
// Check whether fun is a user defined type which implements opCall or a template.
|
|
// As opCall itself can be templated, std.traits.isCallable does not work here.
|
|
enum isSomeFunctor = (is(typeof(fun) == struct) || is(typeof(fun) == class)) && __traits(hasMember, fun, "opCall");
|
|
static if (isSomeFunctor || __traits(isTemplate, fun))
|
|
{
|
|
auto partial(Ts...)(Ts args2)
|
|
{
|
|
static if (is(typeof(fun(arg, args2))))
|
|
{
|
|
return fun(arg, args2);
|
|
}
|
|
else
|
|
{
|
|
static string errormsg()
|
|
{
|
|
string msg = "Cannot call '" ~ fun.stringof ~ "' with arguments " ~
|
|
"(" ~ arg.stringof;
|
|
foreach (T; Ts)
|
|
msg ~= ", " ~ T.stringof;
|
|
msg ~= ").";
|
|
return msg;
|
|
}
|
|
static assert(0, errormsg());
|
|
}
|
|
}
|
|
}
|
|
else static if (!isCallable!fun)
|
|
{
|
|
static assert(false, "Cannot apply partial to a non-callable '" ~ fun.stringof ~ "'.");
|
|
}
|
|
else // Assume fun is callable and uniquely defined.
|
|
{
|
|
static if (Parameters!fun.length == 0)
|
|
{
|
|
static assert(0, "Cannot partially apply '" ~ fun.stringof ~ "'." ~
|
|
"'" ~ fun.stringof ~ "' has 0 arguments.");
|
|
}
|
|
else static if (!is(typeof(arg) : Parameters!fun[0]))
|
|
{
|
|
string errorMsg()
|
|
{
|
|
string msg = "Argument mismatch for '" ~ fun.stringof ~ "': expected " ~
|
|
Parameters!fun[0].stringof ~ ", but got " ~ typeof(arg).stringof ~ ".";
|
|
return msg;
|
|
}
|
|
static assert(0, errorMsg());
|
|
}
|
|
else
|
|
{
|
|
import std.traits : ReturnType;
|
|
ReturnType!fun partial(Parameters!fun[1..$] args2)
|
|
{
|
|
return fun(arg, args2);
|
|
}
|
|
}
|
|
}
|
|
}
|
|
|
|
///
|
|
@safe unittest
|
|
{
|
|
int fun(int a, int b) { return a + b; }
|
|
alias fun5 = partial!(fun, 5);
|
|
assert(fun5(6) == 11);
|
|
// Note that in most cases you'd use an alias instead of a value
|
|
// assignment. Using an alias allows you to partially evaluate template
|
|
// functions without committing to a particular type of the function.
|
|
}
|
|
|
|
// tests for partially evaluating callables
|
|
@safe unittest
|
|
{
|
|
static int f1(int a, int b) { return a + b; }
|
|
assert(partial!(f1, 5)(6) == 11);
|
|
|
|
int f2(int a, int b) { return a + b; }
|
|
int x = 5;
|
|
assert(partial!(f2, x)(6) == 11);
|
|
x = 7;
|
|
assert(partial!(f2, x)(6) == 13);
|
|
static assert(partial!(f2, 5)(6) == 11);
|
|
|
|
auto dg = &f2;
|
|
auto f3 = &partial!(dg, x);
|
|
assert(f3(6) == 13);
|
|
|
|
static int funOneArg(int a) { return a; }
|
|
assert(partial!(funOneArg, 1)() == 1);
|
|
|
|
static int funThreeArgs(int a, int b, int c) { return a + b + c; }
|
|
alias funThreeArgs1 = partial!(funThreeArgs, 1);
|
|
assert(funThreeArgs1(2, 3) == 6);
|
|
static assert(!is(typeof(funThreeArgs1(2))));
|
|
|
|
enum xe = 5;
|
|
alias fe = partial!(f2, xe);
|
|
static assert(fe(6) == 11);
|
|
}
|
|
|
|
// tests for partially evaluating templated/overloaded callables
|
|
@safe unittest
|
|
{
|
|
static auto add(A, B)(A x, B y)
|
|
{
|
|
return x + y;
|
|
}
|
|
|
|
alias add5 = partial!(add, 5);
|
|
assert(add5(6) == 11);
|
|
static assert(!is(typeof(add5())));
|
|
static assert(!is(typeof(add5(6, 7))));
|
|
|
|
// taking address of templated partial evaluation needs explicit type
|
|
auto dg = &add5!(int);
|
|
assert(dg(6) == 11);
|
|
|
|
int x = 5;
|
|
alias addX = partial!(add, x);
|
|
assert(addX(6) == 11);
|
|
|
|
static struct Callable
|
|
{
|
|
static string opCall(string a, string b) { return a ~ b; }
|
|
int opCall(int a, int b) { return a * b; }
|
|
double opCall(double a, double b) { return a + b; }
|
|
}
|
|
Callable callable;
|
|
assert(partial!(Callable, "5")("6") == "56");
|
|
assert(partial!(callable, 5)(6) == 30);
|
|
assert(partial!(callable, 7.0)(3.0) == 7.0 + 3.0);
|
|
|
|
static struct TCallable
|
|
{
|
|
auto opCall(A, B)(A a, B b)
|
|
{
|
|
return a + b;
|
|
}
|
|
}
|
|
TCallable tcallable;
|
|
assert(partial!(tcallable, 5)(6) == 11);
|
|
static assert(!is(typeof(partial!(tcallable, "5")(6))));
|
|
|
|
static struct NonCallable{}
|
|
static assert(!__traits(compiles, partial!(NonCallable, 5)), "Partial should not work on non-callable structs.");
|
|
static assert(!__traits(compiles, partial!(NonCallable.init, 5)),
|
|
"Partial should not work on instances of non-callable structs.");
|
|
|
|
static A funOneArg(A)(A a) { return a; }
|
|
alias funOneArg1 = partial!(funOneArg, 1);
|
|
assert(funOneArg1() == 1);
|
|
|
|
static auto funThreeArgs(A, B, C)(A a, B b, C c) { return a + b + c; }
|
|
alias funThreeArgs1 = partial!(funThreeArgs, 1);
|
|
assert(funThreeArgs1(2, 3) == 6);
|
|
static assert(!is(typeof(funThreeArgs1(1))));
|
|
|
|
auto dg2 = &funOneArg1!();
|
|
assert(dg2() == 1);
|
|
}
|
|
|
|
// Fix issue 15732
|
|
@safe unittest
|
|
{
|
|
// Test whether it works with functions.
|
|
auto partialFunction(){
|
|
auto fullFunction = (float a, float b, float c) => a + b / c;
|
|
alias apply1 = partial!(fullFunction, 1);
|
|
return &apply1;
|
|
}
|
|
auto result = partialFunction()(2, 4);
|
|
assert(result == 1.5f);
|
|
|
|
// And with delegates.
|
|
auto partialDelegate(float c){
|
|
auto fullDelegate = (float a, float b) => a + b / c;
|
|
alias apply1 = partial!(fullDelegate, 1);
|
|
return &apply1;
|
|
}
|
|
auto result2 = partialDelegate(4)(2);
|
|
assert(result2 == 1.5f);
|
|
}
|
|
|
|
/**
|
|
Takes multiple functions and adjoins them together.
|
|
|
|
Params:
|
|
F = the call-able(s) to adjoin
|
|
Returns:
|
|
A new function which returns a $(REF Tuple, std,typecons). Each of the
|
|
elements of the tuple will be the return values of `F`.
|
|
|
|
Note: In the special case where only a single function is provided
|
|
($(D F.length == 1)), adjoin simply aliases to the single passed function
|
|
(`F[0]`).
|
|
*/
|
|
template adjoin(F...)
|
|
if (F.length == 1)
|
|
{
|
|
alias adjoin = F[0];
|
|
}
|
|
/// ditto
|
|
template adjoin(F...)
|
|
if (F.length > 1)
|
|
{
|
|
auto adjoin(V...)(auto ref V a)
|
|
{
|
|
import std.typecons : tuple;
|
|
static if (F.length == 2)
|
|
{
|
|
return tuple(F[0](a), F[1](a));
|
|
}
|
|
else static if (F.length == 3)
|
|
{
|
|
return tuple(F[0](a), F[1](a), F[2](a));
|
|
}
|
|
else
|
|
{
|
|
import std.format : format;
|
|
import std.range : iota;
|
|
return mixin (q{tuple(%(F[%s](a)%|, %))}.format(iota(0, F.length)));
|
|
}
|
|
}
|
|
}
|
|
|
|
///
|
|
@safe unittest
|
|
{
|
|
import std.functional, std.typecons : Tuple;
|
|
static bool f1(int a) { return a != 0; }
|
|
static int f2(int a) { return a / 2; }
|
|
auto x = adjoin!(f1, f2)(5);
|
|
assert(is(typeof(x) == Tuple!(bool, int)));
|
|
assert(x[0] == true && x[1] == 2);
|
|
}
|
|
|
|
@safe unittest
|
|
{
|
|
import std.typecons : Tuple;
|
|
static bool F1(int a) { return a != 0; }
|
|
auto x1 = adjoin!(F1)(5);
|
|
static int F2(int a) { return a / 2; }
|
|
auto x2 = adjoin!(F1, F2)(5);
|
|
assert(is(typeof(x2) == Tuple!(bool, int)));
|
|
assert(x2[0] && x2[1] == 2);
|
|
auto x3 = adjoin!(F1, F2, F2)(5);
|
|
assert(is(typeof(x3) == Tuple!(bool, int, int)));
|
|
assert(x3[0] && x3[1] == 2 && x3[2] == 2);
|
|
|
|
bool F4(int a) { return a != x1; }
|
|
alias eff4 = adjoin!(F4);
|
|
static struct S
|
|
{
|
|
bool delegate(int) @safe store;
|
|
int fun() { return 42 + store(5); }
|
|
}
|
|
S s;
|
|
s.store = (int a) { return eff4(a); };
|
|
auto x4 = s.fun();
|
|
assert(x4 == 43);
|
|
}
|
|
|
|
@safe unittest
|
|
{
|
|
import std.meta : staticMap;
|
|
import std.typecons : Tuple, tuple;
|
|
alias funs = staticMap!(unaryFun, "a", "a * 2", "a * 3", "a * a", "-a");
|
|
alias afun = adjoin!funs;
|
|
assert(afun(5) == tuple(5, 10, 15, 25, -5));
|
|
|
|
static class C{}
|
|
alias IC = immutable(C);
|
|
IC foo(){return typeof(return).init;}
|
|
Tuple!(IC, IC, IC, IC) ret1 = adjoin!(foo, foo, foo, foo)();
|
|
|
|
static struct S{int* p;}
|
|
alias IS = immutable(S);
|
|
IS bar(){return typeof(return).init;}
|
|
enum Tuple!(IS, IS, IS, IS) ret2 = adjoin!(bar, bar, bar, bar)();
|
|
}
|
|
|
|
/**
|
|
Composes passed-in functions $(D fun[0], fun[1], ...).
|
|
|
|
Params:
|
|
fun = the call-able(s) or `string`(s) to compose into one function
|
|
Returns:
|
|
A new function `f(x)` that in turn returns `fun[0](fun[1](...(x)))...`.
|
|
|
|
See_Also: $(LREF pipe)
|
|
*/
|
|
template compose(fun...)
|
|
{
|
|
static if (fun.length == 1)
|
|
{
|
|
alias compose = unaryFun!(fun[0]);
|
|
}
|
|
else static if (fun.length == 2)
|
|
{
|
|
// starch
|
|
alias fun0 = unaryFun!(fun[0]);
|
|
alias fun1 = unaryFun!(fun[1]);
|
|
|
|
// protein: the core composition operation
|
|
typeof({ E a; return fun0(fun1(a)); }()) compose(E)(E a)
|
|
{
|
|
return fun0(fun1(a));
|
|
}
|
|
}
|
|
else
|
|
{
|
|
// protein: assembling operations
|
|
alias compose = compose!(fun[0], compose!(fun[1 .. $]));
|
|
}
|
|
}
|
|
|
|
///
|
|
@safe unittest
|
|
{
|
|
import std.algorithm.comparison : equal;
|
|
import std.algorithm.iteration : map;
|
|
import std.array : split;
|
|
import std.conv : to;
|
|
|
|
// First split a string in whitespace-separated tokens and then
|
|
// convert each token into an integer
|
|
assert(compose!(map!(to!(int)), split)("1 2 3").equal([1, 2, 3]));
|
|
}
|
|
|
|
/**
|
|
Pipes functions in sequence. Offers the same functionality as $(D
|
|
compose), but with functions specified in reverse order. This may
|
|
lead to more readable code in some situation because the order of
|
|
execution is the same as lexical order.
|
|
|
|
Params:
|
|
fun = the call-able(s) or `string`(s) to compose into one function
|
|
Returns:
|
|
A new function `f(x)` that in turn returns `fun[$-1](...fun[1](fun[0](x)))...`.
|
|
|
|
Example:
|
|
|
|
----
|
|
// Read an entire text file, split the resulting string in
|
|
// whitespace-separated tokens, and then convert each token into an
|
|
// integer
|
|
int[] a = pipe!(readText, split, map!(to!(int)))("file.txt");
|
|
----
|
|
|
|
See_Also: $(LREF compose)
|
|
*/
|
|
alias pipe(fun...) = compose!(Reverse!(fun));
|
|
|
|
///
|
|
@safe unittest
|
|
{
|
|
import std.conv : to;
|
|
string foo(int a) { return to!(string)(a); }
|
|
int bar(string a) { return to!(int)(a) + 1; }
|
|
double baz(int a) { return a + 0.5; }
|
|
assert(compose!(baz, bar, foo)(1) == 2.5);
|
|
assert(pipe!(foo, bar, baz)(1) == 2.5);
|
|
|
|
assert(compose!(baz, `to!(int)(a) + 1`, foo)(1) == 2.5);
|
|
assert(compose!(baz, bar)("1"[]) == 2.5);
|
|
|
|
assert(compose!(baz, bar)("1") == 2.5);
|
|
|
|
assert(compose!(`a + 0.5`, `to!(int)(a) + 1`, foo)(1) == 2.5);
|
|
}
|
|
|
|
/**
|
|
* $(LINK2 https://en.wikipedia.org/wiki/Memoization, Memoizes) a function so as
|
|
* to avoid repeated computation. The memoization structure is a hash table keyed by a
|
|
* tuple of the function's arguments. There is a speed gain if the
|
|
* function is repeatedly called with the same arguments and is more
|
|
* expensive than a hash table lookup. For more information on memoization, refer to $(HTTP docs.google.com/viewer?url=http%3A%2F%2Fhop.perl.plover.com%2Fbook%2Fpdf%2F03CachingAndMemoization.pdf, this book chapter).
|
|
|
|
Example:
|
|
----
|
|
double transmogrify(int a, string b)
|
|
{
|
|
... expensive computation ...
|
|
}
|
|
alias fastTransmogrify = memoize!transmogrify;
|
|
unittest
|
|
{
|
|
auto slow = transmogrify(2, "hello");
|
|
auto fast = fastTransmogrify(2, "hello");
|
|
assert(slow == fast);
|
|
}
|
|
----
|
|
|
|
Params:
|
|
fun = the call-able to memozie
|
|
maxSize = The maximum size of the GC buffer to hold the return values
|
|
Returns:
|
|
A new function which calls `fun` and caches its return values.
|
|
|
|
Note:
|
|
Technically the memoized function should be pure because `memoize` assumes it will
|
|
always return the same result for a given tuple of arguments. However, `memoize` does not
|
|
enforce that because sometimes it is useful to memoize an impure function, too.
|
|
*/
|
|
template memoize(alias fun)
|
|
{
|
|
import std.traits : ReturnType;
|
|
// alias Args = Parameters!fun; // Bugzilla 13580
|
|
|
|
ReturnType!fun memoize(Parameters!fun args)
|
|
{
|
|
alias Args = Parameters!fun;
|
|
import std.typecons : Tuple;
|
|
import std.traits : Unqual;
|
|
|
|
static Unqual!(ReturnType!fun)[Tuple!Args] memo;
|
|
auto t = Tuple!Args(args);
|
|
if (auto p = t in memo)
|
|
return *p;
|
|
return memo[t] = fun(args);
|
|
}
|
|
}
|
|
|
|
/// ditto
|
|
template memoize(alias fun, uint maxSize)
|
|
{
|
|
import std.traits : ReturnType;
|
|
// alias Args = Parameters!fun; // Bugzilla 13580
|
|
ReturnType!fun memoize(Parameters!fun args)
|
|
{
|
|
import std.meta : staticMap;
|
|
import std.traits : hasIndirections, Unqual;
|
|
import std.typecons : tuple;
|
|
static struct Value { staticMap!(Unqual, Parameters!fun) args; Unqual!(ReturnType!fun) res; }
|
|
static Value[] memo;
|
|
static size_t[] initialized;
|
|
|
|
if (!memo.length)
|
|
{
|
|
import core.memory : GC;
|
|
|
|
// Ensure no allocation overflows
|
|
static assert(maxSize < size_t.max / Value.sizeof);
|
|
static assert(maxSize < size_t.max - (8 * size_t.sizeof - 1));
|
|
|
|
enum attr = GC.BlkAttr.NO_INTERIOR | (hasIndirections!Value ? 0 : GC.BlkAttr.NO_SCAN);
|
|
memo = (cast(Value*) GC.malloc(Value.sizeof * maxSize, attr))[0 .. maxSize];
|
|
enum nwords = (maxSize + 8 * size_t.sizeof - 1) / (8 * size_t.sizeof);
|
|
initialized = (cast(size_t*) GC.calloc(nwords * size_t.sizeof, attr | GC.BlkAttr.NO_SCAN))[0 .. nwords];
|
|
}
|
|
|
|
import core.bitop : bt, bts;
|
|
import std.conv : emplace;
|
|
|
|
size_t hash;
|
|
foreach (ref arg; args)
|
|
hash = hashOf(arg, hash);
|
|
// cuckoo hashing
|
|
immutable idx1 = hash % maxSize;
|
|
if (!bt(initialized.ptr, idx1))
|
|
{
|
|
emplace(&memo[idx1], args, fun(args));
|
|
bts(initialized.ptr, idx1); // only set to initialized after setting args and value (bugzilla 14025)
|
|
return memo[idx1].res;
|
|
}
|
|
else if (memo[idx1].args == args)
|
|
return memo[idx1].res;
|
|
// FNV prime
|
|
immutable idx2 = (hash * 16_777_619) % maxSize;
|
|
if (!bt(initialized.ptr, idx2))
|
|
{
|
|
emplace(&memo[idx2], memo[idx1]);
|
|
bts(initialized.ptr, idx2); // only set to initialized after setting args and value (bugzilla 14025)
|
|
}
|
|
else if (memo[idx2].args == args)
|
|
return memo[idx2].res;
|
|
else if (idx1 != idx2)
|
|
memo[idx2] = memo[idx1];
|
|
|
|
memo[idx1] = Value(args, fun(args));
|
|
return memo[idx1].res;
|
|
}
|
|
}
|
|
|
|
/**
|
|
* To _memoize a recursive function, simply insert the memoized call in lieu of the plain recursive call.
|
|
* For example, to transform the exponential-time Fibonacci implementation into a linear-time computation:
|
|
*/
|
|
@safe unittest
|
|
{
|
|
ulong fib(ulong n) @safe
|
|
{
|
|
return n < 2 ? n : memoize!fib(n - 2) + memoize!fib(n - 1);
|
|
}
|
|
assert(fib(10) == 55);
|
|
}
|
|
|
|
/**
|
|
* To improve the speed of the factorial function,
|
|
*/
|
|
@safe unittest
|
|
{
|
|
ulong fact(ulong n) @safe
|
|
{
|
|
return n < 2 ? 1 : n * memoize!fact(n - 1);
|
|
}
|
|
assert(fact(10) == 3628800);
|
|
}
|
|
|
|
/**
|
|
* This memoizes all values of `fact` up to the largest argument. To only cache the final
|
|
* result, move `memoize` outside the function as shown below.
|
|
*/
|
|
@safe unittest
|
|
{
|
|
ulong factImpl(ulong n) @safe
|
|
{
|
|
return n < 2 ? 1 : n * factImpl(n - 1);
|
|
}
|
|
alias fact = memoize!factImpl;
|
|
assert(fact(10) == 3628800);
|
|
}
|
|
|
|
/**
|
|
* When the `maxSize` parameter is specified, memoize will used
|
|
* a fixed size hash table to limit the number of cached entries.
|
|
*/
|
|
@system unittest // not @safe due to memoize
|
|
{
|
|
ulong fact(ulong n)
|
|
{
|
|
// Memoize no more than 8 values
|
|
return n < 2 ? 1 : n * memoize!(fact, 8)(n - 1);
|
|
}
|
|
assert(fact(8) == 40320);
|
|
// using more entries than maxSize will overwrite existing entries
|
|
assert(fact(10) == 3628800);
|
|
}
|
|
|
|
@system unittest // not @safe due to memoize
|
|
{
|
|
import core.math : sqrt;
|
|
alias msqrt = memoize!(function double(double x) { return sqrt(x); });
|
|
auto y = msqrt(2.0);
|
|
assert(y == msqrt(2.0));
|
|
y = msqrt(4.0);
|
|
assert(y == sqrt(4.0));
|
|
|
|
// alias mrgb2cmyk = memoize!rgb2cmyk;
|
|
// auto z = mrgb2cmyk([43, 56, 76]);
|
|
// assert(z == mrgb2cmyk([43, 56, 76]));
|
|
|
|
//alias mfib = memoize!fib;
|
|
|
|
static ulong fib(ulong n) @safe
|
|
{
|
|
alias mfib = memoize!fib;
|
|
return n < 2 ? 1 : mfib(n - 2) + mfib(n - 1);
|
|
}
|
|
|
|
auto z = fib(10);
|
|
assert(z == 89);
|
|
|
|
static ulong fact(ulong n) @safe
|
|
{
|
|
alias mfact = memoize!fact;
|
|
return n < 2 ? 1 : n * mfact(n - 1);
|
|
}
|
|
assert(fact(10) == 3628800);
|
|
|
|
// Issue 12568
|
|
static uint len2(const string s) { // Error
|
|
alias mLen2 = memoize!len2;
|
|
if (s.length == 0)
|
|
return 0;
|
|
else
|
|
return 1 + mLen2(s[1 .. $]);
|
|
}
|
|
|
|
int _func(int x) @safe { return 1; }
|
|
alias func = memoize!(_func, 10);
|
|
assert(func(int.init) == 1);
|
|
assert(func(int.init) == 1);
|
|
}
|
|
|
|
// 16079: memoize should work with arrays
|
|
@system unittest // not @safe with -dip1000 due to memoize
|
|
{
|
|
int executed = 0;
|
|
T median(T)(const T[] nums) {
|
|
import std.algorithm.sorting : sort;
|
|
executed++;
|
|
auto arr = nums.dup;
|
|
arr.sort();
|
|
if (arr.length % 2)
|
|
return arr[$ / 2];
|
|
else
|
|
return (arr[$ / 2 - 1]
|
|
+ arr[$ / 2]) / 2;
|
|
}
|
|
|
|
alias fastMedian = memoize!(median!int);
|
|
|
|
assert(fastMedian([7, 5, 3]) == 5);
|
|
assert(fastMedian([7, 5, 3]) == 5);
|
|
|
|
assert(executed == 1);
|
|
}
|
|
|
|
// 16079: memoize should work with structs
|
|
@safe unittest
|
|
{
|
|
int executed = 0;
|
|
T pickFirst(T)(T first)
|
|
{
|
|
executed++;
|
|
return first;
|
|
}
|
|
|
|
struct Foo { int k; }
|
|
Foo A = Foo(3);
|
|
|
|
alias first = memoize!(pickFirst!Foo);
|
|
assert(first(Foo(3)) == A);
|
|
assert(first(Foo(3)) == A);
|
|
assert(executed == 1);
|
|
}
|
|
|
|
// 16079: memoize should work with classes
|
|
@system unittest // not @safe with -dip1000 due to memoize
|
|
{
|
|
int executed = 0;
|
|
T pickFirst(T)(T first)
|
|
{
|
|
executed++;
|
|
return first;
|
|
}
|
|
|
|
class Bar
|
|
{
|
|
size_t k;
|
|
this(size_t k)
|
|
{
|
|
this.k = k;
|
|
}
|
|
override size_t toHash()
|
|
{
|
|
return k;
|
|
}
|
|
override bool opEquals(Object o)
|
|
{
|
|
auto b = cast(Bar) o;
|
|
return b && k == b.k;
|
|
}
|
|
}
|
|
|
|
alias firstClass = memoize!(pickFirst!Bar);
|
|
assert(firstClass(new Bar(3)).k == 3);
|
|
assert(firstClass(new Bar(3)).k == 3);
|
|
assert(executed == 1);
|
|
}
|
|
|
|
// https://issues.dlang.org/show_bug.cgi?id=20302
|
|
@system unittest
|
|
{
|
|
version (none) // TODO change `none` to `all` and fix remaining limitations
|
|
struct S { const int len; }
|
|
else
|
|
struct S { int len; }
|
|
|
|
static string fun000( string str, S s) { return str[0 .. s.len] ~ "123"; }
|
|
static string fun001( string str, const S s) { return str[0 .. s.len] ~ "123"; }
|
|
static string fun010(const string str, S s) { return str[0 .. s.len] ~ "123"; }
|
|
static string fun011(const string str, const S s) { return str[0 .. s.len] ~ "123"; }
|
|
static const(string) fun100( string str, S s) { return str[0 .. s.len] ~ "123"; }
|
|
static const(string) fun101( string str, const S s) { return str[0 .. s.len] ~ "123"; }
|
|
static const(string) fun110(const string str, S s) { return str[0 .. s.len] ~ "123"; }
|
|
static const(string) fun111(const string str, const S s) { return str[0 .. s.len] ~ "123"; }
|
|
|
|
static foreach (fun; AliasSeq!(fun000, fun001, fun010, fun011, fun100, fun101, fun110, fun111))
|
|
{{
|
|
alias mfun = memoize!fun;
|
|
assert(mfun("abcdefgh", S(3)) == "abc123");
|
|
|
|
alias mfun2 = memoize!(fun, 42);
|
|
assert(mfun2("asd", S(3)) == "asd123");
|
|
}}
|
|
}
|
|
|
|
private struct DelegateFaker(F)
|
|
{
|
|
import std.typecons : FuncInfo, MemberFunctionGenerator;
|
|
|
|
// for @safe
|
|
static F castToF(THIS)(THIS x) @trusted
|
|
{
|
|
return cast(F) x;
|
|
}
|
|
|
|
/*
|
|
* What all the stuff below does is this:
|
|
*--------------------
|
|
* struct DelegateFaker(F) {
|
|
* extern(linkage)
|
|
* [ref] ReturnType!F doIt(Parameters!F args) [@attributes]
|
|
* {
|
|
* auto fp = cast(F) &this;
|
|
* return fp(args);
|
|
* }
|
|
* }
|
|
*--------------------
|
|
*/
|
|
|
|
// We will use MemberFunctionGenerator in std.typecons. This is a policy
|
|
// configuration for generating the doIt().
|
|
template GeneratingPolicy()
|
|
{
|
|
// Inform the genereator that we only have type information.
|
|
enum WITHOUT_SYMBOL = true;
|
|
|
|
// Generate the function body of doIt().
|
|
template generateFunctionBody(unused...)
|
|
{
|
|
enum generateFunctionBody =
|
|
// [ref] ReturnType doIt(Parameters args) @attributes
|
|
q{
|
|
// When this function gets called, the this pointer isn't
|
|
// really a this pointer (no instance even really exists), but
|
|
// a function pointer that points to the function to be called.
|
|
// Cast it to the correct type and call it.
|
|
|
|
auto fp = castToF(&this);
|
|
return fp(args);
|
|
};
|
|
}
|
|
}
|
|
// Type information used by the generated code.
|
|
alias FuncInfo_doIt = FuncInfo!(F);
|
|
|
|
// Generate the member function doIt().
|
|
mixin( MemberFunctionGenerator!(GeneratingPolicy!())
|
|
.generateFunction!("FuncInfo_doIt", "doIt", F) );
|
|
}
|
|
|
|
/**
|
|
* Convert a callable to a delegate with the same parameter list and
|
|
* return type, avoiding heap allocations and use of auxiliary storage.
|
|
*
|
|
* Params:
|
|
* fp = a function pointer or an aggregate type with `opCall` defined.
|
|
* Returns:
|
|
* A delegate with the context pointer pointing to nothing.
|
|
*
|
|
* Example:
|
|
* ----
|
|
* void doStuff() {
|
|
* writeln("Hello, world.");
|
|
* }
|
|
*
|
|
* void runDelegate(void delegate() myDelegate) {
|
|
* myDelegate();
|
|
* }
|
|
*
|
|
* auto delegateToPass = toDelegate(&doStuff);
|
|
* runDelegate(delegateToPass); // Calls doStuff, prints "Hello, world."
|
|
* ----
|
|
*
|
|
* BUGS:
|
|
* $(UL
|
|
* $(LI Does not work with `@safe` functions.)
|
|
* $(LI Ignores C-style / D-style variadic arguments.)
|
|
* )
|
|
*/
|
|
auto toDelegate(F)(auto ref F fp)
|
|
if (isCallable!(F))
|
|
{
|
|
static if (is(F == delegate))
|
|
{
|
|
return fp;
|
|
}
|
|
else static if (is(typeof(&F.opCall) == delegate)
|
|
|| (is(typeof(&F.opCall) V : V*) && is(V == function)))
|
|
{
|
|
return toDelegate(&fp.opCall);
|
|
}
|
|
else
|
|
{
|
|
alias DelType = typeof(&(new DelegateFaker!(F)).doIt);
|
|
|
|
static struct DelegateFields {
|
|
union {
|
|
DelType del;
|
|
//pragma(msg, typeof(del));
|
|
|
|
struct {
|
|
void* contextPtr;
|
|
void* funcPtr;
|
|
}
|
|
}
|
|
}
|
|
|
|
// fp is stored in the returned delegate's context pointer.
|
|
// The returned delegate's function pointer points to
|
|
// DelegateFaker.doIt.
|
|
DelegateFields df;
|
|
|
|
df.contextPtr = cast(void*) fp;
|
|
|
|
DelegateFaker!(F) dummy;
|
|
auto dummyDel = &dummy.doIt;
|
|
df.funcPtr = dummyDel.funcptr;
|
|
|
|
return df.del;
|
|
}
|
|
}
|
|
|
|
///
|
|
@system unittest
|
|
{
|
|
static int inc(ref uint num) {
|
|
num++;
|
|
return 8675309;
|
|
}
|
|
|
|
uint myNum = 0;
|
|
auto incMyNumDel = toDelegate(&inc);
|
|
auto returnVal = incMyNumDel(myNum);
|
|
assert(myNum == 1);
|
|
}
|
|
|
|
@system unittest // not @safe due to toDelegate
|
|
{
|
|
static int inc(ref uint num) {
|
|
num++;
|
|
return 8675309;
|
|
}
|
|
|
|
uint myNum = 0;
|
|
auto incMyNumDel = toDelegate(&inc);
|
|
int delegate(ref uint) dg = incMyNumDel;
|
|
auto returnVal = incMyNumDel(myNum);
|
|
assert(myNum == 1);
|
|
|
|
interface I { int opCall(); }
|
|
class C: I { int opCall() { inc(myNum); return myNum;} }
|
|
auto c = new C;
|
|
auto i = cast(I) c;
|
|
|
|
auto getvalc = toDelegate(c);
|
|
assert(getvalc() == 2);
|
|
|
|
auto getvali = toDelegate(i);
|
|
assert(getvali() == 3);
|
|
|
|
struct S1 { int opCall() { inc(myNum); return myNum; } }
|
|
static assert(!is(typeof(&s1.opCall) == delegate));
|
|
S1 s1;
|
|
auto getvals1 = toDelegate(s1);
|
|
assert(getvals1() == 4);
|
|
|
|
struct S2 { static int opCall() { return 123456; } }
|
|
static assert(!is(typeof(&S2.opCall) == delegate));
|
|
S2 s2;
|
|
auto getvals2 =&S2.opCall;
|
|
assert(getvals2() == 123456);
|
|
|
|
/* test for attributes */
|
|
{
|
|
static int refvar = 0xDeadFace;
|
|
|
|
static ref int func_ref() { return refvar; }
|
|
static int func_pure() pure { return 1; }
|
|
static int func_nothrow() nothrow { return 2; }
|
|
static int func_property() @property { return 3; }
|
|
static int func_safe() @safe { return 4; }
|
|
static int func_trusted() @trusted { return 5; }
|
|
static int func_system() @system { return 6; }
|
|
static int func_pure_nothrow() pure nothrow { return 7; }
|
|
static int func_pure_nothrow_safe() pure nothrow @safe { return 8; }
|
|
|
|
auto dg_ref = toDelegate(&func_ref);
|
|
int delegate() pure dg_pure = toDelegate(&func_pure);
|
|
int delegate() nothrow dg_nothrow = toDelegate(&func_nothrow);
|
|
int delegate() @property dg_property = toDelegate(&func_property);
|
|
int delegate() @safe dg_safe = toDelegate(&func_safe);
|
|
int delegate() @trusted dg_trusted = toDelegate(&func_trusted);
|
|
int delegate() @system dg_system = toDelegate(&func_system);
|
|
int delegate() pure nothrow dg_pure_nothrow = toDelegate(&func_pure_nothrow);
|
|
int delegate() @safe pure nothrow dg_pure_nothrow_safe = toDelegate(&func_pure_nothrow_safe);
|
|
|
|
//static assert(is(typeof(dg_ref) == ref int delegate())); // [BUG@DMD]
|
|
|
|
assert(dg_ref() == refvar);
|
|
assert(dg_pure() == 1);
|
|
assert(dg_nothrow() == 2);
|
|
assert(dg_property() == 3);
|
|
assert(dg_safe() == 4);
|
|
assert(dg_trusted() == 5);
|
|
assert(dg_system() == 6);
|
|
assert(dg_pure_nothrow() == 7);
|
|
assert(dg_pure_nothrow_safe() == 8);
|
|
}
|
|
/* test for linkage */
|
|
{
|
|
struct S
|
|
{
|
|
extern(C) static void xtrnC() {}
|
|
extern(D) static void xtrnD() {}
|
|
}
|
|
auto dg_xtrnC = toDelegate(&S.xtrnC);
|
|
auto dg_xtrnD = toDelegate(&S.xtrnD);
|
|
static assert(! is(typeof(dg_xtrnC) == typeof(dg_xtrnD)));
|
|
}
|
|
}
|
|
|
|
/**
|
|
Forwards function arguments while keeping `out`, `ref`, and `lazy` on
|
|
the parameters.
|
|
|
|
Params:
|
|
args = a parameter list or an $(REF AliasSeq,std,meta).
|
|
Returns:
|
|
An `AliasSeq` of `args` with `out`, `ref`, and `lazy` saved.
|
|
*/
|
|
template forward(args...)
|
|
{
|
|
import core.lifetime : fun = forward;
|
|
alias forward = fun!args;
|
|
}
|
|
|
|
///
|
|
@safe unittest
|
|
{
|
|
class C
|
|
{
|
|
static int foo(int n) { return 1; }
|
|
static int foo(ref int n) { return 2; }
|
|
}
|
|
|
|
// with forward
|
|
int bar()(auto ref int x) { return C.foo(forward!x); }
|
|
|
|
// without forward
|
|
int baz()(auto ref int x) { return C.foo(x); }
|
|
|
|
int i;
|
|
assert(bar(1) == 1);
|
|
assert(bar(i) == 2);
|
|
|
|
assert(baz(1) == 2);
|
|
assert(baz(i) == 2);
|
|
}
|
|
|
|
///
|
|
@safe unittest
|
|
{
|
|
void foo(int n, ref string s) { s = null; foreach (i; 0 .. n) s ~= "Hello"; }
|
|
|
|
// forwards all arguments which are bound to parameter tuple
|
|
void bar(Args...)(auto ref Args args) { return foo(forward!args); }
|
|
|
|
// forwards all arguments with swapping order
|
|
void baz(Args...)(auto ref Args args) { return foo(forward!args[$/2..$], forward!args[0..$/2]); }
|
|
|
|
string s;
|
|
bar(1, s);
|
|
assert(s == "Hello");
|
|
baz(s, 2);
|
|
assert(s == "HelloHello");
|
|
}
|
|
|
|
///
|
|
@safe unittest
|
|
{
|
|
struct X {
|
|
int i;
|
|
this(this)
|
|
{
|
|
++i;
|
|
}
|
|
}
|
|
|
|
struct Y
|
|
{
|
|
private X x_;
|
|
this()(auto ref X x)
|
|
{
|
|
x_ = forward!x;
|
|
}
|
|
}
|
|
|
|
struct Z
|
|
{
|
|
private const X x_;
|
|
this()(auto ref X x)
|
|
{
|
|
x_ = forward!x;
|
|
}
|
|
this()(auto const ref X x)
|
|
{
|
|
x_ = forward!x;
|
|
}
|
|
}
|
|
|
|
X x;
|
|
const X cx;
|
|
auto constX = (){ const X x; return x; };
|
|
static assert(__traits(compiles, { Y y = x; }));
|
|
static assert(__traits(compiles, { Y y = X(); }));
|
|
static assert(!__traits(compiles, { Y y = cx; }));
|
|
static assert(!__traits(compiles, { Y y = constX(); }));
|
|
static assert(__traits(compiles, { Z z = x; }));
|
|
static assert(__traits(compiles, { Z z = X(); }));
|
|
static assert(__traits(compiles, { Z z = cx; }));
|
|
static assert(__traits(compiles, { Z z = constX(); }));
|
|
|
|
|
|
Y y1 = x;
|
|
// ref lvalue, copy
|
|
assert(y1.x_.i == 1);
|
|
Y y2 = X();
|
|
// rvalue, move
|
|
assert(y2.x_.i == 0);
|
|
|
|
Z z1 = x;
|
|
// ref lvalue, copy
|
|
assert(z1.x_.i == 1);
|
|
Z z2 = X();
|
|
// rvalue, move
|
|
assert(z2.x_.i == 0);
|
|
Z z3 = cx;
|
|
// ref const lvalue, copy
|
|
assert(z3.x_.i == 1);
|
|
Z z4 = constX();
|
|
// const rvalue, copy
|
|
assert(z4.x_.i == 1);
|
|
}
|