diff --git a/include/rosa/support/csv/CSVWriter.hpp b/include/rosa/support/csv/CSVWriter.hpp
index 574806b..1c06bbb 100755
--- a/include/rosa/support/csv/CSVWriter.hpp
+++ b/include/rosa/support/csv/CSVWriter.hpp
@@ -1,152 +1,161 @@
 //===-- rosa/support/csv/CSVWriter.hpp --------------------------*- C++ -*-===//
 //
 //                                 The RoSA Framework
 //
 //===----------------------------------------------------------------------===//
 ///
 /// \file rosa/support/csv/CSVWriter.hpp
 ///
 /// \author David Juhasz (david.juhasz@tuwien.ac.at)
 ///
 /// \date 2017
 ///
 /// \brief Facitilities to write CSV files.
 ///
 //===----------------------------------------------------------------------===//
 
 #ifndef ROSA_SUPPORT_CSV_CSVWRITER_HPP
 #define ROSA_SUPPORT_CSV_CSVWRITER_HPP
 
 #include <iostream>
 #include <ostream>
 
 #include <tuple>
 
 namespace rosa {
 namespace csv {
 
 /// Provides facilities to write values into a CSV file.
 ///
 /// The writer emits a comma, the character `,`, between each written values.
 /// The resulted stream is a flat CSV file as it consists of onlyone row, no new
 /// line is emitted.
 ///
 /// \tparam T type of values to write
 template <typename T>
 class CSVWriter {
 public:
+  /// \defgroup CSVWriterTypedefs Typedefs of rosa::csv::CSVWriter
+  ///
+  /// Useful `typedef`s for writers.
+  ///
+  ///@{
+  typedef T value_type; ///< Type of values written
+  typedef T &reference; ///< Reference to the type written
+  ///@}
+
   /// Creates a new instance.
   ///
   /// \param [in,out] S output stream to write to
   ///
   /// \note The writer operates on non-binary outputs as long as \p S is in
   /// good state.
   CSVWriter(std::ostream &S)
       : Str(S.good() && !(S.flags() & std::ios::binary) ? &S : nullptr),
         IsFirst(true) {}
 
   /// Tells if the last operation was successful.
   ///
   /// \return if the last operation was successful
   bool good(void) const noexcept {
     return Str != nullptr;
   }
 
   /// Writes an entry to the output stream.
   ///
   /// The implementation does anything only if the last operation was
   /// successful. If so, \p V is written to \c rosa::csv::CSVWriter::Str.
   /// The emitted value is preceded with a comma if the actual call is not the
   /// first one for \p this object. Success of the operation is checked at the
   /// end.
   ///
   /// \param V value to write
   void write(const T &V) {
     if (Str) {
       if (!IsFirst) {
         *Str << ',';
       } else {
         IsFirst = false;
       }
       *Str << V;
       if (!Str->good()) {
         Str = nullptr;
       }
     }
   }
 
 private:
   std::ostream *Str; ///< Output stream to write to.
   bool IsFirst;      ///< Denotes if the next write would be the first one.
 };
 
 /// Writes a tuple of values into a CSV file
 ///
 /// \tparam Ts tpyes of values to write
 template <typename... Ts> class CSVTupleWriter {
 
 public:
     /// Creates a new instance.
     ///
     /// \param [in,out] S output stream to write to
     ///
     /// \note The writer operates on non-binary outputs as long as \p S is in
     /// good state.
     CSVTupleWriter(std::ostream &S)
         : Str(S.good() && !(S.flags() & std::ios::binary) ? &S : nullptr),
           IsFirst(true) {}
 
     /// Tells if the last operation was successful.
     ///
     /// \return if the last operation was successful
     bool good(void) const noexcept {
       return Str != nullptr;
     }
 
     template<size_t i = 0>
     void write(std::tuple<Ts...> values) {
         size_t size = 0;
         std::cout << "Writing tuple values into file" << std::endl;
         std::cout << "Tuple has ";
         std::cout << std::tuple_size<decltype (values)>::value;
         std::cout << " elements." << std::endl;
         size = std::tuple_size<decltype (values)>::value;
 
         std::cout << std::get<i>(values) << std::endl;
 
         if(Str){
             if constexpr(i+1 != sizeof...(Ts)){
                 *Str << std::get<i>(values) << " ,";
                 write<i+1>(values);
             }else if constexpr(i + 1 == sizeof...(Ts)){
                 *Str << std::get<i>(values) << '\n';
             }
         }
     }
 
 private:
     std::ostream *Str; ///< Output stream to write to.
     bool IsFirst;      ///< Denotes if the next write would be the first one.
 
 };
 
 /// Writes a value to a CSV file with \c rosa::csv::CSVWriter.
 ///
 /// \see rosa::csv::CSVWriter
 ///
 /// \tparam T type of value to write
 ///
 /// \param [in,out] W object to write with
 /// \param V value to write
 ///
 /// \return \p W after writing \p V with it
 template <typename T>
 CSVWriter<T> &operator<<(CSVWriter<T> &W, const T& V) {
   W.write(V);
   return W;
 }
 
 } // End namespace csv
 } // End namespace rosa
 
 #endif // ROSA_SUPPORT_CSV_CSVWRITER_HPP
