Permalink
Branch: master
Find file Copy path
Fetching contributors…
Cannot retrieve contributors at this time
202 lines (185 sloc) 6.27 KB
//===----------------------------------------------------------------------===//
//
// This source file is part of the Swift.org open source project
//
// Copyright (c) 2014 - 2017 Apple Inc. and the Swift project authors
// Licensed under Apache License v2.0 with Runtime Library Exception
//
// See https://swift.org/LICENSE.txt for license information
// See https://swift.org/CONTRIBUTORS.txt for the list of Swift project authors
//
//===----------------------------------------------------------------------===//
// Generate comparison functions for tuples up to some reasonable arity.
%{
comparableOperators = [
('<', 'before'),
('<=', 'before or the same as'),
('>', 'after'),
('>=', 'after or the same as')
]
}%
/// Returns a Boolean value indicating whether the corresponding components of
/// two tuples are equal.
///
/// All arity zero tuples are equal.
///
/// - Parameters:
/// - lhs: An empty tuple.
/// - rhs: An empty tuple.
@inlinable // trivial-implementation
public func ==(lhs: (), rhs: ()) -> Bool {
return true
}
/// Returns a Boolean value indicating whether any corresponding components of
/// the two tuples are not equal.
///
/// All arity zero tuples are equal.
///
/// - Parameters:
/// - lhs: An empty tuple.
/// - rhs: An empty tuple.
@inlinable // trivial-implementation
public func !=(lhs: (), rhs: ()) -> Bool {
return false
}
/// Returns a Boolean value indicating whether the first tuple is ordered
/// before the second in a lexicographical ordering.
///
/// An arity zero tuple is never strictly before another arity zero tuple in a
/// lexicographical ordering.
///
/// - Parameters:
/// - lhs: An empty tuple.
/// - rhs: An empty tuple.
@inlinable // trivial-implementation
public func <(lhs: (), rhs: ()) -> Bool {
return false
}
/// Returns a Boolean value indicating whether the first tuple is ordered
/// before or the same as the second in a lexicographical ordering.
///
/// An arity zero tuple is always before or the same as another arity zero tuple
/// in a lexicographical ordering.
///
/// - Parameters:
/// - lhs: An empty tuple.
/// - rhs: An empty tuple.
@inlinable // trivial-implementation
public func <=(lhs: (), rhs: ()) -> Bool {
return true
}
/// Returns a Boolean value indicating whether the first tuple is ordered
/// after the second in a lexicographical ordering.
///
/// An arity zero tuple is never strictly after another arity zero tuple in a
/// lexicographical ordering.
///
/// - Parameters:
/// - lhs: An empty tuple.
/// - rhs: An empty tuple.
@inlinable // trivial-implementation
public func >(lhs: (), rhs: ()) -> Bool {
return false
}
/// Returns a Boolean value indicating whether the first tuple is ordered
/// after or the same as the second in a lexicographical ordering.
///
/// An arity zero tuple is always after or the same as another arity zero tuple
/// in a lexicographical ordering.
///
/// - Parameters:
/// - lhs: An empty tuple.
/// - rhs: An empty tuple.
@inlinable // trivial-implementation
public func >=(lhs: (), rhs: ()) -> Bool {
return true
}
% for arity in range(2,7):
% typeParams = [chr(ord("A") + i) for i in range(arity)]
% tupleT = "({})".format(",".join(typeParams))
% equatableTypeParams = ", ".join(["{} : Equatable".format(c) for c in typeParams])
% originalTuple = "(\"a\", {})".format(", ".join(map(str, range(1, arity))))
% greaterTuple = "(\"a\", {})".format(", ".join(map(str, range(1, arity - 1) + [arity])))
/// Returns a Boolean value indicating whether the corresponding components of
/// two tuples are equal.
///
/// For two tuples to compare as equal, each corresponding pair of components
/// must be equal. The following example compares tuples made up of ${arity}
/// components:
///
/// let a = ${originalTuple}
/// let b = ${originalTuple}
/// print(a == b)
/// // Prints "true"
///
/// let c = ${greaterTuple}
/// print(a == c)
/// // Prints "false"
///
/// - Parameters:
/// - lhs: A tuple of `Equatable` elements.
/// - rhs: Another tuple of elements of the same type as `lhs`.
@inlinable // trivial-implementation
public func == <${equatableTypeParams}>(lhs: ${tupleT}, rhs: ${tupleT}) -> Bool {
guard lhs.0 == rhs.0 else { return false }
/*tail*/ return (
${", ".join("lhs.{}".format(i) for i in range(1, arity))}
) == (
${", ".join("rhs.{}".format(i) for i in range(1, arity))}
)
}
/// Returns a Boolean value indicating whether any corresponding components of
/// the two tuples are not equal.
///
/// For two tuples to compare as equal, each corresponding pair of components
/// must be equal. The following example compares tuples made up of ${arity}
/// components:
///
/// let a = ${originalTuple}
/// let b = ${originalTuple}
/// print(a != b)
/// // Prints "false"
///
/// let c = ${greaterTuple}
/// print(a != c)
/// // Prints "true"
///
/// - Parameters:
/// - lhs: A tuple of `Equatable` elements.
/// - rhs: Another tuple of elements of the same type as `lhs`.
@inlinable // trivial-implementation
public func != <${equatableTypeParams}>(lhs: ${tupleT}, rhs: ${tupleT}) -> Bool {
guard lhs.0 == rhs.0 else { return true }
/*tail*/ return (
${", ".join("lhs.{}".format(i) for i in range(1, arity))}
) != (
${", ".join("rhs.{}".format(i) for i in range(1, arity))}
)
}
% comparableTypeParams = ", ".join(["{} : Comparable".format(c) for c in typeParams])
% for op, phrase in comparableOperators:
/// Returns a Boolean value indicating whether the first tuple is ordered
/// ${phrase} the second in a lexicographical ordering.
///
/// Given two tuples `(a1, a2, ..., aN)` and `(b1, b2, ..., bN)`, the first
/// tuple is ${phrase} the second tuple if and only if
/// `a1 ${op.replace('=', '')} b1` or (`a1 == b1` and
/// `(a2, ..., aN) ${op} (b2, ..., bN)`).
///
/// - Parameters:
/// - lhs: A tuple of `Comparable` elements.
/// - rhs: Another tuple of elements of the same type as `lhs`.
@inlinable // trivial-implementation
public func ${op} <${comparableTypeParams}>(lhs: ${tupleT}, rhs: ${tupleT}) -> Bool {
if lhs.0 != rhs.0 { return lhs.0 ${op} rhs.0 }
/*tail*/ return (
${", ".join("lhs.{}".format(i) for i in range(1, arity))}
) ${op} (
${", ".join("rhs.{}".format(i) for i in range(1, arity))}
)
}
% end
% end
// ${'Local Variables'}:
// eval: (read-only-mode 1)
// End: