type-plus 6.5.0 → 6.7.0

package/ts/null/null_type.ts

@@ -3,9 +3,7 @@ import type { IsAny } from '../any/any_type.js'
 /**
  * Check if the type `T` is exactly `null`.
  *
- * ```
- * import type { NullType } from 'type-plus'
- *
+ * ```ts
  * type R = NullType<null> // null
  *
  * type R = NullType<never> // never
@@ -18,9 +16,7 @@ export type NullType<T, Then = T, Else = never> = IsAny<T, Else, [T, null] exten
 /**
  * Is the type `T` exactly `null`.
  *
- * ```
- * import type { IsNull } from 'type-plus'
- *
+ * ```ts
  * type R = IsNull<null> // true
  *
  * type R = IsNull<never> // false
@@ -33,9 +29,7 @@ export type IsNull<T, Then = true, Else = false> = NullType<T, Then, Else>
 /**
  * Check if the type `T` is not exactly `null`.
  *
- * ```
- * import type { NotNullType } from 'type-plus'
- *
+ * ```ts
  * type R = NotNullType<null> // never
  *
  * type R = NotNullType<never> // never
@@ -48,9 +42,7 @@ export type NotNullType<T, Then = T, Else = never> = NullType<T, Else, Then>
 /**
  * Is the type `T` not exactly `null`.
  *
- * ```
- * import type { IsNotNull } from 'type-plus'
- *
+ * ```ts
  * type R = IsNotNull<null> // false
  *
  * type R = IsNotNull<never> // true

package/ts/number/integer.ts

@@ -5,8 +5,6 @@ import type { Numeric } from './numeric_type.js'
  * Check if T is an integer, including bigint.
  *
  * ```ts
- * import type { Integer } from 'type-plus'
- *
  * type R = Integer<0> // 0
  * type R = Integer<1n> // 1n
  *
@@ -24,8 +22,6 @@ export type Integer<T, Then = T, Else = never> = IsAnyOrNever<
  * Is T an integer, including bigint.
  *
  * ```ts
- * import type { IsInteger } from 'type-plus'
- *
  * type R = IsInteger<0> // true
  * type R = IsInteger<1n> // true
  *
@@ -39,8 +35,6 @@ export type IsInteger<T, Then = true, Else = false> = Integer<T, Then, Else>
  * Check if T is not an integer, including bigint.
  *
  * ```ts
- * import type { NotInteger } from 'type-plus'
- *
  * type R = NotInteger<1.1> // 1.1
  * type R = NotInteger<number> // number as it contains non-integer
  *
@@ -68,9 +62,7 @@ export type IsNotInteger<T, Then = true, Else = false> = NotInteger<T, Else, The
 /**
  * Check if T is an integer, including bigint.
  *
- * ```
- * import type { IsWhole } from 'type-plus'
- *
+ * ```ts
  * type R = IsWhole<0> // 0
  * type R = IsWhole<1n> // 1n
  *

package/ts/number/negative.ts

@@ -6,8 +6,6 @@ import type { Zero } from './numeric_type.js'
  * Check if 'T' is a negative numeric type.
  *
  * ```ts
- * import type { Negative } from 'type-plus'
- *
  * type R = Negative<-1> // -1
  * type R = Negative<-1n> // -1n
  *
@@ -42,8 +40,6 @@ export type Negative<T, Then = T, Else = never> = IsAny<
  * Is 'T' a negative numeric type.
  *
  * ```ts
- * import type { IsNegative } from 'type-plus'
- *
  * type R = IsNegative<-1> // true
  * type R = IsNegative<-1n> // true
  *
@@ -60,8 +56,6 @@ export type IsNegative<T, Then = true, Else = false> = Negative<T, Then, Else>
  * Check if 'T' is not a negative numeric type.
  *
  * ```ts
- * import type { NotNegative } from 'type-plus'
- *
  * type R = NotNegative<-1> // never
  * type R = NotNegative<-1n> // never
  *
@@ -94,8 +88,6 @@ export type NotNegative<T, Then = T, Else = never> = IsAny<
  * Is 'T' not a negative numeric type.
  *
  * ```ts
- * import type { IsNotNegative } from 'type-plus'
- *
  * type R = IsNotNegative<-1> // false
  * type R = IsNotNegative<-1n> // false
  *

package/ts/number/number_type.ts

@@ -4,8 +4,6 @@ import type { IsAnyOrNever } from '../any/any_or_never.js'
  * Check if the type `T` is `number`.
  *
  * ```ts
- * import type { NumberType } from 'type-plus'
- *
  * type R = NumberType<number> // true
  * type R = NumberType<1> // true
  *
@@ -19,8 +17,6 @@ export type NumberType<T, Then = T, Else = never> = IsAnyOrNever<T, Else, [T] ex
  * Is the type `T` is `number`.
  *
  * ```ts
- * import type { IsNumber } from 'type-plus'
- *
  * type R = IsNumber<number> // true
  * type R = IsNumber<1> // true
  *
@@ -34,8 +30,6 @@ export type IsNumber<T, Then = true, Else = false> = NumberType<T, Then, Else>
  * Check if the type `T` is not `number`.
  *
  * ```ts
- * import type { NotNumberType } from 'type-plus'
- *
  * type R = NotNumberType<number> // false
  * type R = NotNumberType<1> // false
  *
@@ -49,8 +43,6 @@ export type NotNumberType<T, Then = T, Else = never> = NumberType<T, Else, Then>
  * Is the type `T` not `number`.
  *
  * ```ts
- * import type { IsNotNumber } from 'type-plus'
- *
  * type R = IsNotNumber<number> // false
  * type R = IsNotNumber<1> // false
  *

package/ts/number/numeric_type.ts

@@ -15,8 +15,6 @@ export type Zero = 0 | 0n
  * Meaning it is either a `number` or a `bigint`.
  *
  * ```ts
- * import type { NumericType } from 'type-plus'
- *
  * type R = NumericType<1> // 1
  * type R = NumericType<1.1> // 1.1
  *
@@ -30,8 +28,6 @@ export type NumericType<T, Then = T, Else = never> = IsAnyOrNever<T, Else, [T] e
  * Is `T` numeric.
  *
  * ```ts
- * import type { IsNumeric } from 'type-plus'
- *
  * type R = IsNumeric<1> // true
  * type R = IsNumeric<1.1> // true
  *
@@ -45,8 +41,6 @@ export type IsNumeric<T, Then = true, Else = false> = NumericType<T, Then, Else>
  * Check if `T` is not numeric.
  *
  * ```ts
- * import type { NotNumericType } from 'type-plus'
- *
  * type R = NotNumericType<1> // never
  * type R = NotNumericType<1.1> // never
  *
@@ -60,8 +54,6 @@ export type NotNumericType<T, Then = T, Else = never> = NumericType<T, Else, The
  * Is `T` not numeric.
  *
  * ```ts
- * import type { IsNotNumeric } from 'type-plus'
- *
  * type R = IsNotNumeric<1> // false
  * type R = IsNotNumeric<1.1> // false
  *

package/ts/number/positive.ts

@@ -5,8 +5,6 @@ import { IsNever } from '../index.js'
  * Check if `T` is a positive numeric type.
  *
  * ```ts
- * import type { Positive } from 'type-plus'
- *
  * type R = Positive<1> // 1
  * type R = Positive<0> // 0
  * type R = Positive<1n> // 1n
@@ -24,15 +22,13 @@ export type Positive<T, Then = T, Else = never> = IsAny<
  * Is `T` a positive numeric type.
  *
  * ```ts
- * import type { IsPositive } from 'type-plus'
- *
  * type R = IsPositive<1> // true
  * type R = IsPositive<0> // true
  * type R = IsPositive<1n> // true
  *
  * type R = IsPositive<number> // boolean
  * type R = IsPositive<bigint> // boolean
- * type R = IsPosistive<any> // boolean
+ * type R = IsPositive<any> // boolean
  *
  * type R = IsPositive<-1> // false
  * ```
@@ -43,8 +39,6 @@ export type IsPositive<T, Then = true, Else = false> = Positive<T, Then, Else>
  * Check if `T` is not a positive numeric type.
  *
  * ```ts
- * import type { NonPositive } from 'type-plus'
- *
  * type R = NonPositive<-1> // -1
  *
  * type R = NonPositive<0> // never
@@ -57,8 +51,6 @@ export type NonPositive<T, Then = T, Else = never> = Positive<T, Else, Then>
  * Is `T` not a positive numeric type.
  *
  * ```ts
- * import type { IsNotPositive } from 'type-plus'
- *
  * type R = IsNotPositive<-1> // true
  *
  * type R = IsNotPositive<0> // false

package/ts/number/strict_number_type.ts

@@ -4,8 +4,6 @@ import type { IsAny } from '../any/any_type.js'
  * Check if the type `T` is exactly the type `number` and not numeric literals.
  *
  * ```ts
- * import type { StrictNumberType } from 'type-plus'
- *
  * type R = StrictNumberType<number> // true
  * type R = StrictNumberType<1> // false
  *
@@ -23,8 +21,6 @@ export type StrictNumberType<T, Then = T, Else = never> = IsAny<
  * Is the type `T` exactly the type `number` and not numeric literals.
  *
  * ```ts
- * import type { IsStrictNumber } from 'type-plus'
- *
  * type R = IsStrictNumber<number> // true
  * type R = IsStrictNumber<1> // false
  *
@@ -38,13 +34,11 @@ export type IsStrictNumber<T, Then = true, Else = false> = StrictNumberType<T, T
  * Check if the type `T` is not the type `number` or numeric literals.
  *
  * ```ts
- * import type { NotStictNumberType } from 'type-plus'
+ * type R = NotStrictNumberType<number> // false
+ * type R = NotStrictNumberType<1> // true
  *
- * type R = NotStictNumberType<number> // false
- * type R = NotStictNumberType<1> // true
- *
- * type R = NotStictNumberType<never> // true
- * type R = NotStictNumberType<unknown> // true
+ * type R = NotStrictNumberType<never> // true
+ * type R = NotStrictNumberType<unknown> // true
  * ```
  */
 export type NotStrictNumberType<T, Then = T, Else = never> = StrictNumberType<T, Else, Then>
