Reduce risk of conflict for precedence groups

Turns out these need to be unique! Fun stuff. To reduce the risk of conflict
here lets go ahead and prefix our precedence group names with our package
name.

This sucks.

Sources/Runes.swift

@@ -1,30 +1,30 @@
-precedencegroup MonadicPrecedenceRight {
+precedencegroup RunesMonadicPrecedenceRight {
     associativity: right
     lowerThan: LogicalDisjunctionPrecedence
     higherThan: AssignmentPrecedence
 }
 
-precedencegroup MonadicPrecedenceLeft {
+precedencegroup RunesMonadicPrecedenceLeft {
     associativity: left
     lowerThan: LogicalDisjunctionPrecedence
     higherThan: AssignmentPrecedence
 }
 
-precedencegroup AlternativePrecedence {
+precedencegroup RunesAlternativePrecedence {
     associativity: left
     higherThan: LogicalConjunctionPrecedence
     lowerThan: ComparisonPrecedence
 }
 
-precedencegroup ApplicativePrecedence {
+precedencegroup RunesApplicativePrecedence {
     associativity: left
-    higherThan: AlternativePrecedence
+    higherThan: RunesAlternativePrecedence
     lowerThan: NilCoalescingPrecedence
 }
 
-precedencegroup ApplicativeSequencePrecedence {
+precedencegroup RunesApplicativeSequencePrecedence {
     associativity: left
-    higherThan: ApplicativePrecedence
+    higherThan: RunesApplicativePrecedence
     lowerThan: NilCoalescingPrecedence
 }
 
@@ -34,55 +34,55 @@ map a function over a value with context
 Expected function type: `(a -> b) -> f a -> f b`
 Haskell `infixl 4`
 */
-infix operator <^> : ApplicativePrecedence
+infix operator <^> : RunesApplicativePrecedence
 
 /**
 apply a function with context to a value with context
 
 Expected function type: `f (a -> b) -> f a -> f b`
 Haskell `infixl 4`
 */
-infix operator <*> : ApplicativePrecedence
+infix operator <*> : RunesApplicativePrecedence
 
 /**
 sequence actions, discarding right (value of the second argument)
 
 Expected function type: `f a -> f b -> f a`
 Haskell `infixl 4`
 */
-infix operator <* : ApplicativeSequencePrecedence
+infix operator <* : RunesApplicativeSequencePrecedence
 
 /**
 sequence actions, discarding left (value of the first argument)
 
 Expected function type: `f a -> f b -> f b`
 Haskell `infixl 4`
 */
-infix operator *> : ApplicativeSequencePrecedence
+infix operator *> : RunesApplicativeSequencePrecedence
 
 /**
 an associative binary operation
 
 Expected function type: `f a -> f a -> f a`
 Haskell `infixl 3`
 */
-infix operator <|> : AlternativePrecedence
+infix operator <|> : RunesAlternativePrecedence
 
 /**
 map a function over a value with context and flatten the result
 
 Expected function type: `m a -> (a -> m b) -> m b`
 Haskell `infixl 1`
 */
-infix operator >>- : MonadicPrecedenceLeft
+infix operator >>- : RunesMonadicPrecedenceLeft
 
 /**
 map a function over a value with context and flatten the result
 
 Expected function type: `(a -> m b) -> m a -> m b`
 Haskell `infixr 1`
 */
-infix operator -<< : MonadicPrecedenceRight
+infix operator -<< : RunesMonadicPrecedenceRight
 
 /**
 compose two functions that produce results in a context,
@@ -91,7 +91,7 @@ from left to right, returning a result in that context
 Expected function type: `(a -> m b) -> (b -> m c) -> a -> m c`
 Haskell `infixr 1`
 */
-infix operator >-> : MonadicPrecedenceRight
+infix operator >-> : RunesMonadicPrecedenceRight
 
 /**
 compose two functions that produce results in a context,
@@ -102,4 +102,4 @@ like `>->`, but with the arguments flipped
 Expected function type: `(b -> m c) -> (a -> m b) -> a -> m c`
 Haskell `infixr 1`
 */
-infix operator <-< : MonadicPrecedenceRight
+infix operator <-< : RunesMonadicPrecedenceRight

Tests/Runes/Operators.swift

@@ -2,7 +2,7 @@ import Runes
 
 precedencegroup CompositionPrecedence {
     associativity: right
-    higherThan: ApplicativeSequencePrecedence
+    higherThan: RunesApplicativeSequencePrecedence
 }
 
 infix operator •: CompositionPrecedence