From 11056703e53685b527c07bda007524542153b1ff Mon Sep 17 00:00:00 2001
From: Justin Ackermann <justinackermann@yahoo.com>
Date: Wed, 14 Dec 2022 15:57:31 -0500
Subject: [PATCH] convert to custom operator ~==

---
 Cartography/Compound.swift |  25 +++++++++
 Cartography/Priority.swift |   8 +++
 Cartography/Property.swift | 105 +++++++++++++++++++++++++++++++++++++
 3 files changed, 138 insertions(+)

diff --git a/Cartography/Compound.swift b/Cartography/Compound.swift
index 22522e1b..038875c2 100644
--- a/Cartography/Compound.swift
+++ b/Cartography/Compound.swift
@@ -94,3 +94,28 @@ 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)
+}
+
+@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 b5462ff0..d2484efe 100644
--- a/Cartography/Priority.swift
+++ b/Cartography/Priority.swift
@@ -23,6 +23,14 @@ precedencegroup CarthographyPriorityPrecedence {
 
 infix operator  ~: CarthographyPriorityPrecedence
 
+infix operator ~==: AssignmentPrecedence
+infix operator ~<=: AssignmentPrecedence
+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 21371903..7e615a1f 100644
--- a/Cartography/Property.swift
+++ b/Cartography/Property.swift
@@ -222,3 +222,108 @@ 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)
+}
+
+@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)
+}