std.bind

Jump to: bind _0 _1 _2 _3 _4 _5 _6 _7 _8 _9 Tuple appendT append prependT prepend concatT type value tuple isTypeTuple minNumArgs BoundFunc bindAlias
Bind function arguments to functions.

References:
boost::bind

Authors:
Tomasz Stachowiak

Date:
November 28, 2006

const DynArg!(0) _0;
const DynArg!(1) _1;
const DynArg!(2) _2;
const DynArg!(3) _3;
const DynArg!(4) _4;
const DynArg!(5) _5;
const DynArg!(6) _6;
const DynArg!(7) _7;
const DynArg!(8) _8;
const DynArg!(9) _9;
    When passed to the 'bind' function, they will mark dynamic params - ones that aren't statically bound In boost, they're called _1, _2, _3, etc.. here _0, _1, _2, ...
当传递给绑定功能，他们将标记动态 params-那些不静态绑定 在推动，他们被调用 _ 1、 _2、 _3 等... 在这里 _0，_ 1，_2，...

struct Tuple(T...);
    A simple tuple struct with some basic operations
与一些基本的操作的简单的元组结构

    template appendT(X)
        Statically yields a tuple type with an extra element added at its end
与一个额外的元素，在其最终添加静态生成一个元组类型

    template append(X)
        Yields a tuple with an extra element added at its end
与一个额外的元素，在其最终添加产生一个元组

        appendT!(X) append(X x);
            Yields a tuple with an extra element added at its end
与一个额外的元素，在其最终添加产生一个元组

    template prependT(X)
        Statically yields a tuple type with an extra element added at its beginning
与一个额外的元素，在其开始添加静态生成一个元组类型

    template prepend(X)
        Yields a tuple with an extra element added at its beginning
与一个额外的元素，在其开始添加产生一个元组

        prependT!(X) prepend(X x);
            Yields a tuple with an extra element added at its beginning
与一个额外的元素，在其开始添加产生一个元组

    template concatT(T...)
        Statically concatenates this tuple type with another tuple type
静态连接此元组类型与另一个元组类型

struct Tuple();
    An empty tuple struct
一个空元组结构

    alias type;
        an empty built-in tuple
一个空的内置元组

    alias value;
        an empty built-in tuple
一个空的内置元组

Tuple!(T) tuple(T...)(T t);
    Dynamically create a tuple from the given items
动态创建一个   从给定项的  元组

template isTypeTuple(T)
    Checks whether a given type is the Tuple struct of any length
检查给定的类型是否任何长度的元组结构

template minNumArgs(alias fn,fnT = typeof(&fn))
    Finds the minimal number of arguments a given function needs to be provided
查找给定的函数需要提供的参数的最小数目

class BoundFunc(FT,alias FAlias_,AllBoundArgs_);
    A context for bound/curried functions
咖喱绑定/函数的上下文

typeof(new BoundFunc!(FT,NullAlias,Tuple!(ArgList))) bind(FT, ArgList...)(FT fp, ArgList args);
    bind() can curry or "bind" arguments of a function, producing a different function which requires less parameters, or a different order of parameters. It also allows function composition.
绑定 () 可以咖喱或"   绑定 "的一个函数生产不同的功能，需要较少的参数，参数 一个不同的或命令参数。 它还允许函数组成。

    The syntax of a bind() call is:
语法一    绑定  () 调用：

    bind(function or delegate pointer { , argument });
绑定 函数或委托指针 { 参数 }） ；

    argument can be one of:参数  可以是之一：

        * static/bound argument (an immediate value)
          静态/绑定参数 （一个实时值）
        * another bound function object
          另一个绑定函数对象
        * dynamic argument, of the form _[0-9], e.g. _0, _3 or _9
          窗体 _ [0-9] 例如 _0、 _3 或 _9 的动态参数

    The result is a function object, which can be called using call(), func() or opCall(). There also exists a convenience function, ptr() which returns a delegate to call/func/opCall
结果是可以使用 call()、 func() 或 opCall() 调用的函数对象。 此外存在一个方便的函数返回到调用/func/opCall 的委托的 ptr()

    The resulting delegate accepts exactly as many parameters as many distinct dynamic arguments were used.
