220 5525 <81385547-bb12-4ae6-9d12-82aaeb4b5ba0@isocpp.org> article Path: news.gmane.org!not-for-mail From: tomaszkam@gmail.com Newsgroups: gmane.comp.lang.c++.isocpp.proposals Subject: Grouping placeholders for bind Date: Tue, 23 Jul 2013 13:40:57 -0700 (PDT) Lines: 232 Approved: news@gmane.org Message-ID: <81385547-bb12-4ae6-9d12-82aaeb4b5ba0@isocpp.org> Reply-To: std-proposals@isocpp.org NNTP-Posting-Host: plane.gmane.org Mime-Version: 1.0 Content-Type: multipart/alternative; boundary="----=_Part_756_14761284.1374612057352" X-Trace: ger.gmane.org 1374612060 1959 80.91.229.3 (23 Jul 2013 20:41:00 GMT) X-Complaints-To: usenet@ger.gmane.org NNTP-Posting-Date: Tue, 23 Jul 2013 20:41:00 +0000 (UTC) To: std-proposals@isocpp.org Original-X-From: std-proposals+bncBDNPVXXG6IGBBWWUXOHQKGQECFAAYIA@isocpp.org Tue Jul 23 22:41:01 2013 Return-path: Envelope-to: gclcip-std-proposals@m.gmane.org Original-Received: from mail-qe0-f69.google.com ([209.85.128.69]) by plane.gmane.org with esmtp (Exim 4.69) (envelope-from ) id 1V1jOF-0001S0-8U for gclcip-std-proposals@m.gmane.org; Tue, 23 Jul 2013 22:40:59 +0200 Original-Received: by mail-qe0-f69.google.com with SMTP id a11sf10874851qen.0 for ; Tue, 23 Jul 2013 13:40:58 -0700 (PDT) DKIM-Signature: v=1; a=rsa-sha256; c=relaxed/relaxed; d=gmail.com; s=20120113; h=x-beenthere:date:from:to:message-id:subject:mime-version :x-original-sender:reply-to:precedence:mailing-list:list-id :x-google-group-id:list-post:list-help:list-archive:list-subscribe :list-unsubscribe:content-type; bh=RLD3MpZnbN+zviNkk8gKZL3RJ5O7NQk9OnAUJK7YuiE=; b=BK2oRRs14sOhxKq4xPSRNUnihvrZTquvbGe56KjmWYFeqjR2mOftaSQy4MJPlRx47f pNX3DqgZq+RjHDA6auV5LAO8AAvzmnU71Sqbug+iTx0KrMns5QIOOfie0da79ke8OYtc b2c/kjsrnrof+HFj89nEyxp9Zed0GEzo0uN/p2pLGEkE/1l637Rbp/Wz5MXeWIMDQ9/8 8qUpLu8QcOFXd2P/XjlVv16TskZVgdYeuJRtaVJTZCylPuO1peieSbj2IfZPUEexQynM PZEY7E8V7nKvrIefpDdi1kkTGTDZR1Hk6I1MLvMgAhH0FkGtcjDZXp4kjBvbGjoo4nA/ nvFw== X-Received: by 10.236.62.132 with SMTP id y4mr15264537yhc.13.1374612058377; Tue, 23 Jul 2013 13:40:58 -0700 (PDT) X-BeenThere: std-proposals@isocpp.org Original-Received: by 10.49.82.101 with SMTP id h5ls613639qey.91.gmail; Tue, 23 Jul 2013 13:40:57 -0700 (PDT) X-Received: by 10.49.40.167 with SMTP id y7mr1357332qek.36.1374612057781; Tue, 23 Jul 2013 13:40:57 -0700 (PDT) X-Original-Sender: tomaszkam@gmail.com Precedence: list Mailing-list: list std-proposals@isocpp.org; contact std-proposals+owners@isocpp.org List-ID: X-Google-Group-Id: 399137483710 List-Post: , List-Help: , List-Archive: List-Subscribe: , List-Unsubscribe: , Xref: news.gmane.org gmane.comp.lang.c++.isocpp.proposals:5525 Archived-At: ------=_Part_756_14761284.1374612057352 Content-Type: text/plain; charset=ISO-8859-1 In the discussion of mem_fn with additional parameter Jonathan Wakely proposed the idea of new placeholder type named all, that will forward all of the arguments to the functor and suggested that it could be extended to more generic group placeholders. Example: auto f = std::bind(&A::foo, a, std::placeholders::all); Will create functor that will bind an object/pointer a with the function member pointer and forwards all supplied arguments to the functor, so: f(t1, t2, ..., tN) Will be equivalent to: a.foo(t1, t2, ..., tN) //I assumed a is an object in the example, but it will support anything that INVOKE does. I would like to share my thoughts on the approach how such placeholders can be defined in the extend-able manner (so the user can define its own group placeholders). 1. At this moment the standard defines the is_placeholder traits that provides both functionality: informs that the type placeholder and provides the number of forwarder argument. I would like to split that behavior, to 2 classes: a) is_placeholder would be used to determine if the type is placeholder b) placeholder_positions will provide zero (please see motivation bellow) or more index of argument to be forwarder (index should be 1based to uniform with standard bind). The second argument N would mean actual number of argument provided to invocation of the bind (so we cane genereate index of all arguments). The placeholder position should be derived from std::integer_sequence class in case when is_placeholder::value is true. c) to main the backward compatibility the, default implementation of placeholder_positions would be: template struct placeholder_positions : std::integer_sequence::value> {} so for the single argument placeholder, is_placeholder can be used in the same way as today, but bind depend only for placeholder_positions to get argument to forward. 2. There should be 2 group placeholders defined in the standard: a) _all, that will forward all arguments, definition using proposed specializations would be: template<> struct is_placeholder<_all> : std::true_type {}; template struct placeholder_positions<_all, N> : shift, 1> {} b) _from that will forward arguments all arguments form Nth. The _from should be ill formed if number of arguments is less than N. For exactly N-1 arguments there should be empty sequence generated - if there is need to be sure that at least N arguments, then _N, _from may be used. Implementation: template struct is_placeholder<_from> : std::true_type {}; template struct placeholder_positions<_all, ArgCount> : enable_if, N> {} c) The user can define its own placeholders group via specializations. 3. I would define new placeholder in the namespace std::placeholders, but that may lead to the some annoying problems to the user if there where named simply all and from. Most of the code that uses bind, looks like: using namespace std::placeholders; std::bind(f, _1, a, _2); While there is really low possibility to have variables named _1, _2, .... in the user code, there is pretty much a chance that the user code would define viarbles named all or from and cause the crash of bind. That it the reason I choosed _all and _from instead, which look pretty uniform with _1. Another solution would be to define it in the different namespace. What are you thoughts about this idea. -- --- You received this message because you are subscribed to the Google Groups "ISO C++ Standard - Future Proposals" group. To unsubscribe from this group and stop receiving emails from it, send an email to std-proposals+unsubscribe@isocpp.org. To post to this group, send email to std-proposals@isocpp.org. Visit this group at http://groups.google.com/a/isocpp.org/group/std-proposals/. ------=_Part_756_14761284.1374612057352 Content-Type: text/html; charset=ISO-8859-1 Content-Transfer-Encoding: quoted-printable In the discussion of mem_fn with additional para= meter Jonathan Wakely proposed the idea of new placeholder= type named all,
 that will forward all of the arguments to the fun= ctor and suggested that it could be extended to more generic group placehol= ders.
