Operator: <

operator < { associativity precedence }

Declarations

func <(_: Int, rhs: Int)

Returns a Boolean value that indicates whether the first argument is less than the second argument.

See Also: Equatable, Comparable

Declaration

func <(lhs: Int, rhs: Int) -> Bool
func <(_: Int8, rhs: Int8)

Returns a Boolean value that indicates whether the first argument is less than the second argument.

See Also: Equatable, Comparable

Declaration

func <(lhs: Int8, rhs: Int8) -> Bool
func <(_: Int16, rhs: Int16)

Returns a Boolean value that indicates whether the first argument is less than the second argument.

See Also: Equatable, Comparable

Declaration

func <(lhs: Int16, rhs: Int16) -> Bool
func <(_: Int32, rhs: Int32)

Returns a Boolean value that indicates whether the first argument is less than the second argument.

See Also: Equatable, Comparable

Declaration

func <(lhs: Int32, rhs: Int32) -> Bool
func <(_: Int64, rhs: Int64)

Returns a Boolean value that indicates whether the first argument is less than the second argument.

See Also: Equatable, Comparable

Declaration

func <(lhs: Int64, rhs: Int64) -> Bool
func <(_: UInt, rhs: UInt)

Returns a Boolean value that indicates whether the first argument is less than the second argument.

See Also: Equatable, Comparable

Declaration

func <(lhs: UInt, rhs: UInt) -> Bool
func <(_: UInt8, rhs: UInt8)

Returns a Boolean value that indicates whether the first argument is less than the second argument.

See Also: Equatable, Comparable

Declaration

func <(lhs: UInt8, rhs: UInt8) -> Bool
func <(_: UInt16, rhs: UInt16)

Returns a Boolean value that indicates whether the first argument is less than the second argument.

See Also: Equatable, Comparable

Declaration

func <(lhs: UInt16, rhs: UInt16) -> Bool
func <(_: UInt32, rhs: UInt32)

Returns a Boolean value that indicates whether the first argument is less than the second argument.

See Also: Equatable, Comparable

Declaration

func <(lhs: UInt32, rhs: UInt32) -> Bool
func <(_: UInt64, rhs: UInt64)

Returns a Boolean value that indicates whether the first argument is less than the second argument.

See Also: Equatable, Comparable

Declaration

func <(lhs: UInt64, rhs: UInt64) -> Bool
func <(_: UnsafeMutableRawPointer, rhs: UnsafeMutableRawPointer)

Note: This is an unsigned comparison unlike Strideable's implementation.

Declaration

func <(lhs: UnsafeMutableRawPointer, rhs: UnsafeMutableRawPointer) -> Bool
func <(_: UnsafeRawPointer, rhs: UnsafeRawPointer)

Note: This is an unsigned comparison unlike Strideable's implementation.

Declaration

func <(lhs: UnsafeRawPointer, rhs: UnsafeRawPointer) -> Bool
func < <A : Comparable, B : Comparable, C : Comparable, D : Comparable, E : Comparable, F : Comparable>(_: (A, B, C, D, E, F), rhs: (A, B, C, D, E, F))

Returns a Boolean value indicating whether the first tuple is ordered before the second in a lexicographical ordering.

Given two tuples (a1, a2, ..., aN) and (b1, b2, ..., bN), the first tuple is before the second tuple if and only if a1 < b1 or (a1 == b1 and (a2, ..., aN) < (b2, ..., bN)).

Parameters: lhs: A tuple of Comparable elements. rhs: Another tuple of elements of the same type as lhs.

Declaration

func <<A : Comparable, B : Comparable, C : Comparable, D : Comparable, E : Comparable, F : Comparable>(lhs: (A, B, C, D, E, F), rhs: (A, B, C, D, E, F)) -> Bool
func < <A : Comparable, B : Comparable, C : Comparable, D : Comparable, E : Comparable>(_: (A, B, C, D, E), rhs: (A, B, C, D, E))

Returns a Boolean value indicating whether the first tuple is ordered before the second in a lexicographical ordering.

