diff --git a/src/base_def.h b/src/base_def.h
index d2865c6..56d9d71 100644
--- a/src/base_def.h
+++ b/src/base_def.h
@@ -93,6 +93,10 @@ namespace MultiArrayTools
     template <typename T, class Range, class MARange>
     class Slice;
 
+    // slice.h
+    template <typename T, class Range, class MARange>
+    class ConstSlice;
+
     // manipulator.h
     template <typename T>
     class ManipulatorBase;
diff --git a/src/multi_array.cc b/src/multi_array.cc
index 69179c1..15b2f50 100644
--- a/src/multi_array.cc
+++ b/src/multi_array.cc
@@ -18,13 +18,13 @@ namespace MultiArrayTools
     }
     
     template <typename T, class Range>
-    auto MultiArrayBase<T,Range>::begin() -> decltype(Range().begin())
+    auto MultiArrayBase<T,Range>::begin() const -> decltype(Range().begin())
     {
 	return mRange->begin();
     }
 
     template <typename T, class Range>
-    auto MultiArrayBase<T,Range>::end() -> decltype(Range().end())
+    auto MultiArrayBase<T,Range>::end() const -> decltype(Range().end())
     {
 	return mRange->end();
     }
@@ -119,6 +119,7 @@ namespace MultiArrayTools
 	    mCont.insert(mCont.end(), in[i].mCont.begin(), in[i].mCont.end());
 	}
 	assert(mCont.size() == MAB::mRange->size());
+	return *this;
     }    
     
     template <typename T, class Range>
diff --git a/src/multi_array.h b/src/multi_array.h
index 6631971..6ea374d 100644
--- a/src/multi_array.h
+++ b/src/multi_array.h
@@ -33,8 +33,8 @@ namespace MultiArrayTools
 	virtual size_t size() const; 
 	virtual bool isSlice() const = 0;
 	
-	virtual auto begin() -> decltype(Range().begin());
-	virtual auto end() -> decltype(Range().end());
+	virtual auto begin() const -> decltype(Range().begin());
+	virtual auto end() const -> decltype(Range().end());
 
 	virtual const Range& range() const;
 
diff --git a/src/multi_array_operation.cc b/src/multi_array_operation.cc
index 17aadc4..21043e3 100644
--- a/src/multi_array_operation.cc
+++ b/src/multi_array_operation.cc
@@ -16,7 +16,7 @@ namespace MultiArrayTools
     }
 
     template <typename T>
-    IndefinitIndexBase& MultiArrayOperationBase<T>::index()
+    const IndefinitIndexBase& MultiArrayOperationBase<T>::index() const
     {
 	return *mIibPtr;
     }
@@ -43,9 +43,22 @@ namespace MultiArrayTools
     MultiArrayOperationRoot<T,Range>::makeSlice(MultiArrayOperationRoot<T,RangeX>& in)
     {
 	Slice<T,Range,RangeX>& sl = dynamic_cast<Slice<T,Range,RangeX>&>( mArrayRef );
-	sl.set(in.mArrayRef, name(), dynamic_cast<typename RangeX::IndexType&>( in.index() ), in.name());
+	sl.set(in.mArrayRef, name(), dynamic_cast<const typename RangeX::IndexType&>( in.index() ), in.name());
 	return *this;
     }
+
+    template <typename T, class Range>
+    template <class RangeX>
+    const MultiArrayOperationRoot<T,Range>&
+    MultiArrayOperationRoot<T,Range>::makeConstSlice(const MultiArrayOperationRoot<T,RangeX>& in)
+    {
+	ConstSlice<T,Range,RangeX>& sl = dynamic_cast<ConstSlice<T,Range,RangeX>&>( mArrayRef );
+	sl.set(in.mArrayRef, name(), dynamic_cast<const typename RangeX::IndexType&>( in.index() ), in.name());
+	return *this;
+    }
+
+    
+    // CONST SLICE !!!!!
     
     template <typename T, class Range>
     MultiArrayOperationRoot<T,Range>::
@@ -92,6 +105,18 @@ namespace MultiArrayTools
 	performAssignment(in);
 	return *this;
     }