@@ -53,8 +47,6 @@ export type NotStrictNumberType<T, Then = T, Else = never> = StrictNumberType<T,
  * Is the type `T` not the type `number` or numeric literals.
  *
  * ```ts
- * import type { IsNotStrictNumber } from 'type-plus'
- *
  * type R = IsNotStrictNumber<number> // false
  * type R = IsNotStrictNumber<1> // true
  *

package/ts/object/object_type.ts

@@ -1,11 +1,9 @@
-import { IsAnyOrNever } from '../any/any_or_never.js'
+import type { IsAnyOrNever } from '../any/any_or_never.js'
 
 /**
  * Check if `T` is an `object`.
  *
  * ```ts
- * import { type ObjectType } from 'type-plus'
- *
  * type R = ObjectType<{}> // {}
  * type R = ObjectType<{ a: 1 }> // { a: 1 }
  * type R = ObjectType<Function> // Function
@@ -21,8 +19,6 @@ export type ObjectType<T, Then = T, Else = never> = IsAnyOrNever<T, Else, [T] ex
  * Note that `Function` is also an `object`.
  *
  * ```ts
- * import { type IsObject } from 'type-plus'
- *
  * type R = IsObject<{}> // true
  * type R = IsObject<{ a: 1 }> // true
  * type R = IsObject<Function> // true
@@ -36,8 +32,6 @@ export type IsObject<T, Then = true, Else = false> = ObjectType<T, Then, Else>
  * Check if `T` is not an `object`.
  *
  * ```ts
