diff --git a/amdis/DOFVector.hpp b/amdis/DOFVector.hpp
index db0934887005c111e3268737190f1a7a8df9c228..ebd5e2c75bd833e35b4ed91f30190725b83188e8 100644
--- a/amdis/DOFVector.hpp
+++ b/amdis/DOFVector.hpp
@@ -38,11 +38,14 @@ namespace AMDiS
       , private Observer<event::postAdapt>
   {
     using Self = DOFVector;
-    using Coefficients = VectorFacade<T, TraitsType::template VectorImpl>;
 
   public:
+    /// A global basis associated to the coefficients
     using GlobalBasis = GB;
 
+    /// The internal coefficient vector storage
+    using Coefficients = VectorFacade<T, TraitsType::template VectorImpl>;
+
     /// The index/size - type
     using size_type  = typename GlobalBasis::size_type;
 
diff --git a/amdis/gridfunctions/DiscreteFunction.hpp b/amdis/gridfunctions/DiscreteFunction.hpp
index ada77d7c6091cabd588d237e67f09682c597466a..08581abc332b034420f26cdc6dc8c5a9b4c6a922 100644
--- a/amdis/gridfunctions/DiscreteFunction.hpp
+++ b/amdis/gridfunctions/DiscreteFunction.hpp
@@ -52,12 +52,20 @@ namespace AMDiS
 
   public:
     /// Constructor. Stores a pointer to the mutable `dofvector`.
-    template <class Path>
-    DiscreteFunction(Coefficients& dofVector, GlobalBasis const& basis, Path const& path)
-      : Super(dofVector, basis, path)
+    template <class... Path>
+    DiscreteFunction(Coefficients& dofVector, GlobalBasis const& basis, Path... path)
+      : Super(dofVector, basis, path...)
       , mutableCoeff_(&dofVector)
     {}
 
+    /// Construct a DiscreteFunction directly from a DOFVector
+    template <class DV, class... Path,
+      class Coeff_ = TYPEOF(std::declval<DV>().coefficients()),
+      class GB_    = TYPEOF(*std::declval<DV>().basis())>
+    DiscreteFunction(DV&& dofVector, Path... path)
+      : DiscreteFunction(dofVector.coefficients(), *dofVector.basis(), path...)
+    {}
+
   public:
     /// \brief Interpolation of GridFunction to DOFVector, assuming that there is no
     /// reference to this DOFVector in the expression.
@@ -172,15 +180,24 @@ namespace AMDiS
 
   public:
     /// Constructor. Stores a pointer to the dofVector and a copy of the treePath.
-    template <class Path>
-    DiscreteFunction(Coefficients const& coefficients, GlobalBasis const& basis, Path const& path)
+    template <class... Path>
+    DiscreteFunction(Coefficients const& coefficients, GlobalBasis const& basis, Path... path)
       : coefficients_(&coefficients)
       , basis_(&basis)
-      , treePath_(makeTreePath(path))
+      , treePath_(makeTreePath(path...))
       , entitySet_(basis_->gridView())
       , nodeToRangeEntry_(Dune::Functions::makeDefaultNodeToRangeMap(*basis_, treePath_))
     {}
 
+    /// Construct a DiscreteFunction directly from a DOFVector
+    template <class DV, class... Path,
+      class Coeff_ = TYPEOF(std::declval<DV>().coefficients()),
+      class GB_    = TYPEOF(*std::declval<DV>().basis())>
+    DiscreteFunction(DV const& dofVector, Path... path)
+      : DiscreteFunction(dofVector.coefficients(), *dofVector.basis(), path...)
+    {}
+
+
     /// \brief Evaluate DiscreteFunction in global coordinates. NOTE: expensive
     Range operator()(Domain const& x) const;
 
@@ -229,6 +246,21 @@ namespace AMDiS
     NodeToRangeEntry nodeToRangeEntry_;
   };
 
+  // deduction guides
+
+  template <class Coeff, class GB, class... Path,
+    class TP = TYPEOF(makeTreePath(std::declval<Path>()...)),
+    REQUIRES(Concepts::GlobalBasis<GB>)>
+  DiscreteFunction(Coeff&, GB const&, Path...)
+    -> DiscreteFunction<Coeff,GB,TP>;
+
+  template <class DV, class... Path,
+    class Coeff = decltype(std::declval<DV>().coefficients()),
+    class GB    = decltype(*std::declval<DV>().basis()),
+    class TP    = TYPEOF(makeTreePath(std::declval<Path>()...))>
+  DiscreteFunction(DV&, Path...)
+    -> DiscreteFunction<std::remove_reference_t<Coeff>,std::decay_t<GB>,TP>;
+
 } // end namespace AMDiS
 
 #include "DiscreteLocalFunction.inc.hpp"