[lclcontext] Any interest in Pythonesque "with-as" statement in C++.
I think Python's concept of Context and Context Managers useful and I've adapted, to the best of my abilities, a similar concept in C++. For those not familiar with this concept, I'll quote a brief snippet from the documentation: "Simply stated, this library enables the use of the Pythonesque with-statement construct in C++. More broadly, this library seeks to formalize a generalized version of a subset of the RAII (Resource Acquisition is Initialization) idiom that, for the lack of preexisting terms, I shall refer here to as the STEP (Scope Triggered Event Processing) idiom. The STEP idiom is the commonly occurring use case where for a given block of code some user specified action(s) must execute on entry and on exit, and the failure to do so will result in some deterministic behavior." You can find the library here: https://github.com/m-w-a/WG Documentation is here: https://github.com/m-w-a/WG/tree/master/Local/Docs (In the same repository I've also redid Boost's local_function, but that the subject of another posting.) If there is enough interest from the community for such a library then I will go ahead and "Boostify" it.
I think Python's concept of Context and Context Managers useful and I've adapted, to the best of my abilities, a similar concept in C++. For those not familiar with this concept, I'll quote a brief snippet from the documentation:
"Simply stated, this library enables the use of the Pythonesque with-statement construct in C++. More broadly, this library seeks to formalize a generalized version of a subset of the RAII (Resource Acquisition is Initialization) idiom that, for the lack of preexisting terms, I shall refer here to as the STEP (Scope Triggered Event Processing) idiom. The STEP idiom is the commonly occurring use case where for a given block of code some user specified action(s) must execute on entry and on exit, and the failure to do so will result in some deterministic behavior."
You can find the library here:
Documentation is here:
https://github.com/m-w-a/WG/tree/master/Local/Docs
(In the same repository I've also redid Boost's local_function, but that the subject of another posting.)
If there is enough interest from the community for such a library then I will go ahead and "Boostify" it.
i'm sure you already know this but C++14's initialized lambda captures basically are python's with-as (albeit with C++'s normal syntax tax). struct foo { foo() { std::cout << "foo()" << std::endl; ~foo() { std::cout << "~foo()" << std::endl; }; auto make_foo() -> foo { return {}; } auto main() -> int { std::cout << "before" << std::endl; [f = make_foo()]() { std::cout << "during" << std::endl; }(); std::cout << "after" << std::endl; } With perfect forwarding we could even achieve a nicer syntax without any macros: with(make_foo(), [](auto f) { // ... });
On Mon, 17 Aug 2015 01:59:08 -0700, Sam Kellett
I think Python's concept of Context and Context Managers useful and I've adapted, to the best of my abilities, a similar concept in C++. For those not familiar with this concept, I'll quote a brief snippet from the documentation:
"Simply stated, this library enables the use of the Pythonesque with-statement construct in C++. More broadly, this library seeks to formalize a generalized version of a subset of the RAII (Resource Acquisition is Initialization) idiom that, for the lack of preexisting terms, I shall refer here to as the STEP (Scope Triggered Event Processing) idiom. The STEP idiom is the commonly occurring use case where for a given block of code some user specified action(s) must execute on entry and on exit, and the failure to do so will result in some deterministic behavior."
You can find the library here:
Documentation is here:
https://github.com/m-w-a/WG/tree/master/Local/Docs
(In the same repository I've also redid Boost's local_function, but that the subject of another posting.)
If there is enough interest from the community for such a library then I will go ahead and "Boostify" it.
i'm sure you already know this but C++14's initialized lambda captures basically are python's with-as (albeit with C++'s normal syntax tax).
I didn't know that. I was only targeting C++03/C++11.
I didn't know that. I was only targeting C++03/C++11.
This should work with C++11:
template
On Mon, 17 Aug 2015 09:48:55 -0700, Sam Kellett
I didn't know that. I was only targeting C++03/C++11.
This should work with C++11:
template
void with(T &&t, F &&fn) { fn(std::forward<T>(t)); } with(make_foo(), [](foo &&f) { // do things with foo. }); // foo is destroyed.
Don't think I can help w/r/t C++03 though, the lack of lambdas is a killer.
One thing this method doesn't do is automatically determine if the scope exit prematurely.
This should work with C++11:
template
void with(T &&t, F &&fn) { fn(std::forward<T>(t)); } with(make_foo(), [](foo &&f) { // do things with foo. }); // foo is destroyed.
Don't think I can help w/r/t C++03 though, the lack of lambdas is a killer.
One thing this method doesn't do is automatically determine if the scope exit prematurely.
hmm... scanning your documentation do you mean the scope_completed flag?
ok so if i understand correctly you're saying that foo could be a
transaction, and when foo is destructed you either want to commit or
rollback depending on whether or not the lambda succeeded? interesting...
an easy thing to do is an overload of with for objects of T that has an
on_exit method to expect a boolean lambda and call the on_exit callback
with the result of the lambda.
namespace detail {
// for types that can handle failure
template
On 08/17/2015 11:59 AM, Sam Kellett wrote:
I think Python's concept of Context and Context Managers useful and I've adapted, to the best of my abilities, a similar concept in C++. For those not familiar with this concept, I'll quote a brief snippet from the documentation:
"Simply stated, this library enables the use of the Pythonesque with-statement construct in C++. More broadly, this library seeks to formalize a generalized version of a subset of the RAII (Resource Acquisition is Initialization) idiom that, for the lack of preexisting terms, I shall refer here to as the STEP (Scope Triggered Event Processing) idiom. The STEP idiom is the commonly occurring use case where for a given block of code some user specified action(s) must execute on entry and on exit, and the failure to do so will result in some deterministic behavior."
You can find the library here:
Documentation is here:
https://github.com/m-w-a/WG/tree/master/Local/Docs
(In the same repository I've also redid Boost's local_function, but that the subject of another posting.)
If there is enough interest from the community for such a library then I will go ahead and "Boostify" it.
i'm sure you already know this but C++14's initialized lambda captures basically are python's with-as (albeit with C++'s normal syntax tax).
struct foo { foo() { std::cout << "foo()" << std::endl; ~foo() { std::cout << "~foo()" << std::endl; };
auto make_foo() -> foo { return {}; }
auto main() -> int { std::cout << "before" << std::endl; [f = make_foo()]() { std::cout << "during" << std::endl; }(); std::cout << "after" << std::endl; }
With perfect forwarding we could even achieve a nicer syntax without any macros:
with(make_foo(), [](auto f) { // ... });
It's not the same. There is no way to conditionally return from the enclosing scope from the lambda: with(make_foo(), [](auto f) { if (!f) { return; } // ... }); is different from the python with/as construct.
participants (3)
-
Avi Kivity -
Mostafa -
Sam Kellett