Index: cppstreams/stream.h
===================================================================
--- cppstreams/stream.h	(revision 3)
+++ cppstreams/stream.h	(revision 16)
@@ -3,5 +3,5 @@
  * All rights reserved.
  *
- * This software was developed by Attila Gobi and Zalan Szugyi. 
+ * This software was developed by Attila Gobi and Zalan Szugyi.
  * The project was supported by the European Union and co-financed by the
  * European Social Fund (grant agreement no. TAMOP 4.2.1./B-09/1/KMR-2010-0003)
@@ -9,7 +9,7 @@
  * Redistribution and use in source and binary forms, with or without
  * modification, are permitted provided that the following conditions are met:
- * 1. Redistributions of source code must retain the above copyright 
+ * 1. Redistributions of source code must retain the above copyright
  *    notice, this list of conditions and the following disclaimer.
- * 2. Redistributions in binary form must reproduce the above copyright 
+ * 2. Redistributions in binary form must reproduce the above copyright
  *    notice, this list of conditions and the following disclaimer in the
  *    documentation and/or other materials provided with the distribution.
@@ -61,5 +61,5 @@
     stream(const stream<T> &o)
         : impl_(o.impl_->clone())
-    { 
+    {
     }
 
@@ -69,13 +69,13 @@
         std::swap(impl_, o.impl_);
     }
