Rename AsBits to ToBits

The conversion is owning to owning (cheap copy), not
reference to reference or owning to reference. So it's a
'to' transformation.

Author: danakj

subspace/CMakeLists.txt

@@ -225,7 +225,7 @@ if(${SUBSPACE_BUILD_TESTS})
         "choice/choice_types_unittest.cc"
         "choice/choice_unittest.cc"
         "convert/subclass_unittest.cc"
-        "construct/as_bits_unittest.cc"
+        "construct/to_bits_unittest.cc"
         "containers/array_unittest.cc"
         "containers/invalidation_off_size_unittest.cc"
         "containers/invalidation_on_size_unittest.cc"

subspace/construct/as_bits.h renamed to subspace/construct/to_bits.h

@@ -19,37 +19,37 @@
 namespace sus::construct {
 
 /// Specializing this class for `To` and `From` allows `To` to satisfy
-/// `AsBits<To, From>`.
+/// `ToBits<To, From>`.
 ///
 /// # Examples
 ///
 /// To allow bitwise conversion to `Goat` from any type satisying a
 /// concept `GoatLike`:
 /// ```cpp
-/// // Satisfies AsBits<Goat, GoatLike>.
+/// // Satisfies ToBits<Goat, GoatLike>.
 /// template <class Goat, GoatLike G>
-/// struct AsBitsImpl<Goat, G> {
+/// struct ToBitsImpl<Goat, G> {
 ///   constexpr static Goat from_bits(const G& g) noexcept { return ...; }
 /// };
 /// ```
 ///
 /// To receive something that can be bitwise converted to an `u32`.
 /// ```cpp
-/// auto add = [](u32 a, const sus::construct::AsBits<u32> auto& b) -> u32 {
-///   return a.wrapping_add(sus::as_bits<u32>(b));
+/// auto add = [](u32 a, const sus::construct::ToBits<u32> auto& b) -> u32 {
+///   return a.wrapping_add(sus::to_bits<u32>(b));
 /// };
 /// sus::check(add(3_u32, -1_i32) == u32::MIN + 2);
 /// ```
 template <class To, class From>
-struct AsBitsImpl;
+struct ToBitsImpl;
 
-// sus::construct::AsBits<T, T> trait for identity conversion.
+// sus::construct::ToBits<T, T> trait for identity conversion.
 template <class T>
-struct sus::construct::AsBitsImpl<T, T> {
+struct ToBitsImpl<T, T> {
   constexpr static T from_bits(const T& from) noexcept { return from; }
 };
 
-/// A type `T` that satisfies `AsBits<T, F>` can be constructed from `F` through
+/// A type `T` that satisfies `ToBits<T, F>` can be constructed from `F` through
 /// a bitwise conversion that preserves the bits but not the conceptual value of
 /// `F`. The conversion may also truncate or extend `F` in order to do the
 /// bitwise conversion to `T`.
@@ -59,9 +59,9 @@ struct sus::construct::AsBitsImpl<T, T> {
 /// types to participate in deciding how and when bitwise converstions can be
 /// performed.
 template <class To, class From>
-concept AsBits = requires(const From& from) {
+concept ToBits = requires(const From& from) {
   {
-    ::sus::construct::AsBitsImpl<To, From>::from_bits(from)
+    ::sus::construct::ToBitsImpl<To, From>::from_bits(from)
   } noexcept -> std::same_as<To>;
 };
 
@@ -71,10 +71,10 @@ concept AsBits = requires(const From& from) {
 ///
 /// To convert between types while preserving the meaning of the value, use
 /// `sus::construct::Into` or `sus::construct::TryInto`. Usually prefer using
-/// `sus::into(x)` or `sus::try_into(x)` over `sus::as_bits<Y>(x)` as most code
+/// `sus::into(x)` or `sus::try_into(x)` over `sus::to_bits<Y>(x)` as most code
 /// is not doing bitwise manipulation.
 ///
-/// The result of `as_bits()` may be lossy. It may truncate bits from the input,
+/// The result of `to_bits()` may be lossy. It may truncate bits from the input,
 /// or extend it.
 ///
 /// # Examples
@@ -83,16 +83,16 @@ concept AsBits = requires(const From& from) {
 /// large positive number, and truncates 32 bits which loses the original value
 /// as well.
 /// ```cpp
-/// sus::check(u32::MAX == sus::as_bits<u32>(-1_i64));
+/// sus::check(u32::MAX == sus::to_bits<u32>(-1_i64));
 /// ```
 template <class To, class From>
-constexpr inline To as_bits(const From& from) {
-  return AsBitsImpl<To, From>::from_bits(from);
+constexpr inline To to_bits(const From& from) {
+  return ToBitsImpl<To, From>::from_bits(from);
 }
 
 }  // namespace sus::construct
 
-// Bring the as_bits() function into the `sus` namespace.
+// Bring the to_bits() function into the `sus` namespace.
 namespace sus {
-using ::sus::construct::as_bits;
+using ::sus::construct::to_bits;
 }

subspace/construct/as_bits_unittest.cc renamed to subspace/construct/to_bits_unittest.cc

@@ -12,22 +12,22 @@
 // See the License for the specific language governing permissions and
 // limitations under the License.
 
-#include "subspace/construct/as_bits.h"
+#include "subspace/construct/to_bits.h"
 
 #include "googletest/include/gtest/gtest.h"
 #include "subspace/prelude.h"
 
 namespace {
 
-TEST(AsBits, Example_Concept) {
-  auto add = [](u32 a, const sus::construct::AsBits<u32> auto& b) -> u32 {
-    return a.wrapping_add(sus::as_bits<u32>(b));
+TEST(ToBits, Example_Concept) {
+  auto add = [](u32 a, const sus::construct::ToBits<u32> auto& b) -> u32 {
+    return a.wrapping_add(sus::to_bits<u32>(b));
   };
   sus::check(add(3_u32, -1_i32) == u32::MIN + 2u);
 }
 
-TEST(AsBits, Example_Function) {
-  sus::check(u32::MAX == sus::as_bits<u32>(-1_i64));
+TEST(ToBits, Example_Function) {
+  sus::check(u32::MAX == sus::to_bits<u32>(-1_i64));
 }
 
 }  // namespace