- * import { type NotObjectType } from 'type-plus'
- *
  * type R = NotObjectType<{}> // never
  * type R = NotObjectType<{ a: 1 }> // never
  * type R = NotObjectType<Function> // never
@@ -53,8 +47,6 @@ export type NotObjectType<T, Then = T, Else = never> = ObjectType<T, Else, Then>
  * Note that `Function` is also an `object`.
  *
  * ```ts
- * import { type IsNotObject } from 'type-plus'
- *
  * type R = IsNotObject<{}> // false
  * type R = IsNotObject<{ a: 1 }> // false
  * type R = IsNotObject<Function> // false

package/ts/string/readme.md

@@ -36,6 +36,11 @@ type R = StrictStringType<1> // never
 - [`NotStrictStringType<T, Then = T, Else = never>`](strict_string_type.ts#L52): check if `T` is not exactly `string`.
 - [`IsNotStrictString<T, Then = true, Else = false>`](strict_string_type.ts#L69): is `T` not exactly `string`.
 
+## String Utilities
+
+- [`StringIncludes<Subject, Search, Then = true, Else = false>`](./string.ts): check if `Subject` includes `Search`.
+- [`StringSplit<Subject, Separater>`](./string.ts): split `Subject` by `Separater`.
+
 ## References
 
 - [Handbook]

package/ts/string/strict_string_type.ts

@@ -3,26 +3,26 @@ import type { IsAny } from '../any/any_type.js'
 /**
  * Check if the type `T` is exactly `string`.
  *
- * ```
- * import type { StrictStringType } from 'type-plus'
- *
+ * ```ts
  * type R = StrictStringType<string> // string
-*
-* type R = StrictStringType<''> // never
-* type R = StrictStringType<'1'> // never
-* type R = StrictStringType<string | boolean> // never
-* type R = StrictStringType<never> // never
-* type R = StrictStringType<unknown> // never
+ *
+ * type R = StrictStringType<''> // never
+ * type R = StrictStringType<'1'> // never
+ * type R = StrictStringType<string | boolean> // never
+ * type R = StrictStringType<never> // never
+ * type R = StrictStringType<unknown> // never
  * ```
  */