-    
+
     stream<T> & operator = (stream<T> &&o)
     {
-    	if(this != &o) {
-    		std::swap(impl_, o.impl_);
-    		return *this;
-    	}
-    }
-    
+        if(this != &o) {
+            std::swap(impl_, o.impl_);
+            return *this;
+        }
+    }
+
     ~stream()
     {
@@ -84,5 +84,5 @@
 
     struct iterator {
-        iterator& operator ++() 
+        iterator& operator ++()
         {
             (*impl_)->next(*this);
@@ -128,8 +128,8 @@
     struct addimpl: public impl {
         addimpl(const T &a, ST &&s)
-            : a_(a), s_(std::forward<ST>(s)) 
+            : a_(a), s_(std::forward<ST>(s))
         { }
 
-        const T &get(const iterator &) 
+        const T &get(const iterator &)
         {
             return a_;
@@ -141,5 +141,5 @@
         }
 
-        impl *clone() 
+        impl *clone()
         {
             return new addimpl<ST>(a_, std::forward<ST>(s_));
@@ -160,5 +160,5 @@
 
         const T &get(const iterator &it)
-        { 
+        {
             *(it.impl_)=new addimpl<stream<T>&&>(op_(*it1), stream<T>(this));
             ++it1;
@@ -166,5 +166,5 @@
         }
 
-        void next(iterator &it) 
+        void next(iterator &it)
         {
             *(it.impl_)=new addimpl<stream<T>&&>(op_(*it1), stream<T>(this));
@@ -173,5 +173,5 @@
         }
 
-        impl *clone() 
+        impl *clone()
         {
             return new mapimpl2<Op, ST>(op_, std::forward<ST>(s_));
@@ -181,5 +181,5 @@
         iterator it1;
         Op op_;
-	};
+    };
 
     template<typename Op, typename ST>
@@ -189,9 +189,9 @@
         { }
 
-        const T &get(const iterator &it) 
+        const T &get(const iterator &it)
         {
             impl *x = new mapimpl2<Op, ST>(op_, std::forward<ST>(s_));
             *(it.impl_) = x;
-            
+
             delete this;
             return *it;
@@ -206,5 +206,5 @@
         }
 
-        impl *clone() 
+        impl *clone()
         {
             return new mapimpl<Op, ST>(op_, std::forward<ST>(s_));
@@ -213,5 +213,5 @@
     private:
         typename storage_type<ST>::type s_;
-		Op op_;
+        Op op_;
     };
 
@@ -223,6 +223,6 @@
         { }
 
-        const T &get(const iterator &it) 
-        { 
+        const T &get(const iterator &it)
+        {
             impl *x = new zipimpl2<Op, ST1, ST2>(op_, std::forward<ST1>(s1_), std::forward<ST2>(s2_));
             *(it.impl_) = x;
@@ -231,5 +231,5 @@
         }
 
-        void next(iterator &it) 
+        void next(iterator &it)
         {
             impl *x = new zipimpl2<Op, ST1, ST2>(op_, std::forward<ST1>(s1_), std::forward<ST2>(s2_));
@@ -239,5 +239,5 @@
         }
 
-        impl *clone() 
+        impl *clone()
         {
             return new zipimpl<Op, ST1, ST2>(op_, std::forward<ST1>(s1_), std::forward<ST2>(s2_));
@@ -259,5 +259,5 @@
 
         const T &get(const iterator &it)
-        { 
+        {
             *(it.impl_)=new addimpl<stream<T>&&>(op_(*it1, *it2), stream<T>(this));
             ++it1;
@@ -266,5 +266,5 @@
         }
 
-        void next(iterator &it) 
+        void next(iterator &it)
         {
             *(it.impl_)=new addimpl<stream<T>&&>(op_(*it1, *it2), stream<T>(this));
@@ -274,5 +274,5 @@
         }
 
-        impl *clone() 
+        impl *clone()
         {
             return new zipimpl2<Op, ST1, ST2>(op_, std::forward<ST1>(s1_), std::forward<ST2>(s2_));
@@ -286,7 +286,7 @@
 
 public:
-	template <typename S, typename U>
-	friend stream<U> operator <<= (const U& a, S && s);
-    
+    template <typename S, typename U>
+    friend stream<U> operator <<= (const U& a, S && s);
+
     template <typename Op, typename ST1, typename ST2>
     static stream<T> zipwith(Op op, ST1 &&s1, ST2 &&s2)
@@ -294,6 +294,6 @@
         return stream(new zipimpl<Op, decltype(s1), decltype(s2)>(op, std::forward<ST1>(s1), std::forward<ST2>(s2)));
     }
-    
-	template <typename ST1, typename Op>
+
+    template <typename ST1, typename Op>
     static stream<T> map(Op op, ST1 &&s1)
     {
@@ -301,9 +301,9 @@
     }
 
-	static stream<T> pure(const T& v)
-	{
-		stream<T> s = v<<=s;
-		return s;
-	}
+    static stream<T> pure(const T& v)
+    {
+        stream<T> s = v<<=s;
+        return s;
+    }
 };
 
@@ -311,5 +311,5 @@
 struct stream_value_type
 {
-	typedef typename std::remove_reference<ST>::type::value_type type;
+    typedef typename std::remove_reference<ST>::type::value_type type;
 };
 
@@ -317,11 +317,11 @@
 stream<U> operator <<= (const U& a, S && s)
 {
-	return stream<U>(new typename stream<U>::template addimpl<decltype(s)>(a, std::forward<S>(s)));
-}
-    
+    return stream<U>(new typename stream<U>::template addimpl<decltype(s)>(a, std::forward<S>(s)));
+}
+
 template<typename ST1, typename ST2, typename T=typename stream_value_type<ST1>::type>
 stream<T> operator +(ST1 &&s1, ST2 &&s2)
 {
-	return stream<T>::zipwith(std::plus<T>(), std::forward<ST1>(s1), std::forward<ST2>(s2));
+    return stream<T>::zipwith(std::plus<T>(), std::forward<ST1>(s1), std::forward<ST2>(s2));
 }
 
@@ -329,5 +329,5 @@
 stream<T> operator -(ST1 &&s1, ST2 &&s2)
 {
-	return stream<T>::zipwith(std::minus<T>(), std::forward<ST1>(s1), std::forward<ST2>(s2));
+    return stream<T>::zipwith(std::minus<T>(), std::forward<ST1>(s1), std::forward<ST2>(s2));
 }
 
@@ -335,5 +335,5 @@
 stream<T> operator *(ST1 &&s1, ST2 &&s2)
 {
-	return stream<T>::zipwith(std::multiplies<T>(), std::forward<ST1>(s1), std::forward<ST2>(s2));
+    return stream<T>::zipwith(std::multiplies<T>(), std::forward<ST1>(s1), std::forward<ST2>(s2));
 }
 
@@ -341,5 +341,5 @@
 stream<T> operator /(ST1 &&s1, ST2 &&s2)
 {
-	return stream<T>::zipwith(std::divides<T>(), std::forward<ST1>(s1), std::forward<ST2>(s2));
+    return stream<T>::zipwith(std::divides<T>(), std::forward<ST1>(s1), std::forward<ST2>(s2));
 }
 
@@ -347,5 +347,5 @@
 stream<T> operator %(ST1 &&s1, ST2 &&s2)
 {
-	return stream<T>::zipwith(std::modulus<T>(), std::forward<ST1>(s1), std::forward<ST2>(s2));
+    return stream<T>::zipwith(std::modulus<T>(), std::forward<ST1>(s1), std::forward<ST2>(s2));
 }
 
@@ -353,5 +353,5 @@
 stream<T> operator -(ST &&s)
 {
-	return stream<T>::map(std::negate<T>(), std::forward<ST>(s));
+    return stream<T>::map(std::negate<T>(), std::forward<ST>(s));
 }
 
@@ -360,16 +360,16 @@
 struct stream_proxy
 {
-	stream_proxy(unsigned long long i): x(i) {}
-	template <typename T>
-	operator stream<T> () {
-		stream<T> a = static_cast<T>(x)<<=a;
-		return a;
-	}
-	unsigned long long x;
+    stream_proxy(unsigned long long i): x(i) {}
+    template <typename T>
+    operator stream<T> () {
+        stream<T> a = static_cast<T>(x)<<=a;
+        return a;
+    }
+    unsigned long long x;
 };
 
 stream_proxy operator "" _s (unsigned long long i)
 {
-	return stream_proxy(i);
+    return stream_proxy(i);
 }
 