+
+    template <typename T, class Range>
+    template <class Range2>
+    const MultiArrayOperationRoot<T,Range>&
+    MultiArrayOperationRoot<T,Range>::operator=(const MultiArrayOperationRoot<T,Range2>& in)
+    {
+	if(mArrayRef.isSlice() and not mArrayRef.isInit()){
+	    return makeConstSlice(in);
+	}
+	performAssignment(in);
+	return *this;
+    }
     
     template <typename T, class Range>
     template <class Operation, class... MAOps>
@@ -107,18 +132,18 @@ namespace MultiArrayTools
 	return *this;
     }
 
-    template <typename T, class Range>
+    /*    template <typename T, class Range>
     template <class Operation, class... MAOps>
     MultiArrayOperation<T,Operation,MultiArrayOperationRoot<T,Range>, MAOps...>
-    MultiArrayOperationRoot<T,Range>::operator()(Operation& op, const MAOps&... secs)
+    MultiArrayOperationRoot<T,Range>::operator()(Operation& op, const MAOps&... secs) const
     {
 	return MultiArrayOperation<T,Operation,MultiArrayOperationRoot<T,Range>, MAOps...>(op, *this, secs...);
-    }
+	}*/
 
     template <typename T, class Range>
     template <class Operation, class... MAOps>
     MultiArrayOperation<T,Operation,MultiArrayOperationRoot<T,Range>, MAOps...>
-    MultiArrayOperationRoot<T,Range>::operator()(const Operation& op, const MAOps&... secs)
+    MultiArrayOperationRoot<T,Range>::operator()(const Operation& op, const MAOps&... secs) const
     {
 	return MultiArrayOperation<T,Operation,MultiArrayOperationRoot<T,Range>, MAOps...>(op, *this, secs...);
     }
@@ -192,6 +217,18 @@ namespace MultiArrayTools
     {
 	return (*this) = copyThis() / sec;
     }
+
+    template <typename T, class Range>
+    const MultiArrayBase<T,Range>& MultiArrayOperationRoot<T,Range>::operator*() const
+    {
+	return mArrayRef;
+    }
+
+    template <typename T, class Range>
+    MultiArrayBase<T,Range> const* MultiArrayOperationRoot<T,Range>::operator->() const
+    {
+	return &mArrayRef;
+    }
     
     template <typename T, class Range>
     size_t MultiArrayOperationRoot<T,Range>::argNum() const
@@ -231,6 +268,13 @@ namespace MultiArrayTools
 	mIndex.copyPos(ind);
 	return *this;
     }
