Generic Type Name

Generic type name should only contain alphanumeric characters, start with an uppercase character and span between 1 and 20 characters in length.

  • Identifier: generic_type_name
  • Enabled by default: Yes
  • Supports autocorrection: No
  • Kind: idiomatic
  • Analyzer rule: No
  • Minimum Swift compiler version: 5.0.0
  • Default configuration: (min_length) w/e: 1/0, (max_length) w/e: 20/1000, excluded: [], allowed_symbols: [], validates_start_with_lowercase: error

Non Triggering Examples

func foo<T>() {}

func foo<T>() -> T {}

func foo<T, U>(param: U) -> T {}

func foo<T: Hashable, U: Rule>(param: U) -> T {}

struct Foo<T> {}

class Foo<T> {}

enum Foo<T> {}

func run(_ options: NoOptions<CommandantError<()>>) {}

func foo(_ options: Set<type>) {}

func < <T: Comparable>(lhs: T?, rhs: T?) -> Bool

func configureWith(data: Either<MessageThread, (project: Project, backing: Backing)>)

typealias StringDictionary<T> = Dictionary<String, T>

typealias BackwardTriple<T1, T2, T3> = (T3, T2, T1)

typealias DictionaryOfStrings<T : Hashable> = Dictionary<T, String>

Triggering Examples

func foo<T_Foo>() {}

func foo<T, U_Foo>(param: U_Foo) -> T {}

func foo<TTTTTTTTTTTTTTTTTTTTT>() {}

func foo<type>() {}

typealias StringDictionary<T_Foo> = Dictionary<String, T_Foo>

typealias BackwardTriple<T1, T2_Bar, T3> = (T3, T2_Bar, T1)

typealias DictionaryOfStrings<T_Foo: Hashable> = Dictionary<T_Foo, String>

class Foo<T_Foo> {}

class Foo<T, U_Foo> {}

class Foo<T_Foo, U_Foo> {}

class Foo<TTTTTTTTTTTTTTTTTTTTT> {}

class Foo<type> {}

struct Foo<T_Foo> {}

struct Foo<T, U_Foo> {}

struct Foo<T_Foo, U_Foo> {}

struct Foo<TTTTTTTTTTTTTTTTTTTTT> {}

struct Foo<type> {}

enum Foo<T_Foo> {}

enum Foo<T, U_Foo> {}

enum Foo<T_Foo, U_Foo> {}

enum Foo<TTTTTTTTTTTTTTTTTTTTT> {}

enum Foo<type> {}