结果委托接受完全一样多参数，很多不同的动态参数使用。

    - bind(&foo, _0, _1) // will yield a delegate accepting two parameters
                             将产量接受两个参数的委托
    - bind(&foo, _1, _0) // will yield a delegate accepting two parameters
                             将产量接受两个参数的委托
    - bind(&bar, _0, _1, _2, _0) // will yield a delegate accepting three parameters                         
                                 将产量接受三个参数的委托


    The types of dynamic parameters are extracted from the bound function itself and when necessary, type negotiation is performed. For example, binding a function
动态参数的类型提取从本身的绑定功能和有需要时, 键入谈判 执行。
例如绑定一个函数

    void foo(int a, long b)

    // with:
    bind(&foo, _0, _0)

    will result in a delegate accepting a single, optimal parameter type. The best type is computed using std.typetuple.DerivedToFront, so in case of an int and a long, long will be selected. Generally, bind will try to find a type that can be implicitly converted to all the other types a given dynamic parameter uses.
会接受一个单、 优化参数类型的委托。 最佳的类型被计算 使用 std.typetuple.DerivedToFront，所以例 int 和很长一段长时间将被选定。 通常，   绑定  将尝试查找 可以隐式转换为所有其他类型给定的动态参数的类型使用。

注意：
    Note:
    in case of numeric types, an explicit, but transparent (to the user) cast will be performed
数值类型的情况下显式，但透明 (用户) 的强制转换将会执行

    Function composition works intuitively:
功能组成直观地工作：

    bind(&f1, bind(&f2, _0))

    which will yield a delegate, that takes the argument, calls f2, then uses the return value of f2 to call f1. Mathematically speaking, it will yield a function composition:
会产生一个接受该的参数的委托调用 f2，然后使用 f2 的返回值调用 f1。 数学 说，它会生成函数组成：

    f1(f2(_0))

    When one function is composed multiple times, it will be called multiple times - Bind does no lazy evaluation, so
当一个函数由多次时，它会被调用多次-Bind 所以并没有懒惰的评价

    bind(&f3, bind(&f4, _0), bind(&f4, _0))

    will produce a delegate, which, upon calling, will invoke f4 two times to evaluate the arguments for f3 and then call f3
将产生委托，电话后, 将调用 f4 两次评估 f3 参数，然后调用 f3

    One another feature that bind() supports is automatic tuple expansion. It means that having functions:
另一个特征， 绑定 () 支持是自动的元组扩展。 它意味着该函数：

    void foo(int a, int b)
    Tuple!(int, int) bar()

    Allows them to be bound by writing:允许他们受写：

    bind(&foo, bind(&bar))
    // or
    bind(&foo, tuple(23, 45))

template bindAlias(alias FT)
    bindAlias() is similar to bind(), but it's more powerful. Use bindAlias() rather than bind() where possible.
类似于 bind()，但这是更强大。 使用    bindAlias  ()，而不是 bind() 在可能的情况下。
    The syntax is:语法是：

    bindAlias!(Function)(argument, argument, argument, argument, ...);

    bindAlias takes advantage of using aliases directly, thus being able to extract default values from functions and not forcing the user to bind them. It doesn't, however mean that the resulting delegate can be called, omitting some of its parameters. It only means that these arguments that have default values in the function provided to bindAlias don't have to be bound explicitly.
直接使用别名，因此能够从函数中提取默认值并不强制用户利用  bindAlias  若要将它们绑定。 它不，但表示结果委托可以调用，省略参数的一些及其参数。 它只意味着这些 在函数中提供有默认值的参数    bindAlias  不必将显式绑定。

    Additionally, bindAlias takes care of functions with out/inout parameters, by converting them to pointers internally. A function like:
此外，   bindAlias  照顾使用出 inout 的参数的函数的通过将他们在内部转换为指针。 像一个函数：

    void foo(inout a)

    can be bound using:可绑定使用：

    int x;
    bindAlias!(foo)(&x);

    Note:注意：

    there is no bind-time check for reference nullness, there is however a call-time check on all references which can be disabled by using version=BindNoNullCheck or compiling in release mode.
有是引用 nullness 没有绑定时检查，但是调用时检查所有引用，可以禁用对 使用版本 = BindNoNullCheck 或发布模式中编译。