| Home | Libraries | People | FAQ | More

#### unfused_generic

##### Description

An n-ary Polymorphic Function Object adapter template for an unary Polymorphic Function Object target function. When called, its arguments are bundled to a Random Access Sequence of references that is passed to the target function. Non-const LValue arguments are transported as references to non-const, otherwise references to const are used.

The type of the target function is allowed to be const qualified or a reference. Const qualification is preserved and propagated appropriately (in other words, only const versions of `operator()` can be used if the target function object is const - or, in case the target function object is held by value, the adapter is const).

/functional/adapter/unfused_generic.hpp>

##### Synopsis

    template <class Function>
    class unfused_generic;

##### Template parameters

Parameter | Description | Default
--- | --- | ---
`Function` | An unary Polymorphic Function Object |

##### Model of

- Polymorphic Function Object
- Deferred Callable Object

Notation

`F`

  A possibly const qualified, unary Polymorphic Function Object type or reference type thereof

`f`

  An object convertible to `F`

`UG`

  The type `unfused_generic<F>`

`ug`

  An instance of `UG`, initialized with `f`

`a0`...`aN`

  Arguments to `ug`

##### Expression Semantics

Expression | Semantics
--- | ---
`UG(f)` | Creates a fused function as described above, initializes the target function with `f`.
`UG()` | Creates a fused function as described above, attempts to use `F`'s default constructor.
`ug(a0`...`aN)` | Calls `f` with a Sequence that contains references to the arguments `a0`...`aN`.

##### Example

    template <typename Function, typename T>
    class fused_bound_1st
    {
        typename traits::deduce<Function>::type fnc_deferred;
        typename traits::deduce<T>::type        xxx_bound;
    public:

        fused_bound_1st(Function deferred, T bound)
            : fnc_deferred(deferred), xxx_bound(bound)
        { }

        template <typename Sig>
        struct result;

        template <class Self, class Seq>
        struct result< Self(Seq) >
            : result_of::invoke< Function, typename result_of::push_front<
                typename remove_reference<Seq>::type, T>::type >
        { };

        template <class Seq>
        typename result< void(Seq) >::type operator()(Seq const & s) const
        {
            return invoke(fnc_deferred, push_front(s,xxx_bound));
        }
    };

    template <typename Function, typename T>
    unfused_generic< fused_bound_1st<Function,T> >
    bind_1st(Function f, T const & x)
    {
        return unfused_generic< fused_bound_1st<Function,T> >(
            fused_bound_1st<Function,T>(f,x) );
    }

    int test_func(int a, int b, int c)
    {
        return a+b+c;
    }

    void try_it()
    {
        assert(bind_1st(& test_func,3)(-2,-1) == 0);
        assert(bind_1st(std::plus<float>(), 1)(0.5f) == 1.5f);
    }

##### See also

- `unfused_lvalue_args`
- `unfused_rvalue_args`
- `unfused_typed`
- `deduce`
- `deduce_sequence`