-export type StrictStringType<T, Then = T, Else = never> = IsAny<T, Else, [T, string] extends [string, T] ? Then : Else>
+export type StrictStringType<T, Then = T, Else = never> = IsAny<
+	T,
+	Else,
+	[T, string] extends [string, T] ? Then : Else
+>
 
 /**
  * Is the type `T` exactly `string`.
  *
- * ```
- * import type { IsStrictString } from 'type-plus'
- *
+ * ```ts
  * type R = IsStrictString<string> // true
  *
  * type R = IsStrictString<''> // false
@@ -37,9 +37,7 @@ export type IsStrictString<T, Then = true, Else = false> = StrictStringType<T, T
 /**
  * Check if the type `T` is not exactly `string`.
  *
- * ```
- * import type { NotStrictStringType } from 'type-plus'
- *
+ * ```ts
  * type R = NotStrictStringType<string> // never
  *
  * type R = NotStrictStringType<''> // ''
@@ -54,9 +52,7 @@ export type NotStrictStringType<T, Then = T, Else = never> = StrictStringType<T,
 /**
  * Is the type `T` not exactly `string`.
  *
- * ```
- * import type { IsNotStrictString } from 'type-plus'
- *
+ * ```ts
  * type R = IsNotStrictString<string> // false
  *
  * type R = IsNotStrictString<''> // true

package/ts/string/string.ts

@@ -0,0 +1,36 @@
+/**
+ * Check if `Subject` includes `Search`.
+ * If either of them is not a string, returns `Else`.
+ *
+ * ```ts
+ * type R = StringIncludes<'abc', 'a'> // true
+ *
+ * type R = StringIncludes<'abc', 'd'> // false
+ * ```
+ */
+export type StringIncludes<
+	Subject extends string,
+	Search extends string,
+	Then = true,
+	Else = false
+> = Subject extends `${infer _}${Search}${infer _}` ? Then : Else
+
+/**
+ * Split a string into substrings using the specified separator,
+ * and return them as an array.
+ *
+ * ```ts
+ * type R = StringSplit<'abc', ''> // ['a', 'b', 'c']
+ * type R = StringSplit<'abc', 'a'> // ['', 'bc']
+ * type R = StringSplit<'abc', 'b'> // ['a', 'c']
+ * type R = StringSplit<'abc', 'c'> // ['ab', '']
+ * ```
+ */
+export type StringSplit<
+	Subject extends string,
+	Seperator extends string
+> = Subject extends `${infer A}${Seperator}${infer B}`
+	? [A, ...StringSplit<B, Seperator>]
+	: Seperator extends ''
+	? []
+	: [Subject]

package/ts/string/string_plus.ts

