From 2b6b750fd8b1de53e43f6fcc4c89765d8948f24b Mon Sep 17 00:00:00 2001
From: Andrew Crookston <andrew.crookston@instacart.com>
Date: Tue, 12 Jun 2018 17:53:29 -0700
Subject: [PATCH 1/2] Adds custom operators for speed

---
 Cartography/Compound.swift | 10 +++++
 Cartography/Priority.swift |  6 +++
 Cartography/Property.swift | 82 ++++++++++++++++++++++++++++++++++++++
 3 files changed, 98 insertions(+)

diff --git a/Cartography/Compound.swift b/Cartography/Compound.swift
index 22522e1..e6f4d3d 100644
--- a/Cartography/Compound.swift
+++ b/Cartography/Compound.swift
@@ -94,3 +94,13 @@ public protocol RelativeCompoundInequality : Compound { }
 @discardableResult public func >= <P: RelativeCompoundInequality>(lhs: P, rhs: Expression<P>) -> [NSLayoutConstraint] {
     return lhs.context.addConstraint(lhs, coefficients: rhs.coefficients, to: rhs.value, relation: .greaterThanOrEqual)
 }
+
+// MARK: - Aliases
+
+@discardableResult public func ~== <P: RelativeCompoundEquality>(lhs: P, rhs: Expression<P>) -> [NSLayoutConstraint] {
+    return lhs.context.addConstraint(lhs, coefficients: rhs.coefficients, to: rhs.value)
+}
+
+@discardableResult public func ~== <P: RelativeCompoundEquality>(lhs: P, rhs: P) -> [NSLayoutConstraint] {
+    return lhs.context.addConstraint(lhs, to: rhs)
+}
diff --git a/Cartography/Priority.swift b/Cartography/Priority.swift
index b5462ff..5c5a97a 100644
--- a/Cartography/Priority.swift
+++ b/Cartography/Priority.swift
@@ -23,6 +23,12 @@ precedencegroup CarthographyPriorityPrecedence {
 
 infix operator  ~: CarthographyPriorityPrecedence
 
+infix operator ~==: AssignmentPrecedence
+infix operator ~+: AdditionPrecedence
+infix operator ~-: AdditionPrecedence
+infix operator ~*: MultiplicationPrecedence
+infix operator ~/: MultiplicationPrecedence
+
 /// Sets the priority for a constraint.
 ///
 /// - parameter lhs: The constraint to update.
diff --git a/Cartography/Property.swift b/Cartography/Property.swift
index b3312f5..182dcdb 100644
--- a/Cartography/Property.swift
+++ b/Cartography/Property.swift
@@ -222,3 +222,85 @@ public func / <P: Multiplication>(lhs: Expression<P>, rhs: CGFloat) -> Expressio
 public func / <P: Multiplication>(lhs: P, rhs: CGFloat) -> Expression<P> {
     return lhs * (1 / rhs)
 }
+
+// MARK: - Aliases
+
+@discardableResult public func ~== (lhs: NumericalEquality, rhs: CGFloat) -> NSLayoutConstraint {
+    return lhs.context.addConstraint(lhs, coefficients: Coefficients(1, rhs))
+}
+
+@discardableResult public func ~== <P: RelativeEquality>(lhs: P, rhs: Expression<P>) -> NSLayoutConstraint {
+    return lhs.context.addConstraint(lhs, to: rhs.value, coefficients: rhs.coefficients[0])
+}
+
+@discardableResult public func ~== <P: RelativeEquality>(lhs: P, rhs: P) -> NSLayoutConstraint {
+    return lhs.context.addConstraint(lhs, to: rhs)
+}
+
+public func ~+ <P: Addition>(c: CGFloat, rhs: P) -> Expression<P> {
+    return Expression(rhs, [ Coefficients(1, c) ])
+}
+
+public func ~+ <P: Addition>(lhs: P, rhs: CGFloat) -> Expression<P> {
+    return rhs + lhs
+}
+
+public func ~+ <P: Addition>(c: CGFloat, rhs: Expression<P>) -> Expression<P> {
+    return Expression(rhs.value, rhs.coefficients.map { $0 + c })
+}
+
+public func ~+ <P: Addition>(lhs: Expression<P>, rhs: CGFloat) -> Expression<P> {
+    return rhs + lhs
+}
+
+public func ~- <P: Addition>(c: CGFloat, rhs: P) -> Expression<P> {
+    return Expression(rhs, [ Coefficients(1, -c) ])
+}
+
+public func ~- <P: Addition>(lhs: P, rhs: CGFloat) -> Expression<P> {
+    return rhs - lhs
+}
+
+public func ~- <P: Addition>(c: CGFloat, rhs: Expression<P>) -> Expression<P> {
+    return Expression(rhs.value, rhs.coefficients.map { $0 - c})
+}
+
+public func ~- <P: Addition>(lhs: Expression<P>, rhs: CGFloat) -> Expression<P> {
+    return rhs - lhs
+}
+
+#if os(iOS) || os(tvOS)
+
+public func ~+ (lhs: LayoutSupport, c : CGFloat) -> Expression<LayoutSupport> {
+    return Expression<LayoutSupport>(lhs, [Coefficients(1, c)])
+}
+
+public func ~- (lhs: LayoutSupport, c : CGFloat) -> Expression<LayoutSupport> {
+    return lhs + (-c)
+}
+
+#endif
+
+public func ~* <P: Multiplication>(m: CGFloat, rhs: Expression<P>) -> Expression<P> {
+    return Expression(rhs.value, rhs.coefficients.map { $0 * m })
+}
+
+public func ~* <P: Multiplication>(lhs: Expression<P>, rhs: CGFloat) -> Expression<P> {
+    return rhs * lhs
+}
+
+public func ~* <P: Multiplication>(m: CGFloat, rhs: P) -> Expression<P> {
+    return Expression(rhs, [ Coefficients(m, 0) ])
+}
+
+public func ~* <P: Multiplication>(lhs: P, rhs: CGFloat) -> Expression<P> {
+    return rhs * lhs
+}
+
+public func ~/ <P: Multiplication>(lhs: Expression<P>, rhs: CGFloat) -> Expression<P> {
+    return lhs * (1 / rhs)
+}
+
+public func ~/ <P: Multiplication>(lhs: P, rhs: CGFloat) -> Expression<P> {
+    return lhs * (1 / rhs)
+}

From 2e5e2aec5b3375f0c31b02b341254f433f0abb6e Mon Sep 17 00:00:00 2001
From: Andrew Crookston <andrew.crookston@instacart.com>
Date: Fri, 15 Jun 2018 14:12:01 -0700
Subject: [PATCH 2/2] Add aliases for <= and >=

---
 Cartography/Compound.swift | 16 ++++++++++++++++
 Cartography/Priority.swift |  2 ++
 Cartography/Property.swift | 24 ++++++++++++++++++++++++
 3 files changed, 42 insertions(+)

diff --git a/Cartography/Compound.swift b/Cartography/Compound.swift
index e6f4d3d..a7b2a19 100644
--- a/Cartography/Compound.swift
+++ b/Cartography/Compound.swift
@@ -104,3 +104,19 @@ public protocol RelativeCompoundInequality : Compound { }
 @discardableResult public func ~== <P: RelativeCompoundEquality>(lhs: P, rhs: P) -> [NSLayoutConstraint] {
     return lhs.context.addConstraint(lhs, to: rhs)
 }
+
+@discardableResult public func ~<= <P: RelativeCompoundInequality>(lhs: P, rhs: P) -> [NSLayoutConstraint] {
+    return lhs.context.addConstraint(lhs, to: rhs, relation: .lessThanOrEqual)
+}
+
+@discardableResult public func ~>= <P: RelativeCompoundInequality>(lhs: P, rhs: P) -> [NSLayoutConstraint] {
+    return lhs.context.addConstraint(lhs, to: rhs, relation: .greaterThanOrEqual)
+}
+
+@discardableResult public func ~<= <P: RelativeCompoundInequality>(lhs: P, rhs: Expression<P>) -> [NSLayoutConstraint] {
+    return lhs.context.addConstraint(lhs, coefficients: rhs.coefficients, to: rhs.value, relation: .lessThanOrEqual)
+}
+
+@discardableResult public func ~>= <P: RelativeCompoundInequality>(lhs: P, rhs: Expression<P>) -> [NSLayoutConstraint] {
+    return lhs.context.addConstraint(lhs, coefficients: rhs.coefficients, to: rhs.value, relation: .greaterThanOrEqual)
+}
diff --git a/Cartography/Priority.swift b/Cartography/Priority.swift
index 5c5a97a..d2484ef 100644
--- a/Cartography/Priority.swift
+++ b/Cartography/Priority.swift
@@ -24,6 +24,8 @@ precedencegroup CarthographyPriorityPrecedence {
 infix operator  ~: CarthographyPriorityPrecedence
 
 infix operator ~==: AssignmentPrecedence
+infix operator ~<=: AssignmentPrecedence
+infix operator ~>=: AssignmentPrecedence
 infix operator ~+: AdditionPrecedence
 infix operator ~-: AdditionPrecedence
 infix operator ~*: MultiplicationPrecedence
diff --git a/Cartography/Property.swift b/Cartography/Property.swift
index 182dcdb..d224ebd 100644
--- a/Cartography/Property.swift
+++ b/Cartography/Property.swift
@@ -304,3 +304,27 @@ public func ~/ <P: Multiplication>(lhs: Expression<P>, rhs: CGFloat) -> Expressi
 public func ~/ <P: Multiplication>(lhs: P, rhs: CGFloat) -> Expression<P> {
     return lhs * (1 / rhs)
 }
+
+@discardableResult public func ~<= (lhs: NumericalInequality, rhs: CGFloat) -> NSLayoutConstraint {
+    return lhs.context.addConstraint(lhs, coefficients: Coefficients(1, rhs), relation: .lessThanOrEqual)
+}
+
+@discardableResult public func ~>= (lhs: NumericalInequality, rhs: CGFloat) -> NSLayoutConstraint {
+    return lhs.context.addConstraint(lhs, coefficients: Coefficients(1, rhs), relation: .greaterThanOrEqual)
+}
+
+@discardableResult public func ~<= <P: RelativeInequality>(lhs: P, rhs: P) -> NSLayoutConstraint {
+    return lhs.context.addConstraint(lhs, to: rhs, relation: .lessThanOrEqual)
+}
+
+@discardableResult public func ~>= <P: RelativeInequality>(lhs: P, rhs: P) -> NSLayoutConstraint {
+    return lhs.context.addConstraint(lhs, to: rhs, relation: .greaterThanOrEqual)
+}
+
+@discardableResult public func ~<= <P: RelativeInequality>(lhs: P, rhs: Expression<P>) -> NSLayoutConstraint {
+    return lhs.context.addConstraint(lhs, to: rhs.value, coefficients: rhs.coefficients[0], relation: .lessThanOrEqual)
+}
+
+@discardableResult public func ~>= <P: RelativeInequality>(lhs: P, rhs: Expression<P>) -> NSLayoutConstraint {
+    return lhs.context.addConstraint(lhs, to: rhs.value, coefficients: rhs.coefficients[0], relation: .greaterThanOrEqual)
+}