diff --git a/include/rosa/support/iterator/split_tuple_iterator.hpp b/include/rosa/support/iterator/split_tuple_iterator.hpp
index f64b346..3d1b9e9 100644
--- a/include/rosa/support/iterator/split_tuple_iterator.hpp
+++ b/include/rosa/support/iterator/split_tuple_iterator.hpp
@@ -1,427 +1,431 @@
 //===-- rosa/support/iterator/split_tuple_iterator.hpp ----------*- C++ -*-===/
 //
 //                                 The RoSA Framework
 //
 //===----------------------------------------------------------------------===/
 ///
 /// \file rosa/support/iterator/split_tuple_iterator.hpp
 ///
 /// \authors David Juhasz (david.juhasz@tuwien.ac.at)
 ///
 /// \date 2019
 ///
 /// \brief Facilities to split iterators of \c std::tuple into iterators of
 /// their elements.
 ///
 //===----------------------------------------------------------------------===/
 
 #ifndef ROSA_SUPPORT_ITERATOR_SPLIT_TUPLE_ITERATOR_HPP
 #define ROSA_SUPPORT_ITERATOR_SPLIT_TUPLE_ITERATOR_HPP
 
 #include "rosa/support/debug.hpp"
 #include "rosa/support/sequence.hpp"
 
 #include <memory>
 #include <tuple>
 #include <type_traits>
 #include <queue>
 
 namespace rosa {
 namespace iterator {
 
 /// Anonymous namespace providing implementation for splitting tuple iterators;
 /// consider it private.
 namespace {
 
 /// Iterator of values provided by a buffer based on an index
 ///
 /// \tparam TB buffer providing values to iterate
 /// \tparam I index of the values to iterator from \p TB
 ///
 /// \note \p TB is expected to implemnet an interface matching that of \c
 /// TupleIteratorBuffer.
 template <typename TB, size_t I>
 class SplittedElementIterator {
 public:
   /// Type alias for the values the iterator iterates.
   using T = typename TB::template element_type<I>;
 
   /// \defgroup SplittedElementIteratorTypedefs Typedefs of 
   /// \c SplittedElementIterator
   ///
   /// Standard `typedef`s for iterators.
   ///
   ///@{
   typedef std::input_iterator_tag
       iterator_category;               ///< Category of the iterator.
   typedef T value_type;                ///< Type of values iterated over.
   typedef std::size_t difference_type; ///< Type to identify distance.
   typedef T *pointer;                  ///< Pointer to the type iterated over.
   typedef T &reference;                ///< Reference to the type iterated ver.
   ///@}
 
   /// Creates a new instance.
   ///
   /// \param Buffer buffer providing values for \p this object
   ///
   /// \note \p Buffer is captured as a \c std::shared_ptr because it is shared
   /// among iterators for its element positions.
   SplittedElementIterator(std::shared_ptr<TB> Buffer)
       : Buffer(Buffer), Value() {
     // \c Value is initialized empty so the first incrementation here will read
     // the first value.
     ++(*this);
   }
 
   /// Creates an empty new instance.
   SplittedElementIterator(void) noexcept : Buffer(), Value() {}
 
   /// Pre-increment operator.
   ///
   /// The implementation reads the next value from \c Buffer. If no more values
   /// can be provided by \c Buffer, \p this object becomes empty and the
   /// operator has no further effect.
   ///
   /// \return \p this object after incrementing it.
   SplittedElementIterator &operator++() {
     if (Buffer->template hasMore<I>()) {
       Value = Buffer->template next<I>();
     } else {
       // Reached end of range, remove reference of \c Buffer.
       Buffer.reset();
     }
     return *this;
   }
 
   /// Post-increment operator.
   ///
   /// The implementation uses the pre-increment operator and returns a copy of
   /// the original state of \p this object.
   ///
   /// \return \p this object before incrementing it.
   SplittedElementIterator operator++(int) {
     SplittedElementIterator<TB, I> Tmp(*this);
     ++(*this);
     return Tmp;
   }
 
   /// Returns a constant reference to the current value.
   ///
   /// \note Should not dereference the iterator when it is empty.
   ///
   /// \return constant reference to the current value.
   const T &operator*(void)const noexcept { return Value; }
 
   /// Returns a constant pointer to the current value.
   ///
   /// \note Should not dereference the iterator when it is empty.
   ///
   /// \return constant pointer to the current value.
   const T *operator->(void)const noexcept { return &Value; }
 
   /// Tells if \p this object is equal to another one.
   ///
   /// Two \c SplittedElementIterator instances are equal if and only if they are
   /// the same or both are empty.
   ///
   /// \param RHS other object to compare to
   ///
   /// \return whether \p this object is equal with \p RHS
   bool operator==(const SplittedElementIterator &RHS) const noexcept {
     return ((this == &RHS) || (!Buffer && !RHS.Buffer));
   }
 
   /// Tells if \p this object is not equal to another one.
   ///
   /// \see SplittedElementIterator::operator==
   ///
   /// \param RHS other object to compare to
   ///
   /// \return whether \p this object is not equal with \p RHS.
   bool operator!=(const SplittedElementIterator &RHS) const noexcept {
     return !((*this) == RHS);
   }
 
 private:
   std::shared_ptr<TB> Buffer; ///< Buffer providing values for \p this object
   T Value;                    ///< The current value of the iterator
 };
 
 ///\defgroup TupleBufferContainer Type converter turning a \c std::tuple of
 ///types into a \c std::tuple of container of those types.
 ///
 /// The new type is used for buffering elements of tuples separately.
 ///
 ///@{
 
 /// Template declaration.
 ///
 /// \tparam T type to convert
 ///
 /// \note The template is defined only when \p T is a \c std::tuple.
 ///
 /// Usage for a type \c Tuple as:\code
 /// typename TupleBufferContainer<Tuple>::Type
 /// \endcode
 template <typename T> struct TupleBufferContainer;
 
 /// Template definition for \c std::tuple.
 template <typename... Ts> struct TupleBufferContainer<std::tuple<Ts...>> {
   /// The converted type.
   using Type = std::tuple<std::queue<Ts>...>;
 };
 
 ///@}
 
 /// Convenience template type alias for easy use of \c TupleBufferContainer.
 ///
 /// Converts a \c std::tuple of types into a \c std::tuple of container of those
 /// types.
 ///
 /// \tparam Tuple type to convert
 template <typename Tuple>
 using tuple_buffer_container_t = typename TupleBufferContainer<Tuple>::Type;
 
 /// Buffer for element values for iterator of \c std::tuple.
 ///
 /// The class can be instantiated with a range of iterator of \c std::tuple and
 /// provides an interface for accessing elements of the iterated tuples one by
 /// one.
 ///
 /// \note The class is utilized by \c SplittedElementIterator.
 ///
 /// \tparam TupleIterator the iterator type that provides values of \c
 /// std::tuple
 ///
 /// \todo Consider thread safety of the class.
 template <typename TupleIterator>
 class TupleIteratorBuffer {
 public:
   /// Type alias for the value type of \p TupleIterator.
   /// \note The type is expected to be \c std::tuple.
   using iterator_value_type = typename TupleIterator::value_type;
 
   /// The number of elements of \c iterator_value_type.
   static constexpr size_t iterator_value_size =
       std::tuple_size_v<iterator_value_type>;
 
   /// Template type alias to get element types of \c iterator_value_type by
   /// index.
   /// \tparam I the index of the element
   template <size_t I>
   using element_type =
       typename std::tuple_element<I, iterator_value_type>::type;
 
+  /// Type alias for index sequence for accessing elements of \c
+  /// iterator_value_type.
+  using element_idx_seq_t = seq_t<iterator_value_size>;
+
   /// Creates a new instance.
   ///
   /// \param Begin the beginning of the iterator range to buffer
   /// \param End the end of the iterator range to buffer
   TupleIteratorBuffer(TupleIterator &&Begin, const TupleIterator &End) noexcept
       : Iterator(Begin), End(End), Buffer() {}
 
   /// Tells whether there is any more value in the handled range for index \p I.
   ///
   /// \tparam I the index of the element to check
   ///
   /// \return whether there is more value for index \p I
   template <size_t I> bool hasMore(void) const noexcept {
     const auto &ElementBuffer = std::get<I>(Buffer);
     // There is more value if some has already been buffered or the end of the
     // handled range is not reached yet.
     return !ElementBuffer.empty() || Iterator != End;
   }
 
   /// Gives the next value from the handled range for index \p I.
   ///
   /// \note The function should not be called if there is no more value for
   /// index \p I (i.e., \c hasMore<I>() returns \c false). If it is called in
   /// that situation, it returns the default value of \c element_type<I>.
   ///
   /// \tparam I the index of the element to fetch next value for
   ///
   /// \return the next value for index \p I
   template <size_t I> element_type<I> next(void) noexcept {
     auto &ElementBuffer = std::get<I>(Buffer);
     if (ElementBuffer.empty()) {
       // This position needs a new value from Iterator if there is more.
       if (Iterator != End) {
         // Push next value for all elements.
-        push(*Iterator++, seq_t<iterator_value_size>());
+        push(*Iterator++, element_idx_seq_t());
       } else {
         // No more values; called when hasMore<I>() is false.
         // Return default value.
         return element_type<I>();
       }
     }
     // Buffer is not empty here, return the next value.
     ASSERT(!ElementBuffer.empty() && "Unexpected condition");
     // Get the next value and also pop it from the buffer.
     const element_type<I> Elem = ElementBuffer.front();
     ElementBuffer.pop();
     return Elem;
   }
 
 private:
   /// Buffers next tuple value elementwise into element containers.
   ///
   /// \tparam S0 indices for accessing elements of \c std::tuple
   ///
   /// \param Tuple the values to buffer
   ///
   /// \note The second parameter provides indices as template parameter \p S0
   /// and its actual value is ignored.
   template <size_t... S0>
   void push(const iterator_value_type &Tuple, Seq<S0...>) noexcept {
     (std::get<S0>(Buffer).push(std::get<S0>(Tuple)), ...);
   }
 
   TupleIterator Iterator;  ///< Current input iterator
   const TupleIterator End; ///< End of iterator range to handle
   tuple_buffer_container_t<iterator_value_type>
       Buffer; ///< Container for elementwise buffering
 };
 
 /// Template type alias for iterator of an element based on buffered iterator of
 /// \c std::tuple.
 ///
 /// The alias utilizes \c SplittedElementIterator for iterating over the values
 /// provided by \p TB.
 ///
 /// \tparam TB buffer providing values to iterate
 /// \tparam I index of the values to iterator from \p TB
 template <typename TB, size_t I>
 using element_iterator_t = SplittedElementIterator<TB, I>;
 
 /// Template type alias for iterator-range of an element based on buffered
 /// iterator of \c std::tuple.
 ///
 /// \tparam TB buffer providing values to iterate
 /// \tparam I index of the values to iterator from \p TB
 template <typename TB, size_t I>
 using element_iterator_range_t =
     std::pair<element_iterator_t<TB, I>, element_iterator_t<TB, I>>;
 
 ///\defgroup ElementIteratorRanges Type converter turning a buffer of \c
 /// std::tuple into a \c std::tuple of corresponding \c
 /// element_iterator_range_t.
 ///
 ///@{
 
 /// Template declaration.
 ///
 /// \tparam TB buffer providing values
 /// \tparam S type providing indices for accessing elements of \c std::tuple
 ///
 /// \note \p TB is expected to implement an interface matching that of \c
 /// TupleIteratorBuffer.
 ///
 /// \note The template is defined only when \p S is a \c rosa::Seq.
 ///
 /// Usage for a proper buffer type \c TB:\code
-/// typename ElementIteratorRanges<TB, seq_t<TB::iterator_value_size>>::Type
+/// typename ElementIteratorRanges<TB, typename TB::element_idx_seq_t>::Type
 /// \endcode
 template <typename TB, typename S> struct ElementIteratorRanges;
 
 /// Template definition.
 template <typename TB, size_t... S0>
 struct ElementIteratorRanges<TB, Seq<S0...>> {
   /// The converted type.
   using Type = std::tuple<element_iterator_range_t<TB, S0>...>;
 };
 
 ///@}
 
 /// Convenience template type alias for easy use of \c ElementIteratorRanges.
 ///
 /// Converts a buffer of \c std::tuple into a \c std::tuple of corresponding \c
 /// element_iterator_range_t.
 ///
 /// \tparam TB buffer providing values
 ///
 /// \note \p TB is expected to implement an interface matching that of \c
 /// TupleIteratorBuffer.
 template <typename TB>
 using element_iterator_ranges_t =
-    typename ElementIteratorRanges<TB, seq_t<TB::iterator_value_size>>::Type;
+    typename ElementIteratorRanges<TB, typename TB::element_idx_seq_t>::Type;
 
 /// Template type alias for turning an iterator of \c std::tuple into
 /// corresponding \c element_iterator_ranges_t.
 ///
 /// The alias utilizes \c TupleIteratorBuffer for buffering the values provided
 /// by \p TupleIterator. The elementwise iterators are \c
 /// SplittedElementIterator.
 ///
 /// \tparam TupleIterator iterator of \c std::tuple
 template <typename TupleIterator>
 using splitted_tuple_iterator_ranges_t =
     element_iterator_ranges_t<TupleIteratorBuffer<TupleIterator>>;
 
 /// Creates elementwise iterator ranges for an iterator range of \c std::tuple.
 ///
 /// \note Implementation for \c rosa::iterator::splitTupleIterator.
 ///
 /// \tparam TupleIterator iterator of \c std::tuple
 /// \tparam S0 indices for accessing elements of \c std::tuple
 ///
 /// \param Begin the beginning of the iterator range to handle
 /// \param End the end of the iterator range to handle
 ///
 /// \note The last parameter provides indices as template parameter \p S0 and
 /// its actual value is ignored.
 ///
 /// \return \c std::tuple of elementwise iterator ranges corresponding to \p
 /// Begin and \p End
 template <typename TupleIterator, size_t... S0>
 splitted_tuple_iterator_ranges_t<TupleIterator>
 splitTupleIteratorImpl(TupleIterator &&Begin, const TupleIterator &End,
                        Seq<S0...>) noexcept {
   using TB = TupleIteratorBuffer<TupleIterator>;
   // Create a buffer in shared pointer. The buffer will be destructed once
   // all corresponding element iterators (created below) have reached the end of
   // the handled range or have been destructed.
   auto Buffer = std::make_shared<TB>(std::move(Begin), End);
   return {std::make_pair(element_iterator_t<TB, S0>(Buffer),
                          element_iterator_t<TB, S0>())...};
 }
 
 } // End namespace
 
 /// Creates elementwise iterator ranges for an iterator range of \c std::tuple.
 ///
 /// \note The implementation utilizes \c splitTupleIteratorImpl.
 ///
 /// Obtain element iterator ranges for an iterator range \c Begin and \c End of
 /// iterator type \c TupleIterator of \c std::tuple<T1, T2, T3> as \code
 /// auto [T1Range, T2Range, T3Range] = splitTupleIterator(std::move(Begin), End);
 /// auto [T1Begin, T1End] = T1Range;
 /// auto [T2Begin, T2End] = T2Range;
 /// auto [T3Begin, T3End] = T3Range;
 /// \endcode
 ///
 /// The function returns a tuple of ranges (i.e., \c std::pair of iterators),
 /// which can be assigned to variables using structured binding. The ranges can
 /// be dissected into begin and end iterators by separate structured bindings.
 ///
-/// The function moves its first argument (i.e., \p Begin cannot be used after
-/// splitting it). If the first argument is a variable, it needs to be moved
-/// explicitly by \c std::move() as in the example.
+/// The function moves its first argument (i.e., \p Begin cannot be used
+/// directly after splitting it). If the first argument is a variable, it needs
+/// to be moved explicitly by \c std::move() as in the example.
 ///
 /// \tparam TupleIterator iterator of \c std::tuple
 ///
 /// \param Begin the beginning of the iterator range to handle
 /// \param End the end of the iterator range to handle
 ///
 /// \return \c std::tuple of elementwise iterator ranges corresponding to \p
 /// Begin and \p End
 template <typename TupleIterator>
 splitted_tuple_iterator_ranges_t<TupleIterator>
 splitTupleIterator(TupleIterator &&Begin, const TupleIterator &End) noexcept {
   return splitTupleIteratorImpl(
       std::move(Begin), End,
       seq_t<std::tuple_size_v<typename TupleIterator::value_type>>());
 }
 
 } // End namespace iterator
 } // End namespace rosa
 
 #endif // ROSA_SUPPORT_ITERATOR_SPLIT_TUPLE_ITERATOR_HPP