@@ -0,0 +1,33 @@
+import type { StringIncludes, StringSplit } from './string.js'
+
+export namespace StringPlus {
+	/**
+	 * Check if `Subject` includes `Search`.
+	 * If either of them is not a string, returns `Else`.
+	 *
+	 * ```ts
+	 * type R = StringPlus.Includes<'abc', 'a'> // true
+	 *
+	 * type R = StringPlus.Includes<'abc', 'd'> // false
+	 * ```
+	 */
+	export type Includes<
+		Subject extends string,
+		Search extends string,
+		Then = true,
+		Else = false
+	> = StringIncludes<Subject, Search, Then, Else>
+
+	/**
+	 * Split a string into substrings using the specified separator,
+	 * and return them as an array.
+	 *
+	 * ```ts
+	 * type R = StringPlus.Split<'abc', ''> // ['a', 'b', 'c']
+	 * type R = StringPlus.Split<'abc', 'a'> // ['', 'bc']
+	 * type R = StringPlus.Split<'abc', 'b'> // ['a', 'c']
+	 * type R = StringPlus.Split<'abc', 'c'> // ['ab', '']
+	 * ```
+	 */
+	export type Split<Subject extends string, Seperator extends string> = StringSplit<Subject, Seperator>
+}

package/ts/string/string_type.ts

@@ -3,9 +3,7 @@ import type { IsAnyOrNever } from '../any/any_or_never.js'
 /**
  * Check if the type `T` is `string` or string literals.
  *
- * ```
- * import type { StringType } from 'type-plus'
- *
+ * ```ts
  * type R = StringType<string> // string
  * type R = StringType<''> // ''
  * type R = StringType<'1'> // '1'
@@ -20,9 +18,7 @@ export type StringType<T, Then = T, Else = never> = IsAnyOrNever<T, Else, [T] ex
 /**
  * Is the type `T` `string` or string literals.
  *
- * ```
- * import type { IsString } from 'type-plus'
- *
+ * ```ts
  * type R = IsString<string> // true
  * type R = IsString<''> // true
  * type R = IsString<'a'> // true
@@ -37,9 +33,7 @@ export type IsString<T, Then = true, Else = false> = StringType<T, Then, Else>
 /**
  * Check if the type `T` is not `string` nor string literals.
  *
- * ```
- * import type { NotStringType } from 'type-plus'
- *
+ * ```ts
  * type R = NotStringType<string> // never
  * type R = NotStringType<''> // ''
  * type R = NotStringType<'a'> // 'a'
@@ -54,9 +48,7 @@ export type NotStringType<T, Then = T, Else = never> = StringType<T, Else, Then>
 /**
  * Is the type `T` not `string` nor string literals.
  *
- * ```
- * import type { IsNotString } from 'type-plus'
- *
+ * ```ts
  * type R = IsNotString<string> // false
  * type R = IsNotString<''> // false
  * type R = IsNotString<'a'> // false

package/ts/symbol/symbol_type.ts

@@ -3,9 +3,7 @@ import type { IsAnyOrNever } from '../any/any_or_never.js'
 /**
  * Check if the type `T` is exactly `symbol`.
  *
- * ```
- * import type { SymbolType } from 'type-plus'
- *
+ * ```ts
  * type R = SymbolType<symbol> // symbol
  *
  * type R = SymbolType<never> // never
@@ -13,18 +11,12 @@ import type { IsAnyOrNever } from '../any/any_or_never.js'
  * type R = SymbolType<symbol | boolean> // never
  * ```
  */
