Merge pull request #163 from CodaFi/ifdef-i-could-i-would

CodaFi · CodaFi · commit 695257710fcf · 2015-01-21T22:01:57.000-07:00
Fix iOS Carthage Build
diff --git a/swiftz/Sections.swift b/swiftz/Sections.swift
@@ -674,13 +674,15 @@ public postfix func %<T : _IntegerArithmeticType>(lhs: T) -> T -> T {
 	return { rhs in lhs % rhs }
 }
 
+#if os(OSX)
 public prefix func %(rhs: Swift.Float80) -> Swift.Float80 -> Swift.Float80 {
 	return { lhs in lhs % rhs }
 }
 
 public postfix func %(lhs: Swift.Float80) -> Swift.Float80 -> Swift.Float80 {
 	return { rhs in lhs % rhs }
 }
+#endif
 
 public prefix func %(rhs: Double) -> Double -> Double {
 	return { lhs in lhs % rhs }
@@ -789,13 +791,15 @@ public postfix func *<T : _IntegerArithmeticType>(lhs: T) -> T -> T {
 	return { rhs in lhs * rhs }
 }
 
+#if os(OSX)
 public prefix func *(rhs: Swift.Float80) -> Swift.Float80 -> Swift.Float80 {
 	return { lhs in lhs * rhs }
 }
 
 public postfix func *(lhs: Swift.Float80) -> Swift.Float80 -> Swift.Float80 {
 	return { rhs in lhs * rhs }
 }
+#endif
 
 public prefix func *(rhs: Double) -> Double -> Double {
 	return { lhs in lhs * rhs }
@@ -904,13 +908,15 @@ public postfix func +<T : _IntegerArithmeticType>(lhs: T) -> T -> T {
 	return { rhs in lhs + rhs }
 }
 
+#if os(OSX)
 public prefix func +(rhs: Swift.Float80) -> Swift.Float80 -> Swift.Float80 {
 	return { lhs in lhs + rhs }
 }
 
 public postfix func +(lhs: Swift.Float80) -> Swift.Float80 -> Swift.Float80 {
 	return { rhs in lhs + rhs }
 }
+#endif
 
 public prefix func +(rhs: Double) -> Double -> Double {
 	return { lhs in lhs + rhs }
@@ -1034,9 +1040,11 @@ public postfix func -<T : _IntegerArithmeticType>(lhs: T) -> T -> T {
 	return { rhs in lhs - rhs }
 }
 
+#if os(OSX)
 public postfix func -(lhs: Swift.Float80) -> Swift.Float80 -> Swift.Float80 {
 	return { rhs in lhs - rhs }
 }
+#endif
 
 public postfix func -(lhs: Double) -> Double -> Double {
 	return { rhs in lhs - rhs }
@@ -1129,13 +1137,15 @@ public postfix func /<T : _IntegerArithmeticType>(lhs: T) -> T -> T {
 	return { rhs in lhs / rhs }
 }
 
+#if os(OSX)
 public prefix func /(rhs: Swift.Float80) -> Swift.Float80 -> Swift.Float80 {
 	return { lhs in lhs / rhs }
 }
 
 public postfix func /(lhs: Swift.Float80) -> Swift.Float80 -> Swift.Float80 {
 	return { rhs in lhs / rhs }
 }
+#endif
 
 public prefix func /(rhs: Double) -> Double -> Double {
 	return { lhs in lhs / rhs }
@@ -1313,13 +1323,15 @@ public prefix func ==(rhs: Character) -> Character -> Bool {
 	return { lhs in lhs == rhs }
 }
 
+#if os(OSX)
 public postfix func ==(lhs: Swift.Float80) -> Swift.Float80 -> Bool {
 	return { rhs in lhs == rhs }
 }
 
 public prefix func ==(rhs: Swift.Float80) -> Swift.Float80 -> Bool {
 	return { lhs in lhs == rhs }
 }
+#endif
 
 public postfix func ==(lhs: FloatingPointClassification) -> FloatingPointClassification -> Bool {
 	return { rhs in lhs == rhs }
@@ -1675,13 +1687,15 @@ public prefix func !=(rhs: Character) -> Character -> Bool {
 	return { lhs in lhs == rhs }
 }
 
+#if os(OSX)
 public postfix func !=(lhs: Swift.Float80) -> Swift.Float80 -> Bool {
 	return { rhs in lhs == rhs }
 }
 
 public prefix func !=(rhs: Swift.Float80) -> Swift.Float80 -> Bool {
 	return { lhs in lhs == rhs }
 }
+#endif
 
 public postfix func !=(lhs: FloatingPointClassification) -> FloatingPointClassification -> Bool {
 	return { rhs in lhs == rhs }
@@ -2208,9 +2222,11 @@ public prefix func ><T : _Comparable>(rhs: T?) -> T? -> Bool {
 	return { lhs in lhs > rhs }
 }
 
+#if os(OSX)
 public prefix func >(rhs: Swift.Float80) -> Swift.Float80 -> Bool {
 	return { lhs in lhs > rhs }
 }
+#endif
 
 public prefix func >(rhs: Double) -> Double -> Bool {
 	return { lhs in lhs > rhs }
@@ -2303,9 +2319,11 @@ public postfix func <<T : _Comparable>(lhs: T?) -> T? -> Bool {
 	return { rhs in lhs < rhs }
 }
 
+#if os(OSX)
 public postfix func <(lhs: Swift.Float80) -> Swift.Float80 -> Bool {
 	return { rhs in lhs < rhs }
 }
+#endif
 
 public postfix func <(lhs: Double) -> Double -> Bool {
 	return { rhs in lhs < rhs }
diff --git a/swiftz_core/swiftz_core/Sections.swift b/swiftz_core/swiftz_core/Sections.swift
@@ -543,13 +543,15 @@ public postfix func % <T : _IntegerArithmeticType>(lhs: T) -> T -> T {
 	return { rhs in lhs % rhs }
 }
 
+#if os(OSX)
 public prefix func %(rhs: Swift.Float80) -> Swift.Float80 -> Swift.Float80 {
 	return { lhs in lhs % rhs }
 }
 
 public postfix func %(lhs: Swift.Float80) -> Swift.Float80 -> Swift.Float80 {
 	return { rhs in lhs % rhs }
 }
+#endif
 
 public prefix func %(rhs: Double) -> Double -> Double {
 	return { lhs in lhs % rhs }
@@ -658,13 +660,15 @@ public postfix func * <T : _IntegerArithmeticType>(lhs: T) -> T -> T {
 	return { rhs in lhs * rhs }
 }
 
+#if os(OSX)
 public prefix func *(rhs: Swift.Float80) -> Swift.Float80 -> Swift.Float80 {
 	return { lhs in lhs * rhs }
 }
 
 public postfix func *(lhs: Swift.Float80) -> Swift.Float80 -> Swift.Float80 {
 	return { rhs in lhs * rhs }
 }
+#endif
 
 public prefix func *(rhs: Double) -> Double -> Double {
 	return { lhs in lhs * rhs }
@@ -773,13 +777,15 @@ public postfix func + <T : _IntegerArithmeticType>(lhs: T) -> T -> T {
 	return { rhs in lhs + rhs }
 }
 
+#if os(OSX)
 public prefix func +(rhs: Swift.Float80) -> Swift.Float80 -> Swift.Float80 {
 	return { lhs in lhs + rhs }
 }
 
 public postfix func +(lhs: Swift.Float80) -> Swift.Float80 -> Swift.Float80 {
 	return { rhs in lhs + rhs }
 }
+#endif
 
 public prefix func +(rhs: Double) -> Double -> Double {
 	return { lhs in lhs + rhs }
@@ -911,9 +917,11 @@ public postfix func - <T : _IntegerArithmeticType>(lhs: T) -> T -> T {
 	return { rhs in lhs - rhs }
 }
 
+#if os(OSX)
 public postfix func -(lhs: Swift.Float80) -> Swift.Float80 -> Swift.Float80 {
 	return { rhs in lhs - rhs }
 }
+#endif
 
 public postfix func -(lhs: Double) -> Double -> Double {
 	return { rhs in lhs - rhs }
@@ -1006,13 +1014,15 @@ public postfix func / <T : _IntegerArithmeticType>(lhs: T) -> T -> T {
 	return { rhs in lhs / rhs }
 }
 
+#if os(OSX)
 public prefix func /(rhs: Swift.Float80) -> Swift.Float80 -> Swift.Float80 {
 	return { lhs in lhs / rhs }
 }
 
 public postfix func /(lhs: Swift.Float80) -> Swift.Float80 -> Swift.Float80 {
 	return { rhs in lhs / rhs }
 }
+#endif
 
 public prefix func /(rhs: Double) -> Double -> Double {
 	return { lhs in lhs / rhs }
@@ -1190,13 +1200,15 @@ public prefix func ==(rhs: Character) -> Character -> Bool {
 	return { lhs in lhs == rhs }
 }
 
+#if os(OSX)
 public postfix func ==(lhs: Swift.Float80) -> Swift.Float80 -> Bool {
 	return { rhs in lhs == rhs }
 }
 
 public prefix func ==(rhs: Swift.Float80) -> Swift.Float80 -> Bool {
 	return { lhs in lhs == rhs }
 }
+#endif
 
 public postfix func ==(lhs: FloatingPointClassification) -> FloatingPointClassification -> Bool {
 	return { rhs in lhs == rhs }
@@ -1552,13 +1564,15 @@ public prefix func !=(rhs: Character) -> Character -> Bool {
 	return { lhs in lhs == rhs }
 }
 
+#if os(OSX)
 public postfix func !=(lhs: Swift.Float80) -> Swift.Float80 -> Bool {
 	return { rhs in lhs == rhs }
 }
 
 public prefix func !=(rhs: Swift.Float80) -> Swift.Float80 -> Bool {
 	return { lhs in lhs == rhs }
 }
+#endif
 
 public postfix func !=(lhs: FloatingPointClassification) -> FloatingPointClassification -> Bool {
 	return { rhs in lhs == rhs }
@@ -2085,9 +2099,11 @@ public prefix func > <T : _Comparable>(rhs: T?) -> T? -> Bool {
 	return { lhs in lhs > rhs }
 }
 
+#if os(OSX)
 public prefix func >(rhs: Swift.Float80) -> Swift.Float80 -> Bool {
 	return { lhs in lhs > rhs }
 }
+#endif
 
 public prefix func >(rhs: Double) -> Double -> Bool {
 	return { lhs in lhs > rhs }
@@ -2180,9 +2196,11 @@ public postfix func <<T : _Comparable>(lhs: T?) -> T? -> Bool {
 	return { rhs in lhs < rhs }
 }
 
+#if os(OSX)
 public postfix func <(lhs: Swift.Float80) -> Swift.Float80 -> Bool {
 	return { rhs in lhs < rhs }
 }
+#endif
 
 public postfix func <(lhs: Double) -> Double -> Bool {
 	return { rhs in lhs < rhs }

Original file line number	Diff line number	Diff line change
`@@ -674,13 +674,15 @@ public postfix func %<T : _IntegerArithmeticType>(lhs: T) -> T -> T {`
`674`	`674`	`return { rhs in lhs % rhs }`
`675`	`675`	`}`
`676`	`676`
	`677`	`+#if os(OSX)`
`677`	`678`	`public prefix func %(rhs: Swift.Float80) -> Swift.Float80 -> Swift.Float80 {`
`678`	`679`	`return { lhs in lhs % rhs }`
`679`	`680`	`}`
`680`	`681`
`681`	`682`	`public postfix func %(lhs: Swift.Float80) -> Swift.Float80 -> Swift.Float80 {`
`682`	`683`	`return { rhs in lhs % rhs }`
`683`	`684`	`}`
	`685`	`+#endif`
`684`	`686`
`685`	`687`	`public prefix func %(rhs: Double) -> Double -> Double {`
`686`	`688`	`return { lhs in lhs % rhs }`
`@@ -789,13 +791,15 @@ public postfix func *<T : _IntegerArithmeticType>(lhs: T) -> T -> T {`
`789`	`791`	`return { rhs in lhs * rhs }`
`790`	`792`	`}`
`791`	`793`
	`794`	`+#if os(OSX)`
`792`	`795`	`public prefix func *(rhs: Swift.Float80) -> Swift.Float80 -> Swift.Float80 {`
`793`	`796`	`return { lhs in lhs * rhs }`
`794`	`797`	`}`
`795`	`798`
`796`	`799`	`public postfix func *(lhs: Swift.Float80) -> Swift.Float80 -> Swift.Float80 {`
`797`	`800`	`return { rhs in lhs * rhs }`
`798`	`801`	`}`
	`802`	`+#endif`
`799`	`803`
`800`	`804`	`public prefix func *(rhs: Double) -> Double -> Double {`
`801`	`805`	`return { lhs in lhs * rhs }`
`@@ -904,13 +908,15 @@ public postfix func +<T : _IntegerArithmeticType>(lhs: T) -> T -> T {`
`904`	`908`	`return { rhs in lhs + rhs }`
`905`	`909`	`}`
`906`	`910`
	`911`	`+#if os(OSX)`
`907`	`912`	`public prefix func +(rhs: Swift.Float80) -> Swift.Float80 -> Swift.Float80 {`
`908`	`913`	`return { lhs in lhs + rhs }`
`909`	`914`	`}`
`910`	`915`
`911`	`916`	`public postfix func +(lhs: Swift.Float80) -> Swift.Float80 -> Swift.Float80 {`
`912`	`917`	`return { rhs in lhs + rhs }`
`913`	`918`	`}`
	`919`	`+#endif`
`914`	`920`
`915`	`921`	`public prefix func +(rhs: Double) -> Double -> Double {`
`916`	`922`	`return { lhs in lhs + rhs }`
`@@ -1034,9 +1040,11 @@ public postfix func -<T : _IntegerArithmeticType>(lhs: T) -> T -> T {`
`1034`	`1040`	`return { rhs in lhs - rhs }`
`1035`	`1041`	`}`
`1036`	`1042`
	`1043`	`+#if os(OSX)`
`1037`	`1044`	`public postfix func -(lhs: Swift.Float80) -> Swift.Float80 -> Swift.Float80 {`
`1038`	`1045`	`return { rhs in lhs - rhs }`
`1039`	`1046`	`}`
	`1047`	`+#endif`
`1040`	`1048`
`1041`	`1049`	`public postfix func -(lhs: Double) -> Double -> Double {`
`1042`	`1050`	`return { rhs in lhs - rhs }`
`@@ -1129,13 +1137,15 @@ public postfix func /<T : _IntegerArithmeticType>(lhs: T) -> T -> T {`
`1129`	`1137`	`return { rhs in lhs / rhs }`
`1130`	`1138`	`}`
`1131`	`1139`
	`1140`	`+#if os(OSX)`
`1132`	`1141`	`public prefix func /(rhs: Swift.Float80) -> Swift.Float80 -> Swift.Float80 {`
`1133`	`1142`	`return { lhs in lhs / rhs }`
`1134`	`1143`	`}`
`1135`	`1144`
`1136`	`1145`	`public postfix func /(lhs: Swift.Float80) -> Swift.Float80 -> Swift.Float80 {`
`1137`	`1146`	`return { rhs in lhs / rhs }`
`1138`	`1147`	`}`
	`1148`	`+#endif`
`1139`	`1149`
`1140`	`1150`	`public prefix func /(rhs: Double) -> Double -> Double {`
`1141`	`1151`	`return { lhs in lhs / rhs }`
`@@ -1313,13 +1323,15 @@ public prefix func ==(rhs: Character) -> Character -> Bool {`
`1313`	`1323`	`return { lhs in lhs == rhs }`
`1314`	`1324`	`}`
`1315`	`1325`
	`1326`	`+#if os(OSX)`
`1316`	`1327`	`public postfix func ==(lhs: Swift.Float80) -> Swift.Float80 -> Bool {`
`1317`	`1328`	`return { rhs in lhs == rhs }`
`1318`	`1329`	`}`
`1319`	`1330`
`1320`	`1331`	`public prefix func ==(rhs: Swift.Float80) -> Swift.Float80 -> Bool {`
`1321`	`1332`	`return { lhs in lhs == rhs }`
`1322`	`1333`	`}`
	`1334`	`+#endif`
`1323`	`1335`
`1324`	`1336`	`public postfix func ==(lhs: FloatingPointClassification) -> FloatingPointClassification -> Bool {`
`1325`	`1337`	`return { rhs in lhs == rhs }`
`@@ -1675,13 +1687,15 @@ public prefix func !=(rhs: Character) -> Character -> Bool {`
`1675`	`1687`	`return { lhs in lhs == rhs }`
`1676`	`1688`	`}`
`1677`	`1689`
	`1690`	`+#if os(OSX)`
`1678`	`1691`	`public postfix func !=(lhs: Swift.Float80) -> Swift.Float80 -> Bool {`
`1679`	`1692`	`return { rhs in lhs == rhs }`
`1680`	`1693`	`}`
`1681`	`1694`
`1682`	`1695`	`public prefix func !=(rhs: Swift.Float80) -> Swift.Float80 -> Bool {`
`1683`	`1696`	`return { lhs in lhs == rhs }`
`1684`	`1697`	`}`
	`1698`	`+#endif`
`1685`	`1699`
`1686`	`1700`	`public postfix func !=(lhs: FloatingPointClassification) -> FloatingPointClassification -> Bool {`
`1687`	`1701`	`return { rhs in lhs == rhs }`
`@@ -2208,9 +2222,11 @@ public prefix func ><T : _Comparable>(rhs: T?) -> T? -> Bool {`
`2208`	`2222`	`return { lhs in lhs > rhs }`
`2209`	`2223`	`}`
`2210`	`2224`
	`2225`	`+#if os(OSX)`
`2211`	`2226`	`public prefix func >(rhs: Swift.Float80) -> Swift.Float80 -> Bool {`
`2212`	`2227`	`return { lhs in lhs > rhs }`
`2213`	`2228`	`}`
	`2229`	`+#endif`
`2214`	`2230`
`2215`	`2231`	`public prefix func >(rhs: Double) -> Double -> Bool {`
`2216`	`2232`	`return { lhs in lhs > rhs }`
`@@ -2303,9 +2319,11 @@ public postfix func <<T : _Comparable>(lhs: T?) -> T? -> Bool {`
`2303`	`2319`	`return { rhs in lhs < rhs }`
`2304`	`2320`	`}`
`2305`	`2321`
	`2322`	`+#if os(OSX)`
`2306`	`2323`	`public postfix func <(lhs: Swift.Float80) -> Swift.Float80 -> Bool {`
`2307`	`2324`	`return { rhs in lhs < rhs }`
`2308`	`2325`	`}`
	`2326`	`+#endif`
`2309`	`2327`
`2310`	`2328`	`public postfix func <(lhs: Double) -> Double -> Bool {`
`2311`	`2329`	`return { rhs in lhs < rhs }`
Original file line number	Diff line number	Diff line change
`@@ -543,13 +543,15 @@ public postfix func % <T : _IntegerArithmeticType>(lhs: T) -> T -> T {`
`543`	`543`	`return { rhs in lhs % rhs }`
`544`	`544`	`}`
`545`	`545`
	`546`	`+#if os(OSX)`
`546`	`547`	`public prefix func %(rhs: Swift.Float80) -> Swift.Float80 -> Swift.Float80 {`
`547`	`548`	`return { lhs in lhs % rhs }`
`548`	`549`	`}`
`549`	`550`
`550`	`551`	`public postfix func %(lhs: Swift.Float80) -> Swift.Float80 -> Swift.Float80 {`
`551`	`552`	`return { rhs in lhs % rhs }`
`552`	`553`	`}`
	`554`	`+#endif`
`553`	`555`
`554`	`556`	`public prefix func %(rhs: Double) -> Double -> Double {`
`555`	`557`	`return { lhs in lhs % rhs }`
`@@ -658,13 +660,15 @@ public postfix func * <T : _IntegerArithmeticType>(lhs: T) -> T -> T {`
`658`	`660`	`return { rhs in lhs * rhs }`
`659`	`661`	`}`
`660`	`662`
	`663`	`+#if os(OSX)`
`661`	`664`	`public prefix func *(rhs: Swift.Float80) -> Swift.Float80 -> Swift.Float80 {`
`662`	`665`	`return { lhs in lhs * rhs }`
`663`	`666`	`}`
`664`	`667`
`665`	`668`	`public postfix func *(lhs: Swift.Float80) -> Swift.Float80 -> Swift.Float80 {`
`666`	`669`	`return { rhs in lhs * rhs }`
`667`	`670`	`}`
	`671`	`+#endif`
`668`	`672`
`669`	`673`	`public prefix func *(rhs: Double) -> Double -> Double {`
`670`	`674`	`return { lhs in lhs * rhs }`
`@@ -773,13 +777,15 @@ public postfix func + <T : _IntegerArithmeticType>(lhs: T) -> T -> T {`
`773`	`777`	`return { rhs in lhs + rhs }`
`774`	`778`	`}`
`775`	`779`
	`780`	`+#if os(OSX)`
`776`	`781`	`public prefix func +(rhs: Swift.Float80) -> Swift.Float80 -> Swift.Float80 {`
`777`	`782`	`return { lhs in lhs + rhs }`
`778`	`783`	`}`
`779`	`784`
`780`	`785`	`public postfix func +(lhs: Swift.Float80) -> Swift.Float80 -> Swift.Float80 {`
`781`	`786`	`return { rhs in lhs + rhs }`
`782`	`787`	`}`
	`788`	`+#endif`
`783`	`789`
`784`	`790`	`public prefix func +(rhs: Double) -> Double -> Double {`
`785`	`791`	`return { lhs in lhs + rhs }`
`@@ -911,9 +917,11 @@ public postfix func - <T : _IntegerArithmeticType>(lhs: T) -> T -> T {`
`911`	`917`	`return { rhs in lhs - rhs }`
`912`	`918`	`}`
`913`	`919`
	`920`	`+#if os(OSX)`
`914`	`921`	`public postfix func -(lhs: Swift.Float80) -> Swift.Float80 -> Swift.Float80 {`
`915`	`922`	`return { rhs in lhs - rhs }`
`916`	`923`	`}`
	`924`	`+#endif`
`917`	`925`
`918`	`926`	`public postfix func -(lhs: Double) -> Double -> Double {`
`919`	`927`	`return { rhs in lhs - rhs }`
`@@ -1006,13 +1014,15 @@ public postfix func / <T : _IntegerArithmeticType>(lhs: T) -> T -> T {`
`1006`	`1014`	`return { rhs in lhs / rhs }`
`1007`	`1015`	`}`
`1008`	`1016`
	`1017`	`+#if os(OSX)`
`1009`	`1018`	`public prefix func /(rhs: Swift.Float80) -> Swift.Float80 -> Swift.Float80 {`
`1010`	`1019`	`return { lhs in lhs / rhs }`
`1011`	`1020`	`}`
`1012`	`1021`
`1013`	`1022`	`public postfix func /(lhs: Swift.Float80) -> Swift.Float80 -> Swift.Float80 {`
`1014`	`1023`	`return { rhs in lhs / rhs }`
`1015`	`1024`	`}`
	`1025`	`+#endif`
`1016`	`1026`
`1017`	`1027`	`public prefix func /(rhs: Double) -> Double -> Double {`
`1018`	`1028`	`return { lhs in lhs / rhs }`
`@@ -1190,13 +1200,15 @@ public prefix func ==(rhs: Character) -> Character -> Bool {`
`1190`	`1200`	`return { lhs in lhs == rhs }`
`1191`	`1201`	`}`
`1192`	`1202`
	`1203`	`+#if os(OSX)`
`1193`	`1204`	`public postfix func ==(lhs: Swift.Float80) -> Swift.Float80 -> Bool {`
`1194`	`1205`	`return { rhs in lhs == rhs }`
`1195`	`1206`	`}`
`1196`	`1207`
`1197`	`1208`	`public prefix func ==(rhs: Swift.Float80) -> Swift.Float80 -> Bool {`
`1198`	`1209`	`return { lhs in lhs == rhs }`
`1199`	`1210`	`}`
	`1211`	`+#endif`
`1200`	`1212`
`1201`	`1213`	`public postfix func ==(lhs: FloatingPointClassification) -> FloatingPointClassification -> Bool {`
`1202`	`1214`	`return { rhs in lhs == rhs }`
`@@ -1552,13 +1564,15 @@ public prefix func !=(rhs: Character) -> Character -> Bool {`
`1552`	`1564`	`return { lhs in lhs == rhs }`
`1553`	`1565`	`}`
`1554`	`1566`
	`1567`	`+#if os(OSX)`
`1555`	`1568`	`public postfix func !=(lhs: Swift.Float80) -> Swift.Float80 -> Bool {`
`1556`	`1569`	`return { rhs in lhs == rhs }`
`1557`	`1570`	`}`
`1558`	`1571`
`1559`	`1572`	`public prefix func !=(rhs: Swift.Float80) -> Swift.Float80 -> Bool {`
`1560`	`1573`	`return { lhs in lhs == rhs }`
`1561`	`1574`	`}`
	`1575`	`+#endif`
`1562`	`1576`
`1563`	`1577`	`public postfix func !=(lhs: FloatingPointClassification) -> FloatingPointClassification -> Bool {`
`1564`	`1578`	`return { rhs in lhs == rhs }`
`@@ -2085,9 +2099,11 @@ public prefix func > <T : _Comparable>(rhs: T?) -> T? -> Bool {`
`2085`	`2099`	`return { lhs in lhs > rhs }`
`2086`	`2100`	`}`
`2087`	`2101`
	`2102`	`+#if os(OSX)`
`2088`	`2103`	`public prefix func >(rhs: Swift.Float80) -> Swift.Float80 -> Bool {`
`2089`	`2104`	`return { lhs in lhs > rhs }`
`2090`	`2105`	`}`
	`2106`	`+#endif`
`2091`	`2107`
`2092`	`2108`	`public prefix func >(rhs: Double) -> Double -> Bool {`
`2093`	`2109`	`return { lhs in lhs > rhs }`
`@@ -2180,9 +2196,11 @@ public postfix func <<T : _Comparable>(lhs: T?) -> T? -> Bool {`
`2180`	`2196`	`return { rhs in lhs < rhs }`
`2181`	`2197`	`}`
`2182`	`2198`
	`2199`	`+#if os(OSX)`
`2183`	`2200`	`public postfix func <(lhs: Swift.Float80) -> Swift.Float80 -> Bool {`
`2184`	`2201`	`return { rhs in lhs < rhs }`
`2185`	`2202`	`}`
	`2203`	`+#endif`
`2186`	`2204`
`2187`	`2205`	`public postfix func <(lhs: Double) -> Double -> Bool {`
`2188`	`2206`	`return { rhs in lhs < rhs }`