diff --git a/sprout/complex/operators.hpp b/sprout/complex/operators.hpp
index c909ff04..5dc3c99f 100644
--- a/sprout/complex/operators.hpp
+++ b/sprout/complex/operators.hpp
@@ -8,8 +8,8 @@
 #ifndef SPROUT_COMPLEX_OPERATORS_HPP
 #define SPROUT_COMPLEX_OPERATORS_HPP
 
-#include <iosfwd>
-#include <ios>
+#include <istream>
+#include <ostream>
 #include <sprout/config.hpp>
 #include <sprout/complex/complex.hpp>
 
diff --git a/sprout/functional/ref.hpp b/sprout/functional/ref.hpp
index 72d4ae4f..0d39d429 100644
--- a/sprout/functional/ref.hpp
+++ b/sprout/functional/ref.hpp
@@ -13,6 +13,7 @@
 #include <sprout/config.hpp>
 #include <sprout/utility/forward.hpp>
 #include <sprout/type_traits/integral_constant.hpp>
+#include <sprout/type_traits/identity.hpp>
 #include <sprout/type_traits/has_xxx.hpp>
 #include <sprout/type_traits/inherit_if_xxx.hpp>
 #include <sprout/functional/base.hpp>
@@ -235,20 +236,17 @@ namespace sprout {
 	// unwrap_reference
 	//
 	template<typename T>
-	struct unwrap_reference {
-	public:
-		typedef T type;
-	};
+	struct unwrap_reference
+		: public sprout::identity<T>
+	{};
 	template<typename T>
-	struct unwrap_reference<sprout::reference_wrapper<T> > {
-	public:
-		typedef T type;
-	};
+	struct unwrap_reference<sprout::reference_wrapper<T> >
+		: public sprout::identity<T>
+	{};
 	template<typename T>
-	struct unwrap_reference<std::reference_wrapper<T> > {
-	public:
-		typedef T type;
-	};
+	struct unwrap_reference<std::reference_wrapper<T> >
+		: public sprout::identity<T>
+	{};
 	template<typename T>
 	struct unwrap_reference<T const>
 		: public sprout::unwrap_reference<T>
@@ -266,20 +264,17 @@ namespace sprout {
 	// strip_reference
 	//
 	template<typename T>
-	struct strip_reference {
-	public:
-		typedef T type;
-	};
+	struct strip_reference
+		: public sprout::identity<T>
+	{};
 	template<typename T>
-	struct strip_reference<sprout::reference_wrapper<T> > {
-	public:
-		typedef T& type;
-	};
+	struct strip_reference<sprout::reference_wrapper<T> >
+		: public sprout::identity<T&>
+	{};
 	template<typename T>
-	struct strip_reference<std::reference_wrapper<T> > {
-	public:
-		typedef T& type;
-	};
+	struct strip_reference<std::reference_wrapper<T> >
+		: public sprout::identity<T&>
+	{};
 	template<typename T>
 	struct strip_reference<T const>
 		: public sprout::strip_reference<T>
diff --git a/sprout/logic/tribool/io.hpp b/sprout/logic/tribool/io.hpp
index c7d7cf9b..d14fa5c5 100644
--- a/sprout/logic/tribool/io.hpp
+++ b/sprout/logic/tribool/io.hpp
@@ -10,8 +10,8 @@
 
 #include <locale>
 #include <string>
-#include <iosfwd>
-#include <ios>
+#include <istream>
+#include <ostream>
 #include <sprout/config.hpp>
 #include <sprout/utility/noncopyable.hpp>
 #include <sprout/logic/tribool/tribool.hpp>
diff --git a/sprout/memory.hpp b/sprout/memory.hpp
index 0cfa73e5..06d309f6 100644
--- a/sprout/memory.hpp
+++ b/sprout/memory.hpp
@@ -11,5 +11,8 @@
 #include <sprout/config.hpp>
 #include <sprout/memory/addressof.hpp>
 #include <sprout/memory/exempt_ptr.hpp>
+#include <sprout/memory/observer_ptr.hpp>
+#include <sprout/memory/pointer_cast.hpp>
+#include <sprout/memory/get_pointer.hpp>
 
 #endif	// #ifndef SPROUT_MEMORY_HPP
diff --git a/sprout/memory/exempt_ptr.hpp b/sprout/memory/exempt_ptr.hpp
index a0e472a4..b587f01e 100644
--- a/sprout/memory/exempt_ptr.hpp
+++ b/sprout/memory/exempt_ptr.hpp
@@ -12,9 +12,14 @@
 #include <iterator>
 #include <type_traits>
 #include <utility>
+#include <ostream>
 #include <sprout/config.hpp>
 #include <sprout/workaround/std/cstddef.hpp>
 #include <sprout/functional/hash.hpp>
+#include <sprout/functional/less.hpp>
+#include <sprout/type_traits/common_decay.hpp>
+#include <sprout/memory/pointer_cast.hpp>
+#include <sprout/memory/get_pointer.hpp>
 
 namespace sprout {
 	//
@@ -100,10 +105,7 @@ namespace sprout {
 		SPROUT_EXPLICIT_CONVERSION SPROUT_CONSTEXPR operator bool() const SPROUT_NOEXCEPT {
 			return get();
 		}
-		SPROUT_CONSTEXPR operator pointer() SPROUT_NOEXCEPT {
-			return get();
-		}
-		SPROUT_CONSTEXPR operator const_pointer() const SPROUT_NOEXCEPT {
+		SPROUT_EXPLICIT_CONVERSION SPROUT_CONSTEXPR operator pointer() const SPROUT_NOEXCEPT {
 			return get();
 		}
 		SPROUT_CXX14_CONSTEXPR pointer
@@ -186,25 +188,27 @@ namespace sprout {
 	operator!=(sprout::exempt_ptr<T> const& x, sprout::exempt_ptr<U> const& y) SPROUT_NOEXCEPT {
 		return !(x == y);
 	}
+
 	template<typename T>
 	inline SPROUT_CONSTEXPR bool
-	operator==(sprout::exempt_ptr<T> const& x, std::nullptr_t y) SPROUT_NOEXCEPT {
-		return x.get() == y;
+	operator==(sprout::exempt_ptr<T> const& x, std::nullptr_t) SPROUT_NOEXCEPT {
+		return !x;
 	}
 	template<typename T>
 	inline SPROUT_CONSTEXPR bool
-	operator!=(sprout::exempt_ptr<T> const& x, std::nullptr_t y) SPROUT_NOEXCEPT {
-		return !(x == y);
+	operator!=(sprout::exempt_ptr<T> const& x, std::nullptr_t) SPROUT_NOEXCEPT {
+		return static_cast<bool>(x);
+	}
+
+	template<typename T>
+	inline SPROUT_CONSTEXPR bool
+	operator==(std::nullptr_t, sprout::exempt_ptr<T> const& y) SPROUT_NOEXCEPT {
+		return !y;
 	}
 	template<typename T>
 	inline SPROUT_CONSTEXPR bool
-	operator==(std::nullptr_t x, sprout::exempt_ptr<T> const& y) SPROUT_NOEXCEPT {
-		return x == y.get();
-	}
-	template<typename T>
-	inline SPROUT_CONSTEXPR bool
-	operator!=(std::nullptr_t x, sprout::exempt_ptr<T> const& y) SPROUT_NOEXCEPT {
-		return !(x == y);
+	operator!=(std::nullptr_t, sprout::exempt_ptr<T> const& y) SPROUT_NOEXCEPT {
+		return static_cast<bool>(y);
 	}
 	//
 	// operator<
@@ -215,7 +219,8 @@ namespace sprout {
 	template<typename T, typename U>
 	inline SPROUT_CONSTEXPR bool
 	operator<(sprout::exempt_ptr<T> const& x, sprout::exempt_ptr<U> const& y) {
-		return x.get() < y.get();
+		typedef typename sprout::common_decay<T*, U*>::type type;
+		return sprout::less<type>()(x.get(), y.get());
 	}
 	template<typename T, typename U>
 	inline SPROUT_CONSTEXPR bool
@@ -232,6 +237,48 @@ namespace sprout {
 	operator>=(sprout::exempt_ptr<T> const& x, sprout::exempt_ptr<U> const& y) {
 		return !(x < y);
 	}
+
+	template<typename T>
+	inline SPROUT_CONSTEXPR bool
+	operator<(sprout::exempt_ptr<T> const& x, std::nullptr_t y) {
+		return sprout::less<T*>()(x.get(), y);
+	}
+	template<typename T>
+	inline SPROUT_CONSTEXPR bool
+	operator>(sprout::exempt_ptr<T> const& x, std::nullptr_t y) {
+		return y < x;
+	}
+	template<typename T>
+	inline SPROUT_CONSTEXPR bool
+	operator<=(sprout::exempt_ptr<T> const& x, std::nullptr_t y) {
+		return !(y < x);
+	}
+	template<typename T>
+	inline SPROUT_CONSTEXPR bool
+	operator>=(sprout::exempt_ptr<T> const& x, std::nullptr_t y) {
+		return !(x < y);
+	}
+
+	template<typename T>
+	inline SPROUT_CONSTEXPR bool
+	operator<(std::nullptr_t x, sprout::exempt_ptr<T> const& y) {
+		return sprout::less<T*>()(x, y.get());
+	}
+	template<typename T>
+	inline SPROUT_CONSTEXPR bool
+	operator>(std::nullptr_t x, sprout::exempt_ptr<T> const& y) {
+		return y < x;
+	}
+	template<typename T>
+	inline SPROUT_CONSTEXPR bool
+	operator<=(std::nullptr_t x, sprout::exempt_ptr<T> const& y) {
+		return !(y < x);
+	}
+	template<typename T>
+	inline SPROUT_CONSTEXPR bool
+	operator>=(std::nullptr_t x, sprout::exempt_ptr<T> const& y) {
+		return !(x < y);
+	}
 	//
 	// operator+
 	// operator-
@@ -246,6 +293,14 @@ namespace sprout {
 	operator-(sprout::exempt_ptr<T> const& x, sprout::exempt_ptr<T> const& y) {
 		return x.get() - y.get();
 	}
+	//
+	// operator<<
+	//
+	template<typename T, typename Elem, typename Traits>
+	inline SPROUT_CONSTEXPR std::basic_ostream<Elem, Traits>&
+	operator<<(std::basic_ostream<Elem, Traits>& lhs, sprout::exempt_ptr<T> const& rhs) {
+		return lhs << rhs.get();
+	}
 }	// namespace sprout
 
 namespace sprout {
@@ -276,4 +331,46 @@ namespace std {
 #endif
 }	// namespace std
 
+namespace sprout {
+	//
+	// static_pointer_cast
+	// const_pointer_cast
+	// dynamic_pointer_cast
+	// reinterpret_pointer_cast
+	//
+	template<typename T, typename U>
+	inline SPROUT_CONSTEXPR sprout::exempt_ptr<T>
+	static_pointer_cast(sprout::exempt_ptr<U> const& p) {
+		typedef typename sprout::exempt_ptr<T>::element_type element_type;
+		return sprout::exempt_ptr<T>(sprout::static_pointer_cast<element_type>(p.get()));
+	}
+	template<typename T, typename U>
+	inline SPROUT_CONSTEXPR sprout::exempt_ptr<T>
+	const_pointer_cast(sprout::exempt_ptr<U> const& p) {
+		typedef typename sprout::exempt_ptr<T>::element_type element_type;
+		return sprout::exempt_ptr<T>(sprout::const_pointer_cast<element_type>(p.get()));
+	}
+	template<typename T, typename U>
+	inline SPROUT_CONSTEXPR sprout::exempt_ptr<T>
+	dynamic_pointer_cast(sprout::exempt_ptr<U> const& p) {
+		typedef typename sprout::exempt_ptr<T>::element_type element_type;
+		return sprout::exempt_ptr<T>(sprout::dynamic_pointer_cast<element_type>(p.get()));
+	}
+	template<typename T, typename U>
+	inline SPROUT_CONSTEXPR sprout::exempt_ptr<T>
+	reinterpret_pointer_cast(sprout::exempt_ptr<U> const& p) {
+		typedef typename sprout::exempt_ptr<T>::element_type element_type;
+		return sprout::exempt_ptr<T>(sprout::reinterpret_pointer_cast<element_type>(p.get()));
+	}
+
+	//
+	// get_pointer
+	//
+	template<typename T>
+	inline SPROUT_NON_CONSTEXPR T*
+	get_pointer(sprout::exempt_ptr<T> const& p) SPROUT_NOEXCEPT {
+	    return p.get();
+	}
+}	// namespace sprout
+
 #endif	// #ifndef SPROUT_MEMORY_EXEMPT_PTR_HPP
diff --git a/sprout/memory/get_pointer.hpp b/sprout/memory/get_pointer.hpp
new file mode 100644
index 00000000..e470cd4e
--- /dev/null
+++ b/sprout/memory/get_pointer.hpp
@@ -0,0 +1,46 @@
+/*=============================================================================
+  Copyright (c) 2011-2014 Bolero MURAKAMI
+  https://github.com/bolero-MURAKAMI/Sprout
+
+  Distributed under the Boost Software License, Version 1.0. (See accompanying
+  file LICENSE_1_0.txt or copy at http://www.boost.org/LICENSE_1_0.txt)
+=============================================================================*/
+#ifndef SPROUT_MEMORY_GET_POINTER_HPP
+#define SPROUT_MEMORY_GET_POINTER_HPP
+
+#include <memory>
+#include <sprout/config.hpp>
+
+namespace sprout {
+	//
+	// get_pointer
+	//
+	template<typename T>
+	inline SPROUT_CONSTEXPR T*
+	get_pointer(T* p) SPROUT_NOEXCEPT {
+	    return p;
+	}
+
+	template<typename T>
+	inline SPROUT_NON_CONSTEXPR T*
+	get_pointer(std::auto_ptr<T> const& p) SPROUT_NOEXCEPT {
+	    return p.get();
+	}
+
+#if !defined(SPROUT_NO_CXX11_SMART_PTR)
+	template<typename T>
+	inline SPROUT_NON_CONSTEXPR T*
+	get_pointer(std::unique_ptr<T> const& p) SPROUT_NOEXCEPT {
+	    return p.get();
+	}
+
+	template<typename T>
+	inline SPROUT_NON_CONSTEXPR T*
+	get_pointer(std::shared_ptr<T> const& p) SPROUT_NOEXCEPT {
+	    return p.get();
+	}
+#endif
+}	// namespace sprout
+
+
+#endif	// #ifndef SPROUT_MEMORY_GET_POINTER_HPP
diff --git a/sprout/memory/observer_ptr.hpp b/sprout/memory/observer_ptr.hpp
new file mode 100644
index 00000000..df65087d
--- /dev/null
+++ b/sprout/memory/observer_ptr.hpp
@@ -0,0 +1,33 @@
+/*=============================================================================
+  Copyright (c) 2011-2014 Bolero MURAKAMI
+  https://github.com/bolero-MURAKAMI/Sprout
+
+  Distributed under the Boost Software License, Version 1.0. (See accompanying
+  file LICENSE_1_0.txt or copy at http://www.boost.org/LICENSE_1_0.txt)
+=============================================================================*/
+#ifndef SPROUT_MEMORY_OBSERVER_PTR_HPP
+#define SPROUT_MEMORY_OBSERVER_PTR_HPP
+
+#include <sprout/config.hpp>
+#include <sprout/memory/exempt_ptr.hpp>
+
+namespace sprout {
+	//
+	// make_observer
+	//
+	template<typename T>
+	inline SPROUT_CONSTEXPR sprout::exempt_ptr<T>
+	make_observer(T* p) SPROUT_NOEXCEPT {
+		return sprout::exempt_ptr<T>(p);
+	}
+
+#if SPROUT_USE_TEMPLATE_ALIASES
+	//
+	// observer_ptr
+	//
+	template<typename T>
+	using observer_ptr = sprout::exempt_ptr<T>;
+#endif	// #if SPROUT_USE_TEMPLATE_ALIASES
+}	// namespace sprout
+
+#endif	// #ifndef SPROUT_MEMORY_OBSERVER_PTR_HPP
diff --git a/sprout/memory/pointer_cast.hpp b/sprout/memory/pointer_cast.hpp
new file mode 100644
index 00000000..3695007a
--- /dev/null
+++ b/sprout/memory/pointer_cast.hpp
@@ -0,0 +1,69 @@
+/*=============================================================================
+  Copyright (c) 2011-2014 Bolero MURAKAMI
+  https://github.com/bolero-MURAKAMI/Sprout
+
+  Distributed under the Boost Software License, Version 1.0. (See accompanying
+  file LICENSE_1_0.txt or copy at http://www.boost.org/LICENSE_1_0.txt)
+=============================================================================*/
+#ifndef SPROUT_MEMORY_POINTER_CAST_HPP
+#define SPROUT_MEMORY_POINTER_CAST_HPP
+
+#include <memory>
+#include <sprout/config.hpp>
+#include <sprout/utility/dyn_cast.hpp>
+#include <sprout/utility/reinter_cast.hpp>
+
+namespace sprout {
+	//
+	// static_pointer_cast
+	// const_pointer_cast
+	// dynamic_pointer_cast
+	// reinterpret_pointer_cast
+	//
+	template<typename T, typename U>
+	inline SPROUT_CONSTEXPR T*
+	static_pointer_cast(U* p) {
+		return static_cast<T*>(p);
+	}
+	template<typename T, typename U>
+	inline SPROUT_CONSTEXPR T*
+	const_pointer_cast(U* p) {
+		return const_cast<T*>(p);
+	}
+	template<typename T, typename U>
+	inline SPROUT_CONSTEXPR T*
+	dynamic_pointer_cast(U* p) {
+		return sprout::dyn_cast<T*>(p);
+	}
+	template<typename T, typename U>
+	inline SPROUT_CONSTEXPR T*
+	reinterpret_pointer_cast(U* p) {
+		return sprout::reinter_cast<T*>(p);
+	}
+
+#if !defined(SPROUT_NO_CXX11_SMART_PTR)
+	template<typename T, typename U>
+	inline SPROUT_NON_CONSTEXPR std::shared_ptr<T>
+	static_pointer_cast(std::shared_ptr<U> const& p) {
+		return std::static_pointer_cast<T>(p);
+	}
+	template<typename T, typename U>
+	inline SPROUT_NON_CONSTEXPR std::shared_ptr<T>
+	const_pointer_cast(std::shared_ptr<U> const& p) {
+		return std::const_pointer_cast<T>(p);
+	}
+	template<typename T, typename U>
+	inline SPROUT_NON_CONSTEXPR std::shared_ptr<T>
+	dynamic_pointer_cast(std::shared_ptr<U> const& p) {
+		return std::dynamic_pointer_cast<T>(p);
+	}
+	template<typename T, typename U>
+	inline SPROUT_NON_CONSTEXPR std::shared_ptr<T>
+	reinterpret_pointer_cast(std::shared_ptr<U> const& p) {
+		typedef typename std::shared_ptr<T>::element_type element_type;
+		return std::shared_ptr<T>(p, reinterpret_cast<element_type*>(p.get()));
+	}
+#endif
+}	// namespace sprout
+
+#endif	// #ifndef SPROUT_MEMORY_POINTER_CAST_HPP
diff --git a/sprout/optional/io.hpp b/sprout/optional/io.hpp
index 5323cf22..6ef2c611 100644
--- a/sprout/optional/io.hpp
+++ b/sprout/optional/io.hpp
@@ -8,8 +8,8 @@
 #ifndef SPROUT_OPTIONAL_IO_HPP
 #define SPROUT_OPTIONAL_IO_HPP
 
-#include <iosfwd>
-#include <ios>
+#include <istream>
+#include <ostream>
 #include <sprout/config.hpp>
 #include <sprout/optional/optional.hpp>
 #include <sprout/none.hpp>
diff --git a/sprout/random/additive_combine.hpp b/sprout/random/additive_combine.hpp
index f9f87570..8c4af499 100644
--- a/sprout/random/additive_combine.hpp
+++ b/sprout/random/additive_combine.hpp
@@ -9,8 +9,8 @@
 #define SPROUT_RANDOM_ADDITIVE_COMBINE_HPP
 
 #include <cstdint>
-#include <ios>
 #include <istream>
+#include <ostream>
 #include <sprout/config.hpp>
 #include <sprout/random/random_result.hpp>
 #include <sprout/random/linear_congruential.hpp>
diff --git a/sprout/random/geometric_distribution.hpp b/sprout/random/geometric_distribution.hpp
index e6597c20..cce2d385 100644
--- a/sprout/random/geometric_distribution.hpp
+++ b/sprout/random/geometric_distribution.hpp
@@ -8,7 +8,8 @@
 #ifndef SPROUT_RANDOM_GEOMETRIC_DISTRIBUTION_HPP
 #define SPROUT_RANDOM_GEOMETRIC_DISTRIBUTION_HPP
 
-#include <ios>
+#include <istream>
+#include <ostream>
 #include <sprout/config.hpp>
 #include <sprout/limits.hpp>
 #include <sprout/math/log.hpp>
diff --git a/sprout/random/inversive_congruential.hpp b/sprout/random/inversive_congruential.hpp
index a56621a0..255a4379 100644
--- a/sprout/random/inversive_congruential.hpp
+++ b/sprout/random/inversive_congruential.hpp
@@ -9,7 +9,8 @@
 #define SPROUT_RANDOM_INVERSIVE_CONGRUENTIAL_HPP
 
 #include <cstdint>
-#include <ios>
+#include <istream>
+#include <ostream>
 #include <type_traits>
 #include <sprout/config.hpp>
 #include <sprout/limits.hpp>
diff --git a/sprout/random/linear_congruential.hpp b/sprout/random/linear_congruential.hpp
index 2e0ff8a1..cd805a41 100644
--- a/sprout/random/linear_congruential.hpp
+++ b/sprout/random/linear_congruential.hpp
@@ -9,7 +9,8 @@
 #define SPROUT_RANDOM_LINEAR_CONGRUENTIAL_HPP
 
 #include <cstdint>
-#include <ios>
+#include <istream>
+#include <ostream>
 #include <type_traits>
 #include <sprout/config.hpp>
 #include <sprout/limits.hpp>
diff --git a/sprout/random/linear_feedback_shift.hpp b/sprout/random/linear_feedback_shift.hpp
index 02e48498..12a6b680 100644
--- a/sprout/random/linear_feedback_shift.hpp
+++ b/sprout/random/linear_feedback_shift.hpp
@@ -8,7 +8,8 @@
 #ifndef SPROUT_RANDOM_LINEAR_FEEDBACK_SHIFT_HPP
 #define SPROUT_RANDOM_LINEAR_FEEDBACK_SHIFT_HPP
 
-#include <ios>
+#include <istream>
+#include <ostream>
 #include <sprout/config.hpp>
 #include <sprout/detail/integer/integer_mask.hpp>
 #include <sprout/random/detail/seed_impl.hpp>
diff --git a/sprout/random/mersenne_twister.hpp b/sprout/random/mersenne_twister.hpp
index cfc3b621..5d631f12 100644
--- a/sprout/random/mersenne_twister.hpp
+++ b/sprout/random/mersenne_twister.hpp
@@ -8,7 +8,8 @@
 #ifndef SPROUT_RANDOM_MERSENNE_TWISTER_HPP
 #define SPROUT_RANDOM_MERSENNE_TWISTER_HPP
 
-#include <ios>
+#include <istream>
+#include <ostream>
 #include <type_traits>
 #include <sprout/config.hpp>
 #include <sprout/workaround/std/cstddef.hpp>
diff --git a/sprout/random/normal_distribution.hpp b/sprout/random/normal_distribution.hpp
index 59d6c575..42d8e949 100644
--- a/sprout/random/normal_distribution.hpp
+++ b/sprout/random/normal_distribution.hpp
@@ -8,8 +8,8 @@
 #ifndef SPROUT_RANDOM_NORMAL_DISTRIBUTION_HPP
 #define SPROUT_RANDOM_NORMAL_DISTRIBUTION_HPP
 
-#include <ios>
 #include <istream>
+#include <ostream>
 #include <sprout/config.hpp>
 #include <sprout/limits.hpp>
 #include <sprout/math/constants.hpp>
diff --git a/sprout/random/shuffle_order.hpp b/sprout/random/shuffle_order.hpp
index b006d2bf..0fae1c76 100644
--- a/sprout/random/shuffle_order.hpp
+++ b/sprout/random/shuffle_order.hpp
@@ -9,8 +9,8 @@
 #define SPROUT_RANDOM_SHUFFLE_ORDER_HPP
 
 #include <cstdint>
-#include <ios>
 #include <istream>
+#include <ostream>
 #include <type_traits>
 #include <sprout/config.hpp>
 #include <sprout/workaround/std/cstddef.hpp>
diff --git a/sprout/random/uniform_int_distribution.hpp b/sprout/random/uniform_int_distribution.hpp
index 4234fe23..a97a7742 100644
--- a/sprout/random/uniform_int_distribution.hpp
+++ b/sprout/random/uniform_int_distribution.hpp
@@ -8,8 +8,8 @@
 #ifndef SPROUT_RANDOM_UNIFORM_INT_DISTRIBUTION_HPP
 #define SPROUT_RANDOM_UNIFORM_INT_DISTRIBUTION_HPP
 
-#include <ios>
 #include <istream>
+#include <ostream>
 #include <type_traits>
 #include <sprout/config.hpp>
 #include <sprout/limits.hpp>
diff --git a/sprout/random/uniform_real_distribution.hpp b/sprout/random/uniform_real_distribution.hpp
index 43867955..55a81a9a 100644
--- a/sprout/random/uniform_real_distribution.hpp
+++ b/sprout/random/uniform_real_distribution.hpp
@@ -8,8 +8,8 @@
 #ifndef SPROUT_RANDOM_UNIFORM_REAL_DISTRIBUTION_HPP
 #define SPROUT_RANDOM_UNIFORM_REAL_DISTRIBUTION_HPP
 
-#include <ios>
 #include <istream>
+#include <ostream>
 #include <type_traits>
 #include <sprout/config.hpp>
 #include <sprout/random/detail/signed_unsigned_tools.hpp>
diff --git a/sprout/random/xor_combine.hpp b/sprout/random/xor_combine.hpp
index 0f2a9467..c8e34c47 100644
--- a/sprout/random/xor_combine.hpp
+++ b/sprout/random/xor_combine.hpp
@@ -8,8 +8,8 @@
 #ifndef SPROUT_RANDOM_XOR_COMBINE_HPP
 #define SPROUT_RANDOM_XOR_COMBINE_HPP
 
-#include <ios>
 #include <istream>
+#include <ostream>
 #include <sprout/config.hpp>
 #include <sprout/random/random_result.hpp>
 #include <sprout/random/type_traits.hpp>
diff --git a/sprout/rational/io.hpp b/sprout/rational/io.hpp
index 9bb79080..015c6c81 100644
--- a/sprout/rational/io.hpp
+++ b/sprout/rational/io.hpp
@@ -8,8 +8,8 @@
 #ifndef SPROUT_RATIONAL_IO_HPP
 #define SPROUT_RATIONAL_IO_HPP
 
-#include <ios>
-#include <iostream>
+#include <istream>
+#include <ostream>
 #include <sprout/config.hpp>
 #include <sprout/rational/rational.hpp>
 #include <sprout/detail/io/ios_state.hpp>
diff --git a/sprout/string/io.hpp b/sprout/string/io.hpp
index dbc240f8..f142ba92 100644
--- a/sprout/string/io.hpp
+++ b/sprout/string/io.hpp
@@ -8,7 +8,8 @@
 #ifndef SPROUT_STRING_IO_HPP
 #define SPROUT_STRING_IO_HPP
 
-#include <ios>
+#include <istream>
+#include <ostream>
 #include <sprout/config.hpp>
 #include <sprout/workaround/std/cstddef.hpp>
 #include <sprout/string/string.hpp>
diff --git a/sprout/type_traits.hpp b/sprout/type_traits.hpp
index a7baf937..df443003 100644
--- a/sprout/type_traits.hpp
+++ b/sprout/type_traits.hpp
@@ -18,6 +18,8 @@
 #include <sprout/type_traits/is_uint.hpp>
 #include <sprout/type_traits/is_char_type.hpp>
 #include <sprout/type_traits/is_c_str.hpp>
+#include <sprout/type_traits/is_nullptr_cast.hpp>
+#include <sprout/type_traits/is_upcast.hpp>
 #include <sprout/type_traits/has_type.hpp>
 #include <sprout/type_traits/has_value.hpp>
 #include <sprout/type_traits/identity.hpp>
diff --git a/sprout/type_traits/is_nullptr_cast.hpp b/sprout/type_traits/is_nullptr_cast.hpp
new file mode 100644
index 00000000..fcc4d383
--- /dev/null
+++ b/sprout/type_traits/is_nullptr_cast.hpp
@@ -0,0 +1,29 @@
+/*=============================================================================
+  Copyright (c) 2011-2014 Bolero MURAKAMI
+  https://github.com/bolero-MURAKAMI/Sprout
+
+  Distributed under the Boost Software License, Version 1.0. (See accompanying
+  file LICENSE_1_0.txt or copy at http://www.boost.org/LICENSE_1_0.txt)
+=============================================================================*/
+#ifndef SPROUT_TYPE_TRAITS_IS_NULLPTR_CAST_HPP
+#define SPROUT_TYPE_TRAITS_IS_NULLPTR_CAST_HPP
+
+#include <sprout/config.hpp>
+#include <sprout/workaround/std/cstddef.hpp>
+#include <sprout/type_traits/integral_constant.hpp>
+#include <sprout/type_traits/std_type_traits.hpp>
+
+namespace sprout {
+	//
+	// is_nullptr_cast
+	//
+	template<typename From, typename To>
+	struct is_nullptr_cast
+		: public sprout::integral_constant<
+			bool,
+			sprout::is_pointer<To>::value && sprout::is_same<typename sprout::decay<From>::type, std::nullptr_t>::value
+		>
+	{};
+}	// namespace sprout
+
+#endif	// #ifndef SPROUT_TYPE_TRAITS_IS_NULLPTR_CAST_HPP
diff --git a/sprout/type_traits/is_upcast.hpp b/sprout/type_traits/is_upcast.hpp
new file mode 100644
index 00000000..5ad82663
--- /dev/null
+++ b/sprout/type_traits/is_upcast.hpp
@@ -0,0 +1,35 @@
+/*=============================================================================
+  Copyright (c) 2011-2014 Bolero MURAKAMI
+  https://github.com/bolero-MURAKAMI/Sprout
+
+  Distributed under the Boost Software License, Version 1.0. (See accompanying
+  file LICENSE_1_0.txt or copy at http://www.boost.org/LICENSE_1_0.txt)
+=============================================================================*/
+#ifndef SPROUT_TYPE_TRAITS_IS_UPCAST_HPP
+#define SPROUT_TYPE_TRAITS_IS_UPCAST_HPP
+
+#include <sprout/config.hpp>
+#include <sprout/type_traits/integral_constant.hpp>
+#include <sprout/type_traits/std_type_traits.hpp>
+#include <sprout/type_traits/is_nullptr_cast.hpp>
+
+namespace sprout {
+	//
+	// is_upcast
+	//
+	template<typename From, typename To>
+	struct is_upcast
+		: public sprout::integral_constant<
+			bool,
+			sprout::is_nullptr_cast<From, To>::value
+				|| (sprout::is_pointer<To>::value
+					&& sprout::is_base_of<typename sprout::remove_pointer<To>::type, typename sprout::remove_pointer<typename sprout::decay<From>::type>::type>::value
+					)
+				|| (sprout::is_reference<To>::value
+					&& sprout::is_base_of<typename sprout::remove_reference<To>::type, typename sprout::remove_reference<From>::type>::value
+					)
+		>
+	{};
+}	// namespace sprout
+
+#endif	// #ifndef SPROUT_TYPE_TRAITS_IS_UPCAST_HPP
diff --git a/sprout/utility.hpp b/sprout/utility.hpp
index 9df4dfd1..5231ad20 100644
--- a/sprout/utility.hpp
+++ b/sprout/utility.hpp
@@ -12,6 +12,7 @@
 #include <sprout/utility/pair.hpp>
 #include <sprout/utility/operation.hpp>
 #include <sprout/utility/operation_ext.hpp>
+#include <sprout/utility/cast.hpp>
 #include <sprout/utility/noncopyable.hpp>
 #include <sprout/utility/enabler_if.hpp>
 #include <sprout/utility/pack.hpp>
diff --git a/sprout/utility/cast.hpp b/sprout/utility/cast.hpp
new file mode 100644
index 00000000..4ce2e9c0
--- /dev/null
+++ b/sprout/utility/cast.hpp
@@ -0,0 +1,22 @@
+/*=============================================================================
+  Copyright (c) 2011-2014 Bolero MURAKAMI
+  https://github.com/bolero-MURAKAMI/Sprout
+
+  Distributed under the Boost Software License, Version 1.0. (See accompanying
+  file LICENSE_1_0.txt or copy at http://www.boost.org/LICENSE_1_0.txt)
+=============================================================================*/
+#ifndef SPROUT_UTILITY_CAST_HPP
+#define SPROUT_UTILITY_CAST_HPP
+
+#include <sprout/config.hpp>
+#include <sprout/utility/as_lvalue.hpp>
+#include <sprout/utility/as_const.hpp>
+#include <sprout/utility/lvalue_forward.hpp>
+#include <sprout/utility/unmove.hpp>
+#include <sprout/utility/pass_through.hpp>
+#include <sprout/utility/implicit_cast.hpp>
+#include <sprout/utility/upcast.hpp>
+#include <sprout/utility/dyn_cast.hpp>
+#include <sprout/utility/reinter_cast.hpp>
+
+#endif	// #ifndef SPROUT_UTILITY_CAST_HPP
diff --git a/sprout/utility/dyn_cast.hpp b/sprout/utility/dyn_cast.hpp
new file mode 100644
index 00000000..b024b9d2
--- /dev/null
+++ b/sprout/utility/dyn_cast.hpp
@@ -0,0 +1,38 @@
+/*=============================================================================
+  Copyright (c) 2011-2014 Bolero MURAKAMI
+  https://github.com/bolero-MURAKAMI/Sprout
+
+  Distributed under the Boost Software License, Version 1.0. (See accompanying
+  file LICENSE_1_0.txt or copy at http://www.boost.org/LICENSE_1_0.txt)
+=============================================================================*/
+#ifndef SPROUT_UTILITY_DYN_CAST_HPP
+#define SPROUT_UTILITY_DYN_CAST_HPP
+
+#include <sprout/config.hpp>
+#include <sprout/type_traits/is_upcast.hpp>
+#include <sprout/type_traits/enabler_if.hpp>
+#include <sprout/utility/forward.hpp>
+
+namespace sprout {
+	//
+	// dyn_cast
+	//
+	template<
+		typename T, typename U,
+		typename sprout::enabler_if<sprout::is_upcast<U&&, T>::value>::type = sprout::enabler
+	>
+	inline SPROUT_CONSTEXPR T
+	dyn_cast(U&& x) {
+		return static_cast<T>(SPROUT_FORWARD(U, x));
+	}
+	template<
+		typename T, typename U,
+		typename sprout::enabler_if<!sprout::is_upcast<U&&, T>::value>::type = sprout::enabler
+	>
+	inline SPROUT_NON_CONSTEXPR T
+	dyn_cast(U&& x) {
+		return dynamic_cast<T>(SPROUT_FORWARD(U, x));
+	}
+}	// namespace sprout
+
+#endif	// #ifndef SPROUT_UTILITY_DYN_CAST_HPP
diff --git a/sprout/utility/implicit_cast.hpp b/sprout/utility/implicit_cast.hpp
new file mode 100644
index 00000000..dfccb0b1
--- /dev/null
+++ b/sprout/utility/implicit_cast.hpp
@@ -0,0 +1,25 @@
+/*=============================================================================
+  Copyright (c) 2011-2014 Bolero MURAKAMI
+  https://github.com/bolero-MURAKAMI/Sprout
+
+  Distributed under the Boost Software License, Version 1.0. (See accompanying
+  file LICENSE_1_0.txt or copy at http://www.boost.org/LICENSE_1_0.txt)
+=============================================================================*/
+#ifndef SPROUT_UTILITY_IMPLICIT_CAST_HPP
+#define SPROUT_UTILITY_IMPLICIT_CAST_HPP
+
+#include <sprout/config.hpp>
+#include <sprout/type_traits/identity.hpp>
+
+namespace sprout {
+	//
+	// implicit_cast
+	//
+	template<typename T>
+	inline SPROUT_CONSTEXPR T
+	implicit_cast (typename sprout::identity<T>::type t) {
+	    return t;
+	}
+}	// namespace sprout
+
+#endif	// #ifndef SPROUT_UTILITY_IMPLICIT_CAST_HPP
diff --git a/sprout/utility/noncopyable.hpp b/sprout/utility/noncopyable.hpp
index 6c404ad1..8772313b 100644
--- a/sprout/utility/noncopyable.hpp
+++ b/sprout/utility/noncopyable.hpp
@@ -11,7 +11,7 @@
 #include <sprout/config.hpp>
 
 namespace sprout {
-	namespace noncopyable_ {
+	namespace noncopyable_detail {
 		class noncopyable {
 		protected:
 			SPROUT_CONSTEXPR noncopyable() SPROUT_DEFAULTED_DEFAULT_CONSTRUCTOR_DECL
@@ -20,11 +20,11 @@ namespace sprout {
 			noncopyable(noncopyable const&) SPROUT_DELETED_FUNCTION_DECL
 			noncopyable& operator=(noncopyable const&) SPROUT_DELETED_FUNCTION_DECL
 		};
-	}	// namespace noncopyable_
+	}	// namespace noncopyable_detail
 	//
 	// noncopyable
 	//
-	typedef sprout::noncopyable_::noncopyable noncopyable;
+	typedef sprout::noncopyable_detail::noncopyable noncopyable;
 }	// namespace sprout
 
 #endif	// #ifndef SPROUT_UTILITY_NONCOPYABLE_HPP
diff --git a/sprout/utility/operation.hpp b/sprout/utility/operation.hpp
index 950537ba..e8bb7190 100644
--- a/sprout/utility/operation.hpp
+++ b/sprout/utility/operation.hpp
@@ -14,7 +14,5 @@
 #include <sprout/utility/move.hpp>
 #include <sprout/utility/swap.hpp>
 #include <sprout/utility/exchange.hpp>
-#include <sprout/utility/unmove.hpp>
-#include <sprout/utility/eat.hpp>
 
 #endif	// #ifndef SPROUT_UTILITY_OPERATION_HPP
diff --git a/sprout/utility/operation_ext.hpp b/sprout/utility/operation_ext.hpp
index 4e1cd07d..4f917475 100644
--- a/sprout/utility/operation_ext.hpp
+++ b/sprout/utility/operation_ext.hpp
@@ -10,10 +10,7 @@
 
 #include <sprout/config.hpp>
 #include <sprout/utility/compare_pointees.hpp>
-#include <sprout/utility/as_lvalue.hpp>
-#include <sprout/utility/as_const.hpp>
-#include <sprout/utility/lvalue_forward.hpp>
-#include <sprout/utility/pass_through.hpp>
+#include <sprout/utility/eat.hpp>
 #include <sprout/utility/limited.hpp>
 
 #endif	// #ifndef SPROUT_UTILITY_OPERATION_EXT_HPP
diff --git a/sprout/utility/reinter_cast.hpp b/sprout/utility/reinter_cast.hpp
new file mode 100644
index 00000000..9da6c677
--- /dev/null
+++ b/sprout/utility/reinter_cast.hpp
@@ -0,0 +1,55 @@
+/*=============================================================================
+  Copyright (c) 2011-2014 Bolero MURAKAMI
+  https://github.com/bolero-MURAKAMI/Sprout
+
+  Distributed under the Boost Software License, Version 1.0. (See accompanying
+  file LICENSE_1_0.txt or copy at http://www.boost.org/LICENSE_1_0.txt)
+=============================================================================*/
+#ifndef SPROUT_UTILITY_REINTER_CAST_HPP
+#define SPROUT_UTILITY_REINTER_CAST_HPP
+
+#include <sprout/config.hpp>
+#include <sprout/type_traits/integral_constant.hpp>
+#include <sprout/type_traits/std_type_traits.hpp>
+#include <sprout/type_traits/enabler_if.hpp>
+#include <sprout/utility/forward.hpp>
+
+namespace sprout {
+	namespace detail {
+		template<typename From, typename To>
+		struct is_same_reinterpret_cast
+			: public sprout::integral_constant<
+				bool,
+				(sprout::is_reference<To>::value
+					&& sprout::is_same<typename sprout::decay<From>::type, typename sprout::decay<To>::type>::value
+					&& sprout::is_convertible<From, To>::value
+					)
+					|| ((sprout::is_integral<To>::type || sprout::is_enum<To>::type || sprout::is_pointer<To>::type)
+						&& sprout::is_same<typename sprout::decay<From>::type, To>::value
+						)
+
+			>
+		{};
+	}	// namespace detail
+ 	//
+	// reinter_cast
+	//
+	template<
+		typename T, typename U,
+		typename sprout::enabler_if<sprout::detail::is_same_reinterpret_cast<U&&, T>::value>::type = sprout::enabler
+	>
+	inline SPROUT_CONSTEXPR T
+	reinter_cast(U&& x) {
+		return SPROUT_FORWARD(U, x);
+	}
+	template<
+		typename T, typename U,
+		typename sprout::enabler_if<!sprout::detail::is_same_reinterpret_cast<U&&, T>::value>::type = sprout::enabler
+	>
+	inline SPROUT_NON_CONSTEXPR T
+	reinter_cast(U&& x) {
+		return reinterpret_cast<T>(SPROUT_FORWARD(U, x));
+	}
+}	// namespace sprout
+
+#endif	// #ifndef SPROUT_UTILITY_REINTER_CAST_HPP
diff --git a/sprout/utility/string_ref/io.hpp b/sprout/utility/string_ref/io.hpp
index bedb34cb..b4b8cffb 100644
--- a/sprout/utility/string_ref/io.hpp
+++ b/sprout/utility/string_ref/io.hpp
@@ -9,7 +9,8 @@
 #define SPROUT_UTILITY_STRING_IO_HPP
 
 #include <iterator>
-#include <ios>
+#include <istream>
+#include <ostream>
 #include <sprout/config.hpp>
 #include <sprout/algorithm/cxx14/copy.hpp>
 #include <sprout/utility/string_ref/string_ref.hpp>
diff --git a/sprout/utility/upcast.hpp b/sprout/utility/upcast.hpp
new file mode 100644
index 00000000..a007f056
--- /dev/null
+++ b/sprout/utility/upcast.hpp
@@ -0,0 +1,30 @@
+/*=============================================================================
+  Copyright (c) 2011-2014 Bolero MURAKAMI
+  https://github.com/bolero-MURAKAMI/Sprout
+
+  Distributed under the Boost Software License, Version 1.0. (See accompanying
+  file LICENSE_1_0.txt or copy at http://www.boost.org/LICENSE_1_0.txt)
+=============================================================================*/
+#ifndef SPROUT_UTILITY_UPCAST_HPP
+#define SPROUT_UTILITY_UPCAST_HPP
+
+#include <sprout/config.hpp>
+#include <sprout/type_traits/is_upcast.hpp>
+#include <sprout/type_traits/enabler_if.hpp>
+#include <sprout/utility/forward.hpp>
+
+namespace sprout {
+	//
+	// upcast
+	//
+	template<
+		typename T, typename U,
+		typename sprout::enabler_if<sprout::is_upcast<U&&, T>::value>::type = sprout::enabler
+	>
+	inline SPROUT_CONSTEXPR T
+	upcast(U&& x) {
+		return static_cast<T>(SPROUT_FORWARD(U, x));
+	}
+}	// namespace sprout
+
+#endif	// #ifndef SPROUT_UTILITY_UPCAST_HPP
diff --git a/sprout/uuid/io.hpp b/sprout/uuid/io.hpp
index d9aa385e..02b5cc7e 100644
--- a/sprout/uuid/io.hpp
+++ b/sprout/uuid/io.hpp
@@ -9,9 +9,8 @@
 #define SPROUT_UUID_IO_HPP
 
 #include <iterator>
-#include <ios>
-#include <ostream>
 #include <istream>
+#include <ostream>
 #include <locale>
 #include <sprout/config.hpp>
 #include <sprout/workaround/std/cstddef.hpp>