-export type SymbolType<T, Then = T, Else = never> = IsAnyOrNever<
-	T,
-	Else,
-	[T] extends [symbol] ? Then : Else
->
+export type SymbolType<T, Then = T, Else = never> = IsAnyOrNever<T, Else, [T] extends [symbol] ? Then : Else>
 
 /**
  * Is the type `T` exactly `symbol`.
  *
- * ```
- * import type { IsSymbol } from 'type-plus'
- *
+ * ```ts
  * type R = IsSymbol<symbol> // true
  *
  * type R = IsSymbol<never> // false
@@ -37,9 +29,7 @@ export type IsSymbol<T, Then = true, Else = false> = SymbolType<T, Then, Else>
 /**
  * Check if the type `T` is not `symbol`.
  *
- * ```
- * import type { NotSymbolType } from 'type-plus'
- *
+ * ```ts
  * type R = NotSymbolType<symbol> // never
  *
  * type R = NotSymbolType<never> // never
@@ -52,9 +42,7 @@ export type NotSymbolType<T, Then = T, Else = never> = SymbolType<T, Else, Then>
 /**
  * Is the type `T` not `symbol`.
  *
- * ```
- * import type { IsNotSymbol } from 'type-plus'
- *
+ * ```ts
  * type R = IsNotSymbol<symbol> // false
  *
  * type R = IsNotSymbol<never> // true

package/ts/testing/stub.ts

@@ -1,12 +1,15 @@
 import { requiredDeep } from 'unpartial'
 import type { AnyFunction } from '../function/any_function.js'
 import type { RecursivePartial } from '../object/RecursivePartial.js'
+import type { NoInfer } from '../type/no_infer.js'
 
 export namespace stub {
-	export type Param<T> = T extends AnyFunction ? T : RecursivePartial<T>
+	export type Param<T> = T extends AnyFunction ? T : RecursivePartial<NoInfer<T>>
 }
 
-export function stub<T>(stub?: stub.Param<T>) {
+export function stub<T extends AnyFunction>(stub: T): T
+export function stub<T>(stub: RecursivePartial<NoInfer<T>>): T
+export function stub<T>(stub: unknown): T {
 	return stub as T
 }
 
@@ -18,7 +21,7 @@ function build<T>(init: RecursivePartial<T> | (() => RecursivePartial<T>)): (stu
 function build<T>(init?: RecursivePartial<T> | (() => RecursivePartial<T>)) {
 	return function (value?: stub.Param<T>) {
 		const initValue = typeof init === 'function' ? init() : init
-		return initValue ? stub<T>(requiredDeep(initValue, value) as any) : stub<T>(value)
+		return initValue ? stub(requiredDeep(initValue, value) as any) : stub(value as any)
 	}
 }
 

package/ts/tuple/tuple_type.ts

@@ -4,8 +4,6 @@ import type { IsNever } from '../never/never_type.js'
  * Check if `T` is a tuple and not an array.
  *
  * ```ts
- * import type { TupleType } from 'type-plus'
- *
  * type R = TupleType<[]>       // []
  * type R = TupleType<[1]>      // [1]
  *
@@ -25,8 +23,6 @@ export type TupleType<T, Then = T, Else = never> = IsNever<
  * Check if `T` is not a tuple.
  *
  * ```ts
- * import type { NotTupleType } from 'type-plus'
- *
  * type R = NotTupleType<[]>       // never
  * type R = NotTupleType<[1]>      // never
  *
@@ -42,8 +38,6 @@ export type NotTupleType<T, Then = T, Else = never> = TupleType<T, Else, Then>
  * Is `T` a tuple and not an array.
  *
  * ```ts
- * import type { IsTuple } from 'type-plus'
- *
  * type R = IsTuple<[]>       // true
  *
  * type R = IsTuple<number[]> // false
@@ -58,8 +52,6 @@ export type IsTuple<T, Then = true, Else = false> = TupleType<T, Then, Else>
  * Is `T` not a tuple.
  *
  * ```ts
- * import type { IsNotTuple } from 'type-plus'
- *
  * type R = IsNotTuple<[]>       // false
  * type R = IsNotTuple<[1]>      // false
  *

package/ts/type/failed.ts

@@ -1,4 +1,4 @@
-import { uniSym } from './constants.js'
+declare const uniSym: unique symbol
 
 /**
  * A failed type with message.
@@ -11,8 +11,6 @@ import { uniSym } from './constants.js'
  * use `FailedT` or create your own failed type instead.
  *
  * ```ts
- * import { Failed } from 'type-plus'
- *
  * type T = Failed<'error message'>
  * ```
  */

package/ts/type/no_infer.ts

@@ -0,0 +1,24 @@
+import { IsNull } from '../null/null_type.js'
+import { Or } from '../predicates/logical.js'
+import { IsUndefined } from '../undefined/undefined_type.js'
+
+/**
+ * Prevents inference of a type parameter `T`.
+ *
+ * A build-in type `NoInfer` is coming soon.
+ * @see https://github.com/microsoft/TypeScript/pull/52968
+ *
+ * @by @ajafff
+ *
+ * @example
+ * ```ts
+ * function assertEqual<T>(a: T, b: NoInfer<T>) {
+ *   return a === b
+ * }
+ *
+ * assertEqual(123, 324) // OK
+ * assertEqual(123, 'abc') // Error
+ * assertEqual({ x: 1 }, { x: 1, y: 2 }) // Error
+ * ```
+ */
+export type NoInfer<T> = Or<IsNull<T>, IsUndefined<T>, T, T & {}>