Skip to content

Instantly share code, notes, and snippets.

View RedBeard0531's full-sized avatar

Mathias Stearn RedBeard0531

144 followers · 0 following
  • Copenhagen
View GitHub Profile
@RedBeard0531
RedBeard0531 / semi_lazy.cpp
Created November 18, 2018 18:13
template <typename T>
struct semi_lazy {
struct promise_type {
std::optional<T> val;
std::function<void()> defer;
suspend_never initial_suspend() { return {}; }
suspend_always final_suspend() { return {}; }
void return_value(T v) {
val.emplace(std::move(v));
@RedBeard0531
RedBeard0531 / finally_lazy_shared.cpp
Created September 21, 2018 15:05
#include <type_traits>
#include <future>
#include <functional>
template <typename T>
struct expected {
expected(const T&) {}
};
template <typename T>
struct Promise {
@RedBeard0531
RedBeard0531 / sender_reciever_concepts.cpp
Created August 23, 2018 02:06
#include <utility>
#include <exception>
// This is probably customizable
using Error = std::exception_ptr;
template <typename R, typename T>
concept ValueReciever = requires (T a, R r) {
std::move(r).value(std::move(a));
};
@RedBeard0531
RedBeard0531 / fallibility.cpp
Created July 20, 2018 03:19
template <typename T>
struct ValueReceiver {
virtual void value(T) = 0;
};
template <typename T>
struct ValueOrErrorReceiver : ValueReceiver<T> {
virtual void value(T) = 0;
virtual void error(std::exception_ptr) = 0;
};
@RedBeard0531
RedBeard0531 / another_take_on_bulk.cpp
Last active July 20, 2018 05:22
#include <cstdlib>
#include <boost/optional.hpp>
#include <string>
using boost::optional;
template <typename T>
struct Future{};
template <typename T>
@RedBeard0531
RedBeard0531 / lazy_futures.h
Last active July 11, 2018 17:55
#include <functional>
#include <exception>
#include <optional>
#include <memory>
#include <cassert>
#include <atomic>
#include <iostream>
#include <mutex>
#include <condition_variable>
#include <thread>
@RedBeard0531
RedBeard0531 / include_magic.md
Last active June 13, 2018 18:49
Proposal for making third-party libs easier to use

Magic #includes (and eventually imports)

By: Mathias Stearn
Please provide feedback either by email, or on #sg15-tooling in cpplang.slack.com.

This is an alternative to a proposal that I'm sure was offered with good intentions, but that I and several others shuddered at the sight of:




  


  




    


          
    

      

        
        

          

              @RedBeard0531
          

          

            
                RedBeard0531
                / future_traits.cpp
            
            

              Last active
              April 26, 2018 15:53
            

              
                Future then() traits
              
          

        

      

        

  

    
    


        



  


  

        

          
          #include <tuple>
        

        

          
          #include <optional>
        

        

          
          #include <functional>
        

        

          
          

        

        

          
          /////////////////////
        

        

          
          /// PRIMARY TEMPLATES
        

        

          
          

        

        

          
          template <typename T>
        

        

          
          struct future_then_return_traits {
        

        

          
              // Future::then(cb) for a callback that returns T,
        

  





    


  




    


          
    

      

        
        

          

              @RedBeard0531
          

          

            
                RedBeard0531
                / example_1.cpp
            
            

              Created
              April 14, 2018 20:31
            

              
                Examples of broken release sequences
              
          

        

      

        

  

    
    


        



  


  

        

          
          enum State {INIT, PHASE2, DONE};
        

        

          
          

        

        

          
          std::atomic<State> state{INIT};
        

        

          
          int non_atomic = 0; // placeholder for actual data.
        

        

          
          

        

        

          
          auto phase1 = std::thread([&] {
        

        

          
              non_atomic = 1;
        

        

          
              state.store(PHASE2, std::memory_order_release);
        

        

          
          

        

        

          
              auto phase2 = std::thread([&] {
        

  





    


  




    


          
    

      

        
        

          

              @RedBeard0531
          

          

            
                RedBeard0531
                / P0911R0.md
            
            

              Created
              March 8, 2018 02:07
            

          

        

      

        

  

      

    




Document Number:
P0911R0






Date:
2018-02-03




Project:
Programming Language C++, CWG, LWG




Revises:
none




Reply to:
gorn@microsoft.com






Rebase the Coroutines TS onto the C++17 Standard