+
+    template <typename T, class Range>
+    const MultiArrayOperationRoot<T,Range>& MultiArrayOperationRoot<T,Range>::operator[](const IndexType& ind) const
+    {
+	mIndex.copyPos(ind);
+	return *this;
+    }
     
     /*****************************
      *   MultiArrayOperation     *
@@ -308,7 +352,7 @@ namespace MultiArrayTools
     template <typename T, class Operation, class... MAOps>
     template <class Operation2, class... MAOps2>
     MultiArrayOperation<T,Operation2,MultiArrayOperation<T,Operation,MAOps...>,MAOps2...>
-    MultiArrayOperation<T,Operation,MAOps...>::operator()(Operation2& op, const MAOps2&... secs)
+    MultiArrayOperation<T,Operation,MAOps...>::operator()(Operation2& op, const MAOps2&... secs) const
     {
 	return MultiArrayOperation<T,Operation2,MultiArrayOperation<T,Operation,MAOps...>,
 				   MAOps2...>(op, *this, secs...);
@@ -317,7 +361,7 @@ namespace MultiArrayTools
     template <typename T, class Operation, class... MAOps>
     template <class Operation2, class... MAOps2>
     MultiArrayOperation<T,Operation2,MultiArrayOperation<T,Operation,MAOps...>,MAOps2...>
-    MultiArrayOperation<T,Operation,MAOps...>::operator()(const Operation2& op, const MAOps2&... secs)
+    MultiArrayOperation<T,Operation,MAOps...>::operator()(const Operation2& op, const MAOps2&... secs) const
     {
 	return MultiArrayOperation<T,Operation2,MultiArrayOperation<T,Operation,MAOps...>,
 				   MAOps2...>(op, *this, secs...);
diff --git a/src/multi_array_operation.h b/src/multi_array_operation.h
index 1abebb1..fa3f988 100644
--- a/src/multi_array_operation.h
+++ b/src/multi_array_operation.h
@@ -21,7 +21,7 @@ namespace MultiArrayTools
 	virtual ~MultiArrayOperationBase();
 
 	virtual size_t argNum() const = 0;
-	IndefinitIndexBase& index();
+	const IndefinitIndexBase& index() const;
 	virtual void linkIndicesTo(IndefinitIndexBase* target) const = 0;
 	
 	virtual T& get() = 0;
@@ -37,8 +37,9 @@ namespace MultiArrayTools
     public:
 
 	typedef MultiArrayOperationBase<T> MAOB;
-	typedef decltype(MultiArray<T,Range>().begin()) IndexType;
-	
+	typedef typename Range::IndexType IndexType;
+	//typedef decltype(MultiArray<T,Range>().begin()) IndexType;
+
 	MultiArrayOperationRoot(MultiArrayBase<T,Range>& ma, const Name& nm);
 	MultiArrayOperationRoot& operator=(const MultiArrayOperationRoot& in);
 
@@ -46,17 +47,20 @@ namespace MultiArrayTools
 
 	template <class Range2>
 	MultiArrayOperationRoot& operator=(MultiArrayOperationRoot<T,Range2>& in);
+
+	template <class Range2>
+	const MultiArrayOperationRoot& operator=(const MultiArrayOperationRoot<T,Range2>& in);
 	
 	template <class Operation, class... MAOps>
 	MultiArrayOperationRoot& operator=(const MultiArrayOperation<T,Operation,MAOps...>& in);
 	
-	template <class Operation, class... MAOps>
-	MultiArrayOperation<T,Operation,MultiArrayOperationRoot<T,Range>, MAOps...>
-	operator()(Operation& op, const MAOps&... secs);
+	//template <class Operation, class... MAOps>
+	//MultiArrayOperation<T,Operation,MultiArrayOperationRoot<T,Range>, MAOps...>
+	//operator()(Operation& op, const MAOps&... secs) const;
 
 	template <class Operation, class... MAOps>
 	MultiArrayOperation<T,Operation,MultiArrayOperationRoot<T,Range>, MAOps...>
-	operator()(const Operation& op, const MAOps&... secs);
+	operator()(const Operation& op, const MAOps&... secs) const;
 	
 	template <class MAOp>
 	auto operator+(const MAOp& sec) -> decltype(operator()(std::plus<T>(), sec));
@@ -83,11 +87,15 @@ namespace MultiArrayTools
 
 	template <class MAOp>
 	MultiArrayOperationRoot& operator/=(const MAOp& sec);
+
+	const MultiArrayBase<T,Range>& operator*() const;
+	MultiArrayBase<T,Range> const* operator->() const;
 	
 	virtual size_t argNum() const override;
 
 	// set index -> implement !!!!!
 	MultiArrayOperationRoot<T,Range>& operator[](const IndexType& ind);
+	const MultiArrayOperationRoot<T,Range>& operator[](const IndexType& ind) const;
 	
 	virtual void linkIndicesTo(IndefinitIndexBase* target) const override;
 
@@ -105,6 +113,9 @@ namespace MultiArrayTools
 
 	template <class RangeX>
 	MultiArrayOperationRoot& makeSlice(MultiArrayOperationRoot<T,RangeX>& in);
+
+	template <class RangeX>
+	const MultiArrayOperationRoot& makeConstSlice(const MultiArrayOperationRoot<T,RangeX>& in);
 	
 	MultiArrayBase<T,Range>& mArrayRef;
 	mutable IndexType mIndex;
@@ -124,11 +135,11 @@ namespace MultiArrayTools
 
 	template <class Operation2, class... MAOps2>
 	MultiArrayOperation<T,Operation2,MultiArrayOperation<T,Operation,MAOps...>,MAOps2...>
-	operator()(Operation2& op, const MAOps2&... secs);
+	operator()(Operation2& op, const MAOps2&... secs) const;
 	
 	template <class Operation2, class... MAOps2>
 	MultiArrayOperation<T,Operation2,MultiArrayOperation<T,Operation,MAOps...>,MAOps2...>
-	operator()(const Operation2& op, const MAOps2&... secs);
+	operator()(const Operation2& op, const MAOps2&... secs) const;
 	
 	template <class MAOp2>
 	auto operator+(const MAOp2& sec) -> decltype(operator()(std::plus<T>(), sec));
diff --git a/src/multi_range.cc b/src/multi_range.cc
index cc1ceac..334891b 100644
--- a/src/multi_range.cc
+++ b/src/multi_range.cc
@@ -236,8 +236,8 @@ namespace MultiArrayTools
 	struct MetaPosGetter
 	{
 	    template <class... Indices>
-	    static void getMetaPos(typename MultiIndex<Indices...>::MetaType& target,
-				   const typename MultiIndex<Indices...>::IndexPack& source)
+	    static void getMetaPos(std::tuple<decltype(Indices().getMetaPos())...>& target,
+				   const std::tuple<Indices...>& source)
 	    {
 		std::get<N>(target) = std::get<N>(source).getMetaPos();
 		MetaPosGetter<N-1>::getMetaPos(target, source);
@@ -248,8 +248,8 @@ namespace MultiArrayTools
 	struct MetaPosGetter<0>
 	{
 	    template <class... Indices>
-	    static void getMetaPos(typename MultiIndex<Indices...>::MetaType& target,
-				   const typename MultiIndex<Indices...>::IndexPack& source)
+	    static void getMetaPos(std::tuple<decltype(Indices().getMetaPos())...>& target,
+				   const std::tuple<Indices...>& source)
 	    {
 		std::get<0>(target) = std::get<0>(source).getMetaPos();
 	    }
@@ -614,33 +614,26 @@ namespace MultiArrayTools
     }
 
     template <size_t N>
-    struct MetaTypePrinter
+    struct TuplePrinter
     {
-	template <class... Indices>
-	static void print(std::ostream& os, typename MultiIndex<Indices...>::MetaType& meta)
+	template <typename... Ts>
+	static void print(std::ostream& os, const std::tuple<Ts...>& meta)
 	{
-	    MetaTypePrinter<N-1>::print(os, meta);
+	    TuplePrinter<N-1>::print(os, meta);
 	    os << std::get<N>(meta) << '\t';
 	}
     };
 
     template <>
-    struct MetaTypePrinter<0>
+    struct TuplePrinter<0>
     {
-	template <class... Indices>
-	static void print(std::ostream& os, typename MultiIndex<Indices...>::MetaType& meta)
+	template <typename... Ts>
+	static void print(std::ostream& os, const std::tuple<Ts...>& meta)
 	{
 	    os << std::get<0>(meta) << '\t';
 	}
     };
     
-    template <class... Indices>
-    std::ostream& operator<<(std::ostream& os, typename MultiIndex<Indices...>::MetaType& meta)
-    {
-	MetaTypePrinter<sizeof...(Indices)-1>::print(os, meta);
-	return os;
-    }
-    
     /******************
      *   MultiRange   *
      ******************/