Given two tuples (a1, a2, ..., aN) and (b1, b2, ..., bN), the first tuple is before the second tuple if and only if a1 < b1 or (a1 == b1 and (a2, ..., aN) < (b2, ..., bN)).

Parameters: lhs: A tuple of Comparable elements. rhs: Another tuple of elements of the same type as lhs.

Declaration

func <<A : Comparable, B : Comparable, C : Comparable, D : Comparable, E : Comparable>(lhs: (A, B, C, D, E), rhs: (A, B, C, D, E)) -> Bool
func < <A : Comparable, B : Comparable, C : Comparable, D : Comparable>(_: (A, B, C, D), rhs: (A, B, C, D))

Returns a Boolean value indicating whether the first tuple is ordered before the second in a lexicographical ordering.

Given two tuples (a1, a2, ..., aN) and (b1, b2, ..., bN), the first tuple is before the second tuple if and only if a1 < b1 or (a1 == b1 and (a2, ..., aN) < (b2, ..., bN)).

Parameters: lhs: A tuple of Comparable elements. rhs: Another tuple of elements of the same type as lhs.

Declaration

func <<A : Comparable, B : Comparable, C : Comparable, D : Comparable>(lhs: (A, B, C, D), rhs: (A, B, C, D)) -> Bool
func < <A : Comparable, B : Comparable, C : Comparable>(_: (A, B, C), rhs: (A, B, C))

Returns a Boolean value indicating whether the first tuple is ordered before the second in a lexicographical ordering.

Given two tuples (a1, a2, ..., aN) and (b1, b2, ..., bN), the first tuple is before the second tuple if and only if a1 < b1 or (a1 == b1 and (a2, ..., aN) < (b2, ..., bN)).

Parameters: lhs: A tuple of Comparable elements. rhs: Another tuple of elements of the same type as lhs.

Declaration

func <<A : Comparable, B : Comparable, C : Comparable>(lhs: (A, B, C), rhs: (A, B, C)) -> Bool
func < <A : Comparable, B : Comparable>(_: (A, B), rhs: (A, B))

Returns a Boolean value indicating whether the first tuple is ordered before the second in a lexicographical ordering.

Given two tuples (a1, a2, ..., aN) and (b1, b2, ..., bN), the first tuple is before the second tuple if and only if a1 < b1 or (a1 == b1 and (a2, ..., aN) < (b2, ..., bN)).

Parameters: lhs: A tuple of Comparable elements. rhs: Another tuple of elements of the same type as lhs.

Declaration

func <<A : Comparable, B : Comparable>(lhs: (A, B), rhs: (A, B)) -> Bool
func < <Pointee>(_: UnsafeMutablePointer<Pointee>, rhs: UnsafeMutablePointer<Pointee>)

Note: Strideable's implementation is potentially less efficient and cannot handle misaligned pointers.

Note: This is an unsigned comparison unlike Strideable's implementation.

Declaration

func <<Pointee>(lhs: UnsafeMutablePointer<Pointee>, rhs: UnsafeMutablePointer<Pointee>) -> Bool
func < <Pointee>(_: UnsafePointer<Pointee>, rhs: UnsafePointer<Pointee>)

Note: Strideable's implementation is potentially less efficient and cannot handle misaligned pointers.

Note: This is an unsigned comparison unlike Strideable's implementation.

Declaration

func <<Pointee>(lhs: UnsafePointer<Pointee>, rhs: UnsafePointer<Pointee>) -> Bool
func < <T : FloatingPoint>(_: T, rhs: T)

Declaration

func <<T : FloatingPoint>(lhs: T, rhs: T) -> Bool
func < <T : Strideable>(_: T, y: T)

Compare two Strideables.

Declaration

func <<T : Strideable>(x: T, y: T) -> Bool
func < <T where T.RawValue : Comparable>(_: T, rhs: T)

Declaration

func <<T where T.RawValue : Comparable>(lhs: T, rhs: T) -> Bool