diff --git a/include/rosa/support/writer/namespace.h b/include/rosa/support/writer/namespace.h
new file mode 100644
index 0000000..3349a93
--- /dev/null
+++ b/include/rosa/support/writer/namespace.h
@@ -0,0 +1,25 @@
+//===-- rosa/support/writer/namespace.h --------------------------*- C++ -*-===/
+//
+//                                 The RoSA Framework
+//
+//===----------------------------------------------------------------------===/
+///
+/// \file rosa/support/writer/namespace.h
+///
+/// \author David Juhasz (david.juhasz@tuwien.ac.at)
+///
+/// \date 2019
+///
+/// \brief Documentation for the namespace \c rosa::writer.
+///
+//===----------------------------------------------------------------------===/
+
+#ifndef ROSA_SUPPORT_WRITER_NAMESPACE_H
+#define ROSA_SUPPORT_WRITER_NAMESPACE_H
+
+namespace rosa {
+/// Provides facilities to work with writers.
+namespace writer {}
+} // End namespace rosa
+
+#endif // ROSA_SUPPORT_WRITER_NAMESPACE_H
diff --git a/include/rosa/support/writer/split_tuple_writer.hpp b/include/rosa/support/writer/split_tuple_writer.hpp
new file mode 100644
index 0000000..22e3a35
--- /dev/null
+++ b/include/rosa/support/writer/split_tuple_writer.hpp
@@ -0,0 +1,554 @@
+//===-- rosa/support/writer/split_tuple_writer.hpp ---------------*- C++ -*-===/
+//
+//                                 The RoSA Framework
+//
+//===----------------------------------------------------------------------===/
+///
+/// \file rosa/support/writer/split_tuple_writer.hpp
+///
+/// \authors David Juhasz (david.juhasz@tuwien.ac.at)
+///
+/// \date 2019
+///
+/// \brief Facilities to split writers of \c std::tuple into writers of
+/// their elements.
+///
+//===----------------------------------------------------------------------===/
+
+#ifndef ROSA_SUPPORT_WRITER_SPLIT_TUPLE_WRITER_HPP
+#define ROSA_SUPPORT_WRITER_SPLIT_TUPLE_WRITER_HPP
+
+#include "rosa/support/debug.hpp"
+#include "rosa/support/sequence.hpp"
+
+#include <memory>
+#include <tuple>
+#include <queue>
+
+namespace rosa {
+namespace writer {
+
+/// What to do when splitted element writers got destructed so that some
+/// incomplete tuples remain in the buffer.
+enum IncompleteTuplePolicy {
+  Ignore, ///< ignore incomplete tuples, data discarded
+  Flush   ///< flush incomplete tuples, use default value for missing elements
+};
+
+/// Anonymous namespace providing implementation for splitting tuple writers;
+/// consider it private.
+namespace {
+
+/// Writes values into a buffer based on an index.
+///
+/// The values are first buffered and flushed out later once a corresponding
+/// tuple gets complete (i.e., other elementwise writers put the corresponding
+/// values into the buffer). Since the underlying buffer waits for tuples to
+/// become complete, the elementwise writers are expected to provide the same
+/// number of values for the buffer (i.e., completing all tuples that have an
+/// element). That is, however, not enforced in any ways.
+///
+/// Once all elementwise writers are destructed, the underlying buffer gets
+/// destructed as well. Should the buffer contain some values, which are
+/// elements of incomplete tuples, the destructor of the buffer handles the
+/// situation according to the \c rosa::writer::IncompleteTuplePolicy set when
+/// the elementwise writers were created by \c rosa::writer::splitTupleWriter().
+///
+/// \tparam TB buffer to write into
+/// \tparam I index of the values to write to \p TB
+///
+/// \note \p TB is expected to implemnet an interface matching that of \c
+/// TupleWriterBuffer.
+///
+/// \note the
+template <typename TB, size_t I>
+class SplittedElementWriter {
+public:
+  /// Type alias for the values the writer writes.
+  using T = typename TB::template element_type<I>;
+
+  /// \defgroup SplittedElemenWriterTypedefs Typedefs of 
+  /// \c SplittedElementWriter
+  ///
+  /// Useful `typedef`s for writers.
+  ///
+  ///@{
+  typedef T value_type; ///< Type of values written.
+  typedef T &reference; ///< Reference to the type written
+  ///@}
+
+  /// Creates a new instance.
+  ///
+  /// \param Buffer buffer \p this object writes values into
+  ///
+  /// \note \p Buffer is captured as a \c std::shared_ptr because it is shared
+  /// among writers for its element positions.
+  SplittedElementWriter(std::shared_ptr<TB> Buffer) : Buffer(Buffer) {}
+
+  /// Tells how many values are still in the buffer.
+  ///
+  /// Values are buffered as long as all elements of their corresponding tuples
+  /// are written into the buffer by other elementwise writers and in turn
+  /// complete tuples written by the buffer itself. This function tells how many
+  /// values are still in the buffer waiting for their containing tuples to be
+  /// complete and written out from the buffer.
+  ///
+  /// \note The function simply calles the corresponding function of \p TB.
+  ///
+  /// \return how many values are still in the buffer.
+  size_t buffered(void) const noexcept {
+    return Buffer->template buffered<I>();
+  }
+
+  /// Tells if the last write operation of the buffer was successful.
+  ///
+  /// Values are buffered until their corresponding tuples gets complete. The
+  /// buffer writes complete tuples by the underlying writer. This function
+  /// tells if the buffer successfully has written the latest complete tuple by
+  /// the underlying writer.
+  ///
+  /// Once this function returns \c false, further \c write() calls has no
+  /// effect and the last \c buffered() values will not be written to the
+  /// underlying writer of \c std::tuple.
+  ///
+  /// \note The function simply calles the corresponding function of \p TB.
+  ///
+  /// \return if the last write operation was successful
+  bool good(void) const noexcept { return Buffer->good(); }
+
+  /// Writes an entry to the buffer.
+  ///
+  /// The function has no effect if an earlier write operation of the buffer has
+  /// failed, that is \c good() returns \c false.
+  ///
+  /// \note The function simply calles the corresponding function of \p TB.
+  ///
+  /// \param V value to write
+  void write(const T &V) { Buffer->template write<I>(V); }
+
+private:
+  std::shared_ptr<TB> Buffer; ///< Buffer \p this object writes into
+};
+
+/// Writes an element of a tuple.
+///
+/// \see SplittedElementWriter
+///
+/// \tparam TB type of the buffer \p W writes into
+/// \tparam I index of the values \p W write to \p TB
+///
+/// \param [in,out] W object to write with
+/// \param V value to write
+///
+/// \return \p W after writing \p V with it
+template <typename TB, size_t I>
+SplittedElementWriter<TB, I> &
+operator<<(SplittedElementWriter<TB, I> &W,
+           const typename SplittedElementWriter<TB, I>::value_type &V) {
+  W.write(V);
+  return W;
+}
+
+///\defgroup TupleBufferContainer Type converter turning a \c std::tuple of
+///types into a \c std::tuple of container of those types.
+///
+/// The new type is used for buffering elements of tuples separately.
+///
+///@{
+
+/// Template declaration.
+///
+/// \tparam T type to convert
+///
+/// \note The template is defined only when \p T is a \c std::tuple.
+///
+/// Usage for a type \c Tuple as:\code
+/// typename TupleBufferContainer<Tuple>::Type
+/// \endcode
+template <typename T> struct TupleBufferContainer;
+
+/// Template definition for \c std::tuple.
+template <typename... Ts> struct TupleBufferContainer<std::tuple<Ts...>> {
+  /// The converted type.
+  using Type = std::tuple<std::queue<Ts>...>;
+};
+
+///@}
+
+/// Convenience template type alias for easy use of \c TupleBufferContainer.
+///
+/// Converts a \c std::tuple of types into a \c std::tuple of container of those
+/// types.
+///
+/// \tparam Tuple type to convert
+template <typename Tuple>
+using tuple_buffer_container_t = typename TupleBufferContainer<Tuple>::Type;
+
+/// Buffer for element values for writer of \c std::tuple.
+///
+/// The class can be instantiated with a writer of \c std::tuple and provides
+/// an interface for writing elements into tuples one by one.
+///
+/// \note The class is utilized by \c SplittedElementWriter.
+///
+/// \tparam TupleWriter the writer type that handles values of \c std::tuple
+///
+/// \note The elements of the written \c std::tuple need to be default
+/// constructible because of \c rosa::writer::IncompleteTuplePolicy::Flush.
+///
+/// \todo Consider thread safety of the class.
+template <typename TupleWriter>
+class TupleWriterBuffer {
+public:
+  /// Type alias for the value type of \p TupleWriter.
+  /// \note The type is expected to be \c std::tuple.
+  using writer_value_type = typename TupleWriter::value_type;
+
+  /// The number of elements of \c writer_value_type.
+  static constexpr size_t writer_value_size =
+      std::tuple_size_v<writer_value_type>;
+
+  /// Template type alias to get element types of \c writer_value_type by
+  /// index.
+  /// \tparam I the index of the element
+  template <size_t I>
+  using element_type =
+      typename std::tuple_element<I, writer_value_type>::type;
+
+  /// Type alias for index sequence for accessing elements of \c
+  /// writer_value_size.
+  using element_idx_seq_t = seq_t<writer_value_size>;
+
+  /// Creates a new instance.
+  ///
+  /// \param Writer the writer \p this object uses to write tuples
+  /// \param Policy what to do with incomplete tuples when destructing \p
+  /// this object
+  TupleWriterBuffer(TupleWriter &&Writer,
+                    const IncompleteTuplePolicy Policy) noexcept
+      : Writer(Writer), Policy(Policy), Buffer() {}
+
+  /// Destructor.
+  ///
+  /// Should \p this object has some values in \c Buffer (i.e., incomplete
+  /// tuples), the destructor takes care of them according to \c Policy.
+  ///
+  /// \note The destructor may flush the buffered values if the last write
+  /// operation was successful, that is \c good() returns \c true.
+  ~TupleWriterBuffer(void) noexcept {
+    if (good()) {
+      switch (Policy) {
+      default:
+        ASSERT(false && "Unexpected Policy");
+      case Ignore:
+        // Do not care about incomplete tuples in the buffer.
+        break;
+      case Flush:
+        // Whatever we have in the buffer, flush it out.
+        flush();
+        break;
+      }
+    }
+  }
+
+  /// Tells how many values are in the buffer for index \p I.
+  ///
+  /// \tparam I the index of the element to check
+  ///
+  /// \return the number of values in buffer for index \p I
+  template <size_t I> size_t buffered(void) const noexcept {
+    return std::get<I>(Buffer).size();
+  }
+
+  /// Tells if the last write operation was successful.
+  ///
+  /// Values are buffered until their corresponding tuples gets complete.
+  /// Once a tuple becomes complete, it is written by \c Writer. This function
+  /// tells if writing the latest complete tuple was successful.
+  ///
+  /// Once this function returns \c false, further \c write<I>() calls has no
+  /// effect and the last \c buffered<I>() values will not be written to the
+  /// underlying writer of \c std::tuple.
+  ///
+  /// \return if the last write operation was successful
+  bool good(void) const noexcept { return Writer.good(); }
+
+  /// Writes an entry to the buffer for index \p I.
+  ///
+  /// The function has no effect if an earlier write operation of the buffer has
+  /// failed, that is \c good() returns \c false.
+  ///
+  /// The value is buffered first and written by \p Writer once its
+  /// corresponding tuple becomes complete (i.e., all other elements of the
+  /// tuple are written into \p this object by corresponding elementwise
+  /// writers).
+  ///
+  /// \tparam I the index of the element to write
+  ///
+  /// \param V value to write
+  template <size_t I> void write(const element_type<I> &V) {
+    ASSERT(!hasCompleteTuple(element_idx_seq_t()));
+    if (good()) {
+      std::get<I>(Buffer).push(V);
+      if (hasCompleteTuple(element_idx_seq_t())) {
+        writeTuple(false);
+      }
+    }
+    ASSERT(!hasCompleteTuple(element_idx_seq_t()));
+  }
+
+private:
+  /// Tells whether \c Buffer is completely empty, all elements of it are empty.
+  ///
+  /// \tparam S0 indices for accessing elements of \c std::tuple
+  ///
+  /// \note The parameter provides indices as template parameter \p S0 and its
+  /// actual value is ignored.
+  ///
+  /// \return whether all elements of \c Buffer are empty
+  template <size_t... S0> bool empty(Seq<S0...>) const noexcept {
+    return (true && ... && std::get<S0>(Buffer).empty());
+  }
+
+  /// Tells whether \c Buffer contains at least one complete tuple.
+  ///
+  /// \tparam S0 indices for accessing elements of \c std::tuple
+  ///
+  /// \note The parameter provides indices as template parameter \p S0 and its
+  /// actual value is ignored.
+  ///
+  /// \return whether there is at least one complete tuple in \c Buffer
+  template <size_t... S0> bool hasCompleteTuple(Seq<S0...>) const noexcept {
+    return (true && ... && !std::get<S0>(Buffer).empty());
+  }
+
+  /// Makes sure \c Buffer has one complete tuple in front.
+  ///
+  /// If the tuple in front of \c Buffer is not complete, missing elements are
+  /// default constructed in \c Buffer to complete the tuple.
+  ///
+  /// \tparam S0 indices for accessing elements of \c std::tuple
+  ///
+  /// \note The parameter provides indices as template parameter \p S0 and its
+  /// actual value is ignored.
+  template <size_t... S0> void makeCompleteTuple(Seq<S0...>) noexcept {
+    auto addDefaultIfEmpty = [](auto &Queue) {
+      if (Queue.empty()) {
+        Queue.emplace(); // default construct a value in the empty queue.
+      }
+    };
+    (addDefaultIfEmpty(std::get<S0>(Buffer)), ...);
+  }
+
+  /// Gives the first complete tuple from \c Buffer.
+  ///
+  /// \tparam S0 indices for accessing elements of \c std::tuple
+  ///
+  /// \note The parameter provides indices as template parameter \p S0 and its
+  /// actual value is ignored.
+  ///
+  /// \return the first complete tuple from \c Buffer
+  ///
+  /// \pre There is at least one complete tuple in \c Buffer:\code
+  /// hasCompleteTuple(element_idx_seq_t())
+  /// \endcode
+  template <size_t... S0> writer_value_type front(Seq<S0...>) const noexcept {
+    ASSERT(hasCompleteTuple(element_idx_seq_t()));
+    return {std::get<S0>(Buffer).front()...};
+  }
+
+  /// Removes the first complete tuple from \c Buffer.
+  ///
+  /// \tparam S0 indices for accessing elements of \c std::tuple
+  ///
+  /// \note The parameter provides indices as template parameter \p S0 and its
+  /// actual value is ignored.
+  ///
+  /// \pre There is at least one complete tuple in \c Buffer:\code
+  /// hasCompleteTuple(element_idx_seq_t())
+  /// \endcode
+  template <size_t... S0> void pop(Seq<S0...>) noexcept {
+    ASSERT(hasCompleteTuple(element_idx_seq_t()));
+    (std::get<S0>(Buffer).pop(), ...);
+  }
+
+  /// Takes the first tuple from \c Buffer and writes it with \c Writer.
+  ///
+  /// \c Buffer need to contain a complete tuple to write it with \c Writer. The
+  /// function makes sure that the tuple in front of \c Buffer is complete if \p
+  /// MakeComplete is true. The tuple in fron of \c Buffer are expected to be
+  /// complete otherwise.
+  ///
+  /// \param MakeComplete whether to make the first tuple complete
+  ///
+  /// \pre There is at least one complete tuple in \c Buffer if not \p
+  /// MakeComplete: \code
+  /// MakeComplete || hasCompleteTuple(element_idx_seq_t())
+  /// \endcode
+  void writeTuple(const bool MakeComplete) noexcept {
+    if (MakeComplete) {
+      makeCompleteTuple(element_idx_seq_t());
+    }
+    ASSERT(hasCompleteTuple(element_idx_seq_t()));
+    Writer.write(front(element_idx_seq_t()));
+    pop(element_idx_seq_t());
+  }
+
+  /// Empties \c Buffer by writing out all tuples from it so that missing
+  /// elements of incomplete tuples are extended with default constructed
+  /// values.
+  void flush(void) noexcept {
+    while (!empty(element_idx_seq_t())) {
+      ASSERT(!hasCompleteTuple(element_idx_seq_t())); // Sanity check.
+      writeTuple(true);
+    }
+  }
+
+  TupleWriter Writer;                 ///< The splitted writer
+  const IncompleteTuplePolicy Policy; ///< what to do with incomplete tuples
+                                      ///< when destructing \p this object
+  tuple_buffer_container_t<writer_value_type>
+      Buffer; ///< Container for elementwise buffering
+};
+
+/// Template type alias for writer of an element based on buffered writer of
+/// \c std::tuple.
+///
+/// The alias utilizes \c SplittedElementWriter for writing element values by
+/// \p TB.
+///
+/// \tparam TB buffer to write into
+/// \tparam I index of the values to write to \p TB
+template <typename TB, size_t I>
+using element_writer_t = SplittedElementWriter<TB, I>;
+
+///\defgroup ElementWriters Type converter turning a buffer of \c std::tuple
+///into a \c std::tuple of corresponding \c element_writer_t.
+///
+///@{
+
+/// Template declaration.
+///
+/// \tparam TB buffer to write into
+/// \tparam S type providing indices for accessing elements of \c std::tuple
+///
+/// \note \p TB is expected to implement an interface matching that of \c
+/// TupleWriterBuffer.
+///
+/// \note The template is defined only when \p S is a \c rosa::Seq.
+///
+/// Usage for a proper buffer type \c TB:\code
+/// typename ElementIteratorWriters<TB, typename TB::element_idx_seq_t>::Type
+/// \endcode
+template <typename TB, typename S> struct ElementWriters;
+
+/// Template definition.
+template <typename TB, size_t... S0>
+struct ElementWriters<TB, Seq<S0...>> {
+  /// The converted type.
+  using Type = std::tuple<element_writer_t<TB, S0>...>;
+};
+
+///@}
+
+/// Convenience template type alias for easy use of \c ElementIteratorWriters.
+///
+/// Converts a buffer of \c std::tuple into a \c std::tuple of corresponding \c
+/// element_writer_t.
+///
+/// \tparam TB buffer to write into
+///
+/// \note \p TB is expected to implement an interface matching that of \c
+/// TupleWriterBuffer.
+template <typename TB>
+using element_writers_t =
+    typename ElementWriters<TB, typename TB::element_idx_seq_t>::Type;
+
+/// Template type alias for turning a writer of \c std::tuple into
+/// corresponding \c element_writers_t.
+///
+/// The alias utilizes \c TupleWriterBuffer for buffering values before writing
+/// them by \p TupleWriter. The elementwise writers are \c
+/// SplittedElementWriter.
+///
+/// \tparam TupleWriter writer of \c std::tuple
+template <typename TupleWriter>
+using splitted_tuple_writers_t =
+    element_writers_t<TupleWriterBuffer<TupleWriter>>;
+
+/// Creates elementwise writers for a writer of \c std::tuple.
+///
+/// \note Implementation for \c rosa::iterator::splitTupleWriter.
+///
+/// \tparam TupleWriter writer of \c std::tuple
+/// \tparam S0 indices for accessing elements of \c std::tuple
+///
+/// \param Writer the writer to write tuples with
+/// \param Policy how to handle incomplete tuples when destructing the
+/// underlying buffer
+///
+/// \note The last parameter provides indices as template parameter \p S0 and
+/// its actual value is ignored.
+///
+/// \return \c std::tuple of elementwise writers corresponding to \p Writer
+template <typename TupleWriter, size_t... S0>
+splitted_tuple_writers_t<TupleWriter>
+splitTupleWriterImpl(TupleWriter &&Writer, const IncompleteTuplePolicy Policy,
+                     Seq<S0...>) noexcept {
+  using TB = TupleWriterBuffer<TupleWriter>;
+  // Create a buffer in shared pointer. The buffer will be destructed once
+  // all corresponding element writers (created below) have been destructed.
+  auto Buffer = std::make_shared<TB>(std::move(Writer), Policy);
+  return {element_writer_t<TB, S0>(Buffer)...};
+}
+
+} // End namespace
+
+/// Creates elementwise writers for a writer of \c std::tuple.
+///
+/// \note The implementation utilizes \c splitTupleWriterImpl.
+///
+/// Obtain elementwise writers for a writer \p Writer of type \c TupleWriter of
+/// \c std::tuple<T1, T2, T3> as \code
+/// auto [T1Writer, T2Writer, T3Writer] = splitTupleWriter(std::move(Writer),
+///                                                        Ignore);
+/// \endcode
+///
+/// The function returns a tuple of writers, which can be assigned to variables
+/// using structured binding.
+///
+/// The function moves its first argument (i.e., \p Writer cannot be used
+/// directly after splitting it). If the first argument is a variable, it needs
+/// to be moved explicitly by \c std::move() as in the example.
+///
+/// While a tuple could be written with \p Writer directly as \code
+/// Writer << std::make_tuple(T1(), T2(), T3());
+/// \endcode The same tuple is written with splitted writers as \code
+/// T1Writer << T1();
+/// T2Writer << T2();
+/// T3Writer << T3();
+/// \endcode
+///
+/// \tparam TupleWriter writer of \c std::tuple
+///
+/// \note The elements of the written \c std::tuple need to be default
+/// constructible because of \c rosa::writer::IncompleteTuplePolicy::Flush.
+///
+/// \param Writer the writer to write tuples with
+/// \param Policy what to do with incomplete tuples when destructing the
+/// underlying buffer
+///
+/// \return \c std::tuple of elementwise writers corresponding to \p Writer
+template <typename TupleWriter>
+splitted_tuple_writers_t<TupleWriter>
+splitTupleWriter(TupleWriter &&Writer,
+                 const IncompleteTuplePolicy Policy) noexcept {
+  return splitTupleWriterImpl(
+      std::move(Writer), Policy,
+      seq_t<std::tuple_size_v<typename TupleWriter::value_type>>());
+}
+
+} // End namespace writer
+} // End namespace rosa
+
+#endif // ROSA_SUPPORT_WRITER_SPLIT_TUPLE_WRITER_HPP
diff --git a/lib/support/CMakeLists.txt b/lib/support/CMakeLists.txt
index 12a3334..318486d 100644
--- a/lib/support/CMakeLists.txt
+++ b/lib/support/CMakeLists.txt
@@ -1,42 +1,46 @@
 set(LIB_INCLUDE_DIR ${ROSA_MAIN_INCLUDE_DIR}/rosa/support)
 
 add_library(ROSASupport
   ${LIB_INCLUDE_DIR}/debug.hpp
   debug.cpp
   ${LIB_INCLUDE_DIR}/terminal_colors.h
   terminal_colors.cpp
   ${LIB_INCLUDE_DIR}/log.h
   log.cpp
   ${LIB_INCLUDE_DIR}/math.hpp
   math.cpp
   ${LIB_INCLUDE_DIR}/type_helper.hpp
   type_helper.cpp
   ${LIB_INCLUDE_DIR}/types.hpp
   types.cpp
   ${LIB_INCLUDE_DIR}/atom.hpp
   atom.cpp
   ${LIB_INCLUDE_DIR}/type_pair.hpp
   type_pair.cpp
   ${LIB_INCLUDE_DIR}/type_list.hpp
   type_list.cpp
   ${LIB_INCLUDE_DIR}/squashed_int.hpp
   squashed_int.cpp
   ${LIB_INCLUDE_DIR}/type_numbers.hpp
   type_numbers.cpp
   ${LIB_INCLUDE_DIR}/type_token.hpp
   type_token.cpp
   ${LIB_INCLUDE_DIR}/tokenized_storages.hpp
   tokenized_storages.cpp
   ${LIB_INCLUDE_DIR}/sequence.hpp
   sequence.cpp
   ${LIB_INCLUDE_DIR}/csv/namespace.h
   csv/namespace.cpp
   ${LIB_INCLUDE_DIR}/csv/CSVReader.hpp
   csv/CSVReader.cpp
   ${LIB_INCLUDE_DIR}/csv/CSVWriter.hpp
   csv/CSVWriter.cpp
   ${LIB_INCLUDE_DIR}/iterator/namespace.h
   iterator/namespace.cpp
   ${LIB_INCLUDE_DIR}/iterator/split_tuple_iterator.hpp
   iterator/split_tuple_iterator.cpp
+  ${LIB_INCLUDE_DIR}/writer/namespace.h
+  writer/namespace.cpp
+  ${LIB_INCLUDE_DIR}/writer/split_tuple_writer.hpp
+  writer/split_tuple_writer.cpp
   )