@@ -701,3 +694,11 @@ namespace MultiArrayTools
 	return ++MultiIndex<typename Ranges::IndexType...>(this, is);
     }
 }
+
+template <typename... Ts>
+std::ostream& operator<<(std::ostream& os,
+			 const std::tuple<Ts...>& meta)
+{
+    MultiArrayTools::TuplePrinter<sizeof...(Ts)-1>::print(os, meta);
+    return os;
+}
diff --git a/src/multi_range.h b/src/multi_range.h
index 722d88b..27c1c64 100644
--- a/src/multi_range.h
+++ b/src/multi_range.h
@@ -92,9 +92,6 @@ namespace MultiArrayTools
 	//virtual void assignRange(RangeBase<MultiIndex<Indices...> > const* range) override;
     };
 
-    template <class... Indices>
-    std::ostream& operator<<(std::ostream& os, typename MultiIndex<Indices...>::MetaType& meta);
-    
     /*****************************
      *   IndexGetter Functions   *
      ****************************/
@@ -106,6 +103,7 @@ namespace MultiArrayTools
     public:
 
 	typedef std::tuple<Ranges...> SpaceType;
+	typedef typename RangeBase<MultiIndex<typename Ranges::IndexType...> >::IndexType IndexType;
 	
 	DEFAULT_MEMBERS(MultiRange);
 