Example:
au= to f =3D std::bind(&A::foo, a, std::placeholders::all);
Will = create functor that will bind an object/pointer a with the function member = pointer and forwards all supplied arguments to the functor,
so:
f(t1, t2, ..., tN)Will be equivalent to:
a.foo(t1, t2, ..., tN)
//I assumed a is an objec= t in the example, but it will support anything that INVOKE does.

I w= ould like to share my thoughts on the approach how such placeholders can be= defined in the extend-able manner (so the user can define
its own group= placeholders).

1. At this moment the standard defines the is_placeh= older traits that provides both functionality: informs that the type placeh= older and provides
the number of forwarder argument. I would like to sp= lit that behavior, to 2 classes:
  a) is_placeholder<T> would= be used to determine if the type is placeholder
  b) placeholder_p= ositions<T,N> will provide zero (please see motivation bellow) or mor= e index of argument to be forwarder (index should be 1based to
 &nb= sp;    uniform with standard bind). The second argument N wo= uld mean actual number of argument provided to invocation of the bind (so w= e cane genereate
      index of all arguments). The = placeholder position should be derived from std::integer_sequence<std::s= ize_t, ...> class in case when is_placeholder<T>::value
  =   is true.
  c) to main the backward compatibility the, defaul= t implementation of placeholder_positions would = be:
  &nbs= p; template<typename T, std::size_t N>
    struct placeh= older_positions :
       std::integer_seq= uence<std::size_t, std::is_placeholder<T>::value>
 &nbs= p;  {}
      so for the single argu= ment placeholder, is_placeholder can be used in the same way as today, but = bind depend only for  placeholder_positions
  to get argument  to forward.

2. There should be 2 group pla= ceholders defined in the standard:
    a) _all, that will= forward all arguments, definition using proposed specializations would be:=
       template<>
   struct is_placeholder<_all> : std= ::true_type {};

   template<std::size_t N><= br>   struct placeholder_positions<_all, N>
&= nbsp;    : shift<std::make_integer_sequence<= ;std::size_t, N>, 1> {}
  b)  _from<N> that will forward arguments all argume= nts form Nth. The _from<N> should be ill formed if number of argument= s is less than N. For exactly N-1
        arguments = there should be empty sequence generated - if there is need to be sure that= at least N arguments, then _N, _from<N+1> may be used.
 &nbs= p;     Implementation:
<= span class=3D"_username">       template<std::size_t N>
   struct i= s_placeholder<_from<N>> : std::true_type {};
  
   template<std::size_t N>   struct placeholder_positions<_all, ArgCount>=
     : enable_if<ArgCount + 1 <=3D N,=     
     &= nbsp;           shift<= std::make_integer_sequence<std::size_t, ArgCount - N  + = 1>, N> {}
  c)= The user can define its own placeholders group via specializations.=

3. I would define new placeholder i= n the namespace std::placeholders, but that may lead to the some annoying p= roblems to the user if there where named simply
    all a= nd from. Most of the code that uses bind, looks like:
    using namespace std::placeholders;
&nb= sp;   std::bind(f, _1, a, _2);
    While= there is really low possibility to have variables named _1, _2, ... in the= user code, there is pretty much a chance that the user code would define v= iarbles
    named all or from and cause the crash of bind= ..  That it the reason I choosed _all and _from instead, which look pre= tty uniform with _1. Another solution would be
    to def= ine it in the different namespace.

What are you thoughts about this = idea.

--
 
---
You received this message because you are subscribed to the Google Groups &= quot;ISO C++ Standard - Future Proposals" group.
To unsubscribe from this group and stop receiving emails from it, send an e= mail to std-proposals+unsubscribe@isocpp.org.
To post to this group, send email to std-proposals@isocpp.org.
Visit this group at http://groups.google.com/a/isocpp.org/group/std-proposals/<= /a>.
 
 
------=_Part_756_14761284.1374612057352-- .