diff --git a/lib/support/writer/namespace.cpp b/lib/support/writer/namespace.cpp
new file mode 100644
index 0000000..b659e2d
--- /dev/null
+++ b/lib/support/writer/namespace.cpp
@@ -0,0 +1,20 @@
+//===-- support/writer/namespace.cpp -----------------------------*- C++ -*-===/
+//
+//                                 The RoSA Framework
+//
+//===----------------------------------------------------------------------===/
+///
+/// \file support/writer/namespace.cpp
+///
+/// \author David Juhasz (david.juhasz@tuwien.ac.at)
+///
+/// \date 2019
+///
+/// \brief Placeholder for rosa/support/iterator/namespace.h.
+///
+/// \note Empty implementation, source file here to have a compile database
+///       entry for rosa/support/writer/namespace.h.
+///
+//===----------------------------------------------------------------------===/
+
+#include "rosa/support/writer/namespace.h"
diff --git a/lib/support/writer/split_tuple_writer.cpp b/lib/support/writer/split_tuple_writer.cpp
new file mode 100644
index 0000000..651e012
--- /dev/null
+++ b/lib/support/writer/split_tuple_writer.cpp
@@ -0,0 +1,20 @@
+//===-- support/writer/split_tuple_writer.cpp --------------------*- C++ -*-===/
+//
+//                                 The RoSA Framework
+//
+//===----------------------------------------------------------------------===/
+///
+/// \file support/writer/split_tuple_writer.cpp
+///
+/// \author David Juhasz (david.juhasz@tuwien.ac.at)
+///
+/// \date 2019
+///
+/// \brief Implementation for rosa/support/writer/split_tuple_writer.hpp.
+///
+/// \note Empty implementation, source file here to have a compile database
+///       entry for rosa/support/writer/split_tuple_writer.hpp.
+///
+//===----------------------------------------------------------------------===/
+
+#include "rosa/support/writer/split_tuple_writer.hpp"