@@ -134,6 +132,11 @@ namespace MultiArrayTools
     
 }
 
+template <typename... Ts>
+std::ostream& operator<<(std::ostream& os,
+			 const std::tuple<Ts...>& meta);
+
+
 #include "multi_range.cc"
 
 #endif
diff --git a/src/name.cc b/src/name.cc
index 2f3d710..1c26432 100644
--- a/src/name.cc
+++ b/src/name.cc
@@ -6,39 +6,40 @@ namespace MultiArrayTools
 
     namespace
     {
-
-	void giveNames(std::vector<Name>& nvec)
+	struct Naming
 	{
-	    nvec.clear();
-	}
-
-	void giveNames(std::vector<Name>& nvec, const Name& name)
-	{
-	    nvec.push_back(name);
-	}
-
-	template <class... NameTypes>
-	void giveNames(std::vector<Name>& nvec, const Name& name1, const Name& name2, const NameTypes&... names)
-	{
-	    nvec.push_back(name1);
-	    giveNames(nvec, name2, names...);
-	}
-
-	
+	    static void giveNames(std::vector<Name>& nvec)
+	    {
+		nvec.clear();
+	    }
+	    
+	    static void giveNames(std::vector<Name>& nvec, const Name& name)
+	    {
+		nvec.push_back(name);
+	    }
+	    
+	    template <class... NameTypes>
+	    static void giveNames(std::vector<Name>& nvec, const Name& name1,
+				  const Name& name2, const NameTypes&... names)
+	    {
+		nvec.push_back(name1);
+		giveNames(nvec, name2, names...);
+	    }
+	};	
     }
     
     template <class... NameTypes>
     Name::Name(const std::string& mainName, const NameTypes&... names) : mMain(mainName)
     {
 	mSub.reserve(sizeof...(NameTypes));
-	giveNames(mSub, names...);
+	Naming::giveNames(mSub, names...);
     }
 
     template <class... NameTypes>
     Name::Name(char const* mainName, const NameTypes&... names) : mMain(mainName)
     {
 	mSub.reserve(sizeof...(NameTypes));
-	giveNames(mSub, names...);
+	Naming::giveNames(mSub, names...);
     }
     
     const std::string& Name::own() const
@@ -67,17 +68,18 @@ namespace MultiArrayTools
 	return mSub.size();
     }
 
-    std::ostream& operator<<(std::ostream& os, const Name& name)
-    {
-	if(name.size() != 0){
-	    for(size_t i = 0; i != name.size(); ++i){
-		os << name.get(i) << '\t';
-	    }
-	}
-	else {
-	    os << name.own();
-	}
-	return os;
-    }
-    
 }
+
+std::ostream& operator<<(std::ostream& os, const MultiArrayTools::Name& name)
+{
+    if(name.size() != 0){
+	for(size_t i = 0; i != name.size(); ++i){
+	    os << name.get(i) << '\t';
+	}
+    }
+    else {
+	os << name.own();
+    }
+    return os;
+}
+
diff --git a/src/name.h b/src/name.h
index 0e466de..490def5 100644
--- a/src/name.h
+++ b/src/name.h
@@ -33,11 +33,11 @@ namespace MultiArrayTools
 	std::string mMain;
 	std::vector<Name> mSub;	
     };
-
-    std::ostream& operator<<(std::ostream& os, const Name& name);
     
 }
 
+std::ostream& operator<<(std::ostream& os, const MultiArrayTools::Name& name);
+
 #include "name.cc"
 
 #endif
diff --git a/src/single_range.cc b/src/single_range.cc
index 779e97c..f6b5d71 100644
--- a/src/single_range.cc
+++ b/src/single_range.cc
@@ -288,7 +288,7 @@ namespace MultiArrayTools
     }
     
     template <typename U, RangeType TYPE>
