style(global): fix typos

utils/tfhe-versionable-derive/src/associated.rs

@@ -87,7 +87,7 @@ pub(crate) enum AssociatedTypeKind {
 /// - A `ref` type, that holds a reference to the underlying data. This is used for faster
 ///   versioning using only references.
 /// - An owned type, that owns the underlying data. This is used for unversioning. The ownership of
-///   the data will be transfered during the unversioning process.
+///   the data will be transferred during the unversioning process.
 ///
 /// [`DispatchType`]: crate::dispatch_type::DispatchType
 /// [`VersionType`]: crate::dispatch_type::VersionType
@@ -151,7 +151,7 @@ pub(crate) trait AssociatedType: Sized {
     fn inner_types(&self) -> syn::Result<Vec<&Type>>;
 
     /// If the associating trait that uses this type needs a type parameter, this returns it.
-    /// For the `VersionsDispatch` trait this paramter is the name of the currently used version,
+    /// For the `VersionsDispatch` trait this parameter is the name of the currently used version,
     /// which is the latest variant of the dispatch enum. The `Version` trait does not need a
     /// parameter.
     fn as_trait_param(&self) -> Option<syn::Result<&Type>>;
@@ -245,7 +245,7 @@ impl<T: AssociatedType> AssociatingTrait<T> {
             // generate better errors in case of misuse of the macros. However in some cases
             // this may generate a warning, so we silence it.
             private_bounds,
-            // If these lints doesn't trigger on the orginal type, we don't want them to trigger
+            // If these lints doesn't trigger on the original type, we don't want them to trigger
             // on the generated one
             clippy::upper_case_acronyms,
             clippy::large_enum_variant,

utils/tfhe-versionable-derive/src/version_type.rs

@@ -23,7 +23,7 @@ use crate::{
 
 /// The types generated for a specific version of a given exposed type. These types are identical to
 /// the user written version types except that their subtypes are replaced by their "Versioned"
-/// form. This allows recursive versionning.
+/// form. This allows recursive versioning.
 pub(crate) struct VersionType {
     orig_type: DeriveInput,
     kind: AssociatedTypeKind,
@@ -681,7 +681,7 @@ fn is_unit(input: &DeriveInput) -> bool {
     }
 }
 
-/// Returns the fields of the input type. This is independant of the kind of type
+/// Returns the fields of the input type. This is independent of the kind of type
 /// (enum, struct, ...)
 fn derive_type_fields(input: &DeriveInput) -> Punctuated<&Field, Comma> {
     match &input.data {

utils/tfhe-versionable/README.md

@@ -1,7 +1,7 @@
 # TFHE-versionable
 This crate provides type level versioning for serialized data. It offers a way
 to add backward compatibility on any data type. The versioning scheme works
-recursively and is independant of the chosen serialized file format. It uses the
+recursively and is independent of the chosen serialized file format. It uses the
 `serde` framework.
 
 The crate will convert any type into an equivalent packed with versions

utils/tfhe-versionable/src/lib.rs

@@ -48,7 +48,7 @@ pub trait VersionizeOwned {
     fn versionize_owned(self) -> Self::VersionedOwned;
 }
 
-/// This trait is used as a proxy to be more felxible when deriving Versionize for Vec<T>.
+/// This trait is used as a proxy to be more flexible when deriving Versionize for Vec<T>.
 ///
 /// This way, we can chose to skip versioning Vec<T> if T is a native types but still versionize in
 /// a loop if T is a custom type.