Fix spelling errors (#384)

aligment -> alignment
constructable -> constructible
constuctible -> constructible
contructed -> constructed
destructable -> destructible
futher -> further
implcit -> implicit
implemenation -> implementation
intrinics -> intrinsics

9 files changed, 11 insertions, 11 deletions

diff --git a/absl/base/attributes.h b/absl/base/attributes.h
index a7da62a..f298297 100644
--- a/absl/base/attributes.h
+++ b/absl/base/attributes.h
@@ -157,7 +157,7 @@
 // Tags a function as weak for the purposes of compilation and linking.
 // Weak attributes currently do not work properly in LLVM's Windows backend,
 // so disable them there. See https://bugs.llvm.org/show_bug.cgi?id=37598
-// for futher information.
+// for further information.
 #if (ABSL_HAVE_ATTRIBUTE(weak) || \
      (defined(__GNUC__) && !defined(__clang__))) && \
     !(defined(__llvm__) && defined(_WIN32))
diff --git a/absl/base/internal/endian.h b/absl/base/internal/endian.h
index 296e92d..b43c9a4 100644
--- a/absl/base/internal/endian.h
+++ b/absl/base/internal/endian.h
@@ -113,7 +113,7 @@ inline uint16_t gbswap_16(uint16_t host_int) {
 #endif
 }
 
-#endif  // intrinics available
+#endif  // intrinsics available
 
 #ifdef ABSL_IS_LITTLE_ENDIAN
 
diff --git a/absl/meta/type_traits.h b/absl/meta/type_traits.h
index 927244e..76959cd 100644
--- a/absl/meta/type_traits.h
+++ b/absl/meta/type_traits.h
@@ -243,7 +243,7 @@ struct is_function
 
 // is_trivially_destructible()
 //
-// Determines whether the passed type `T` is trivially destructable.
+// Determines whether the passed type `T` is trivially destructible.
 //
 // This metafunction is designed to be a drop-in replacement for the C++11
 // `std::is_trivially_destructible()` metafunction for platforms that have
diff --git a/absl/random/distributions.h b/absl/random/distributions.h
index 18ff248..3a4e93a 100644
--- a/absl/random/distributions.h
+++ b/absl/random/distributions.h
@@ -96,7 +96,7 @@ ABSL_INTERNAL_INLINE_CONSTEXPR(IntervalOpenClosedTag, IntervalOpenClosed, {});
 // the return type based on the provided endpoint arguments {A lo, B hi}.
 // Given these endpoints, one of {A, B} will be chosen as the return type, if
 // a type can be implicitly converted into the other in a lossless way. The
-// lack of any such implcit conversion between {A, B} will produce a
+// lack of any such implicit conversion between {A, B} will produce a
 // compile-time error
 //
 // See https://en.wikipedia.org/wiki/Uniform_distribution_(continuous)
diff --git a/absl/synchronization/internal/graphcycles.h b/absl/synchronization/internal/graphcycles.h
index e5bde00..e08dc09 100644
--- a/absl/synchronization/internal/graphcycles.h
+++ b/absl/synchronization/internal/graphcycles.h
@@ -36,7 +36,7 @@
 //   InsertEdge() is very fast when the edge already exists, and reasonably fast
 //   otherwise.
 //   FindPath() is linear in the size of the graph.
-// The current implemenation uses O(|V|+|E|) space.
+// The current implementation uses O(|V|+|E|) space.
 
 #include <cstdint>
 
diff --git a/absl/synchronization/internal/waiter.cc b/absl/synchronization/internal/waiter.cc
index f17ea56..9614578 100644
--- a/absl/synchronization/internal/waiter.cc
+++ b/absl/synchronization/internal/waiter.cc
@@ -355,7 +355,7 @@ class Waiter::WinHelper {
                 "ConditionVariableStorage does not have the same "
                 "alignment as CONDITION_VARIABLE");
 
-  // The SRWLOCK and CONDITION_VARIABLE types must be trivially constuctible
+  // The SRWLOCK and CONDITION_VARIABLE types must be trivially constructible
   // and destructible because we never call their constructors or destructors.
   static_assert(std::is_trivially_constructible<SRWLOCK>::value,
                 "The SRWLOCK type must be trivially constructible");
diff --git a/absl/time/civil_time.h b/absl/time/civil_time.h
index 7c52586..c8166d0 100644
--- a/absl/time/civil_time.h
+++ b/absl/time/civil_time.h
@@ -247,7 +247,7 @@ struct year_tag : month_tag, cctz::detail::year_tag {};
 // int          minute()
 // int          second()
 //
-// Recall that fields inferior to the type's aligment will be set to their
+// Recall that fields inferior to the type's alignment will be set to their
 // minimum valid value.
 //
 // Example:
diff --git a/absl/types/any.h b/absl/types/any.h
index d2e2533..507c8b2 100644
--- a/absl/types/any.h
+++ b/absl/types/any.h
@@ -182,7 +182,7 @@ ValueType* any_cast(any* operand) noexcept;
 // object, when containing a value, must contain a value type; storing a
 // reference type is neither desired nor supported.
 //
-// An `absl::any` can only store a type that is copy-constructable; move-only
+// An `absl::any` can only store a type that is copy-constructible; move-only
 // types are not allowed within an `any` object.
 //
 // Example:
@@ -190,7 +190,7 @@ ValueType* any_cast(any* operand) noexcept;
 //   auto a = absl::any(65);                 // Literal, copyable
 //   auto b = absl::any(std::vector<int>()); // Default-initialized, copyable
 //   std::unique_ptr<Foo> my_foo;
-//   auto c = absl::any(std::move(my_foo));  // Error, not copy-constructable
+//   auto c = absl::any(std::move(my_foo));  // Error, not copy-constructible
 //
 // Note that `absl::any` makes use of decayed types (`absl::decay_t` in this
 // context) to remove const-volatile qualifiers (known as "cv qualifiers"),
diff --git a/absl/types/variant.h b/absl/types/variant.h
index ebd52d2..7ef7f88 100644
--- a/absl/types/variant.h
+++ b/absl/types/variant.h
@@ -24,7 +24,7 @@
 // should always hold a value of one of its alternative types (except in the
 // "valueless by exception state" -- see below). A default-constructed
 // `absl::variant` will hold the value of its first alternative type, provided
-// it is default-constructable.
+// it is default-constructible.
 //
 // In exceptional cases due to error, an `absl::variant` can hold no
 // value (known as a "valueless by exception" state), though this is not the
@@ -92,7 +92,7 @@ namespace absl {
 //   // assign it to a std::string.
 //   absl::variant<int, std::string> v = std::string("abc");
 //
-//   // A default-contructed variant will hold a value-initialized value of
+//   // A default-constructed variant will hold a value-initialized value of
 //   // the first alternative type.
 //   auto a = absl::variant<int, std::string>();   // Holds an int of value '0'.
 //