-    const U& SingleIndex<U,TYPE>::getMetaPos() const
+    U SingleIndex<U,TYPE>::getMetaPos() const
     {
 	return dynamic_cast<SingleRange<U,TYPE> const*>( IB::mRange )->get(IIB::pos());
     }
@@ -346,6 +346,11 @@ namespace MultiArrayTools
 	}
     }
     
+    std::ostream& operator<<(std::ostream& os, VET vet)
+    {
+	os << ( (vet == VET::VALUE) ? std::string("VALUE") : std::string("ERROR") );
+	return os;
+    }
     
     /*
     template <typename U, RangeType TYPE>
diff --git a/src/single_range.h b/src/single_range.h
index 40f1e98..ab38d9e 100644
--- a/src/single_range.h
+++ b/src/single_range.h
@@ -43,7 +43,7 @@ namespace MultiArrayTools
 
 	virtual MultiRangeType rangeType() const override;
 
-	virtual const U& getMetaPos() const;
+	virtual U getMetaPos() const;
 	virtual SingleIndex& atMeta(const U& metaPos);
 	
 	virtual size_t dim() const override; // = 1
@@ -65,12 +65,15 @@ namespace MultiArrayTools
     class SingleRange : public RangeBase<SingleIndex<U,TYPE> >
     {
     public:
+	typedef typename RangeBase<SingleIndex<U,TYPE> >::IndexType IndexType;
+	
 	DEFAULT_MEMBERS(SingleRange);
 
 	SingleRange(const std::vector<U>& space);
 	
 	virtual size_t size() const override;
-	
+
+	//U get(size_t pos) const;
 	const U& get(size_t pos) const;
 	size_t getMeta(const U& metaPos) const;
 
@@ -89,6 +92,8 @@ namespace MultiArrayTools
     class SingleRange<int,RangeType::SPACE> : public RangeBase<SingleIndex<int,RangeType::SPACE> >
     {
     public:
+	typedef typename RangeBase<SingleIndex<int,RangeType::SPACE> >::IndexType IndexType;
+	
 	DEFAULT_MEMBERS(SingleRange);
 
 	SingleRange(int begin, int end);
@@ -112,6 +117,8 @@ namespace MultiArrayTools
     class SingleRange<size_t,RangeType::ENSEMBLE> : public RangeBase<SingleIndex<size_t,RangeType::ENSEMBLE> >
     {
     public:
+	typedef typename RangeBase<SingleIndex<size_t,RangeType::ENSEMBLE> >::IndexType IndexType;
+	
 	DEFAULT_MEMBERS(SingleRange);
 
 	SingleRange(size_t num);
@@ -136,10 +143,14 @@ namespace MultiArrayTools
 	ERROR = 1
     };
 
+    std::ostream& operator<<(std::ostream& os, VET vet);
+    
     template <>
     class SingleRange<VET,RangeType::VALUE_ERROR> : public RangeBase<SingleIndex<VET,RangeType::VALUE_ERROR> >
     {
     public:
+	typedef typename RangeBase<SingleIndex<VET,RangeType::VALUE_ERROR> >::IndexType IndexType;
+	
 	DEFAULT_MEMBERS(SingleRange);
 
 	virtual size_t size() const override;
@@ -157,6 +168,8 @@ namespace MultiArrayTools
     class SingleRange<size_t,RangeType::LORENTZ> : public RangeBase<SingleIndex<size_t,RangeType::LORENTZ> >
     {
     public:
+	typedef typename RangeBase<SingleIndex<size_t,RangeType::LORENTZ> >::IndexType IndexType;
+	
 	DEFAULT_MEMBERS(SingleRange);
 
 	virtual size_t size() const override;
diff --git a/src/slice.cc b/src/slice.cc
index 437822a..7d7ac40 100644
--- a/src/slice.cc
+++ b/src/slice.cc
@@ -32,13 +32,13 @@ namespace MultiArrayTools
     }
 
     template <typename T, class Range, class MARange>
-    auto Slice<T,Range,MARange>::begin() -> decltype(Range().begin())
+    auto Slice<T,Range,MARange>::begin() const -> decltype(Range().begin())
     {
 	return MAB::mRange->begin();
     }
 
     template <typename T, class Range, class MARange>
-    auto Slice<T,Range,MARange>::end() -> decltype(Range().end())
+    auto Slice<T,Range,MARange>::end() const -> decltype(Range().end())
     {
 	return MAB::mRange->end();
     }
@@ -58,4 +58,50 @@ namespace MultiArrayTools
 	//mOwnIdx = i.pos();
 	return (*mMultiArrayPtr)[ mMAIdx ];
     }
+
+    template <typename T, class Range, class MARange>
+    ConstSlice<T,Range,MARange>::
+    ConstSlice(const Range& range) :
+	MultiArrayBase<T,Range>(range) {}
+
+    template <typename T, class Range, class MARange>
+    bool ConstSlice<T,Range,MARange>::isSlice() const
+    {
+	return true;
+    }
+
+    template <typename T, class Range, class MARange>
+    void ConstSlice<T,Range,MARange>::set(const MultiArrayBase<T,MARange>& multiArrayRef,
+					  const Name& ownNm, // for correct linkage
+					  const typename MARange::IndexType& MAIdx, // for desired slice position
+					  const Name& MANm) // for correct linkage)
+    {
+	MAB::mInit = true;
+	mMultiArrayPtr = &multiArrayRef;
+	mMAIdx = MAIdx;
+	mOwnIdx = MAB::mRange->begin();
+	mMAIdx.name(MANm);
+	mOwnIdx.name(ownNm);
+	mMAIdx.linkTo(&mOwnIdx);
+    }
+
+    template <typename T, class Range, class MARange>
+    auto ConstSlice<T,Range,MARange>::begin() const -> decltype(Range().begin())
+    {
+	return MAB::mRange->begin();
+    }
+
+    template <typename T, class Range, class MARange>
+    auto ConstSlice<T,Range,MARange>::end() const -> decltype(Range().end())
+    {
+	return MAB::mRange->end();
+    }
+
+    template <typename T, class Range, class MARange>
+    const T& ConstSlice<T,Range,MARange>::operator[](const typename Range::IndexType& i) const
+    {
+	mOwnIdx.copyPos(i);
+	//mOwnIdx = i.pos();
+	return (*mMultiArrayPtr)[ mMAIdx ];
+    }
 }
diff --git a/src/slice.h b/src/slice.h
index de08ebe..09c66f8 100644
--- a/src/slice.h
+++ b/src/slice.h
@@ -29,8 +29,8 @@ namespace MultiArrayTools
 	//Slice& setSlicePos(const Index& slicePos);
 	
 	// link given Index to mMAPtr which is index of total array
-	virtual auto begin() -> decltype(Range().begin()) override; 
-	virtual auto end() -> decltype(Range().end()) override;
+	virtual auto begin() const -> decltype(Range().begin()) override; 
+	virtual auto end() const -> decltype(Range().end()) override;
 
 	virtual bool isSlice() const override;
 
@@ -45,6 +45,37 @@ namespace MultiArrayTools
 	mutable typename Range::IndexType mOwnIdx;
 	mutable typename MARange::IndexType mMAIdx;
     };
+
+    template <typename T, class Range, class MARange/*, class Index*/>
+    class ConstSlice : public MultiArrayBase<T,Range> // yes, 'Range' is correct !!!
+    {
+    public:
+
+	typedef MultiArrayBase<T,Range> MAB;
+
+	ConstSlice(const Range& range);
+
+	virtual const T& operator[](const typename Range::IndexType& i) const override;
+	
+	//Slice& setSlicePos(const Index& slicePos);
+	
+	// link given Index to mMAPtr which is index of total array
+	virtual auto begin() const -> decltype(Range().begin()) override; 
+	virtual auto end() const -> decltype(Range().end()) override;
+
+	virtual bool isSlice() const override;
+
+	void set(const MultiArrayBase<T,MARange>& multiArrayRef,
+		 const Name& ownNm,
+		 const typename MARange::IndexType& MAIdx,
+		 const Name& MANm); 
+	
+    private:
+	
+	MultiArrayBase<T,MARange> const* mMultiArrayPtr = nullptr;
+	mutable typename Range::IndexType mOwnIdx;
+	mutable typename MARange::IndexType mMAIdx;
+    };
     
     
 }