Fix other <|> breakage

.github/workflows/ci.yml

@@ -22,7 +22,7 @@ jobs:
       - name: Cache PureScript dependencies
         uses: actions/cache@v2
         with:
-          key: ${{ runner.os }}-spago-${{ hashFiles('**/*.dhall') }}
+          key: ${{ runner.os }}-spago-${{ hashFiles('**/*.dhall') }}-2
           path: |
             .spago
             output

.gitignore

@@ -3,6 +3,7 @@
 !.github
 !.editorconfig
 !.tidyrc.json
+!.tidyoperators
 
 output
 generated-docs

.tidyoperators

@@ -0,0 +1,231 @@
+Control.Alt.($>) 4
+Control.Alt.(<#>) 1
+Control.Alt.(<$) 4
+Control.Alt.(<$>) 4
+Control.Alt.(<@>) 4
+Control.Alt.(<|>) 3
+Control.Alternative.($>) 4
+Control.Alternative.(*>) 4
+Control.Alternative.(<#>) 1
+Control.Alternative.(<$) 4
+Control.Alternative.(<$>) 4
+Control.Alternative.(<*) 4
+Control.Alternative.(<*>) 4
+Control.Alternative.(<@>) 4
+Control.Alternative.(<|>) 3
+Control.Applicative.($>) 4
+Control.Applicative.(*>) 4
+Control.Applicative.(<#>) 1
+Control.Applicative.(<$) 4
+Control.Applicative.(<$>) 4
+Control.Applicative.(<*) 4
+Control.Applicative.(<*>) 4
+Control.Applicative.(<@>) 4
+Control.Apply.($>) 4
+Control.Apply.(*>) 4
+Control.Apply.(<#>) 1
+Control.Apply.(<$) 4
+Control.Apply.(<$>) 4
+Control.Apply.(<*) 4
+Control.Apply.(<*>) 4
+Control.Apply.(<@>) 4
+Control.Biapply.(*>>) 4
+Control.Biapply.(<<$>>) 4
+Control.Biapply.(<<*) 4
+Control.Biapply.(<<*>>) 4
+Control.Bind.($>) 4
+Control.Bind.(*>) 4
+Control.Bind.(<#>) 1
+Control.Bind.(<$) 4
+Control.Bind.(<$>) 4
+Control.Bind.(<*) 4
+Control.Bind.(<*>) 4
+Control.Bind.(<=<) 1
+Control.Bind.(<@>) 4
+Control.Bind.(=<<) 1
+Control.Bind.(>=>) 1
+Control.Bind.(>>=) 1
+Control.Category.(<<<) 9
+Control.Category.(>>>) 9
+Control.Comonad.($>) 4
+Control.Comonad.(<#>) 1
+Control.Comonad.(<$) 4
+Control.Comonad.(<$>) 4
+Control.Comonad.(<<=) 1
+Control.Comonad.(<@>) 4
+Control.Comonad.(=<=) 1
+Control.Comonad.(=>=) 1
+Control.Comonad.(=>>) 1
+Control.Extend.($>) 4
+Control.Extend.(<#>) 1
+Control.Extend.(<$) 4
+Control.Extend.(<$>) 4
+Control.Extend.(<<=) 1
+Control.Extend.(<@>) 4
+Control.Extend.(=<=) 1
+Control.Extend.(=>=) 1
+Control.Extend.(=>>) 1
+Control.Monad.($>) 4
+Control.Monad.(*>) 4
+Control.Monad.(<#>) 1
+Control.Monad.(<$) 4
+Control.Monad.(<$>) 4
+Control.Monad.(<*) 4
+Control.Monad.(<*>) 4
+Control.Monad.(<=<) 1
+Control.Monad.(<@>) 4
+Control.Monad.(=<<) 1
+Control.Monad.(>=>) 1
+Control.Monad.(>>=) 1
+Control.MonadPlus.($>) 4
+Control.MonadPlus.(*>) 4
+Control.MonadPlus.(<#>) 1
+Control.MonadPlus.(<$) 4
+Control.MonadPlus.(<$>) 4
+Control.MonadPlus.(<*) 4
+Control.MonadPlus.(<*>) 4
+Control.MonadPlus.(<=<) 1
+Control.MonadPlus.(<@>) 4
+Control.MonadPlus.(<|>) 3
+Control.MonadPlus.(=<<) 1
+Control.MonadPlus.(>=>) 1
+Control.MonadPlus.(>>=) 1
+Control.Plus.($>) 4
+Control.Plus.(<#>) 1
+Control.Plus.(<$) 4
+Control.Plus.(<$>) 4
+Control.Plus.(<@>) 4
+Control.Plus.(<|>) 3
+Control.Semigroupoid.(<<<) 9
+Control.Semigroupoid.(>>>) 9
+Data.Array.(!!) 8
+Data.Array.(..) 8
+Data.Array.(:) 6
+Data.Array.(\\) 5
+Data.Array.NonEmpty.(!!) 8
+Data.Array.NonEmpty.(..) 8
+Data.Array.NonEmpty.(:) 6
+Data.Array.NonEmpty.(\\) 5
+Data.BooleanAlgebra.(&&) 3
+Data.BooleanAlgebra.(||) 2
+Data.Bounded.(<) 4
+Data.Bounded.(<=) 4
+Data.Bounded.(>) 4
+Data.Bounded.(>=) 4
+Data.CommutativeRing.(*) 7
+Data.CommutativeRing.(+) 6
+Data.CommutativeRing.(-) 6
+Data.DivisionRing.(*) 7
+Data.DivisionRing.(+) 6
+Data.DivisionRing.(-) 6
+Data.Either.Nested.(\/) type 6
+Data.Either.Nested.(\/) 6
+Data.Eq.(/=) 4
+Data.Eq.(==) 4
+Data.EuclideanRing.(*) 7
+Data.EuclideanRing.(+) 6
+Data.EuclideanRing.(-) 6
+Data.EuclideanRing.(/) 7
+Data.Field.(*) 7
+Data.Field.(+) 6
+Data.Field.(-) 6
+Data.Field.(/) 7
+Data.Function.(#) 1
+Data.Function.($) 0
+Data.Function.(<<<) 9
+Data.Function.(>>>) 9
+Data.Functor.($>) 4
+Data.Functor.(<#>) 1
+Data.Functor.(<$) 4
+Data.Functor.(<$>) 4
+Data.Functor.(<@>) 4
+Data.Functor.Contravariant.(>#<) 4
+Data.Functor.Contravariant.(>$<) 4
+Data.Functor.Coproduct.Nested.(<\/>) type 6
+Data.Functor.Coproduct.Nested.(<\/>) 6
+Data.Functor.Product.Nested.(</\>) type 6
+Data.Functor.Product.Nested.(</\>) 6
+Data.HeytingAlgebra.(&&) 3
+Data.HeytingAlgebra.(||) 2
+Data.Int.Bits.(.&.) 10
+Data.Int.Bits.(.^.) 10
+Data.Int.Bits.(.|.) 10
+Data.List.(!!) 8
+Data.List.(..) 8
+Data.List.(:) 6
+Data.List.(\\) 5
+Data.List.Lazy.(!!) 8
+Data.List.Lazy.(..) 8
+Data.List.Lazy.(:) 6
+Data.List.Lazy.(\\) 5
+Data.List.Lazy.NonEmpty.(:) 6
+Data.List.Lazy.Types.(:) 6
+Data.List.NonEmpty.(!!) 8
+Data.List.NonEmpty.(:) 6
+Data.List.Types.(:) 6
+Data.Monoid.(<>) 5
+Data.NaturalTransformation.(~>) type 4
+Data.NonEmpty.(:|) 5
+Data.Number.Approximate.(~=) 4
+Data.Number.Approximate.(≅) 4
+Data.Number.Approximate.(≇) 4
+Data.Ord.(<) 4
+Data.Ord.(<=) 4
+Data.Ord.(>) 4
+Data.Ord.(>=) 4
+Data.Profunctor.Choice.(+++) 2
+Data.Profunctor.Choice.(|||) 2
+Data.Profunctor.Strong.(&&&) 3
+Data.Profunctor.Strong.(***) 3
+Data.Ring.(*) 7
+Data.Ring.(+) 6
+Data.Ring.(-) 6
+Data.Semigroup.(<>) 5
+Data.Semiring.(*) 7
+Data.Semiring.(+) 6
+Data.Tuple.Nested.(/\) type 6
+Data.Tuple.Nested.(/\) 6
+Math.(%) 7
+Prelude.(~>) type 4
+Prelude.(#) 1
+Prelude.($) 0
+Prelude.($>) 4
+Prelude.(&&) 3
+Prelude.(*) 7
+Prelude.(*>) 4
+Prelude.(+) 6
+Prelude.(-) 6
+Prelude.(/) 7
+Prelude.(/=) 4
+Prelude.(<) 4
+Prelude.(<#>) 1
+Prelude.(<$) 4
+Prelude.(<$>) 4
+Prelude.(<*) 4
+Prelude.(<*>) 4
+Prelude.(<<<) 9
+Prelude.(<=) 4
+Prelude.(<=<) 1
+Prelude.(<>) 5
+Prelude.(<@>) 4
+Prelude.(=<<) 1
+Prelude.(==) 4
+Prelude.(>) 4
+Prelude.(>=) 4
+Prelude.(>=>) 1
+Prelude.(>>=) 1
+Prelude.(>>>) 9
+Prelude.(||) 2
+Text.Parsing.Indent.(<*/>) 11
+Text.Parsing.Indent.(<+/>) 9
+Text.Parsing.Indent.(<-/>) 10
+Text.Parsing.Indent.(<?/>) 12
+Text.Parsing.Parser.Combinators.($>) 4
+Text.Parsing.Parser.Combinators.(<#>) 1
+Text.Parsing.Parser.Combinators.(<$) 4
+Text.Parsing.Parser.Combinators.(<$>) 4
+Text.Parsing.Parser.Combinators.(<?>) 4
+Text.Parsing.Parser.Combinators.(<??>) 3
+Text.Parsing.Parser.Combinators.(<@>) 4
+Text.Parsing.Parser.Combinators.(<|>) 3
+Text.Parsing.Parser.Combinators.(<~?>) 4

.tidyrc.json

@@ -2,7 +2,7 @@
   "importSort": "source",
   "importWrap": "source",
   "indent": 2,
-  "operatorsFile": null,
+  "operatorsFile": ".tidyoperators",
   "ribbon": 1,
   "typeArrowPlacement": "first",
   "unicode": "never",

CHANGELOG.md

@@ -7,11 +7,12 @@ Notable changes to this project are documented in this file. The format is based
 Breaking changes:
 - Update project and deps to PureScript v0.15.0 (#160 by @JordanMartinez)
 - Drop deprecated `MonadZero` instance (#160 by @JordanMartinez)
-- Make `<?>` right-associative and increase prec from 3 to 2 (#163 by @JordanMartinez)
+- Make `<??>` right-associative (#164 by @JordanMartinez)
+- Drop `<?>` and `<~?>` prec from 3 to 4 (#163, #164 by @JordanMartinez)
 
-  `<|>` was made right associative. `<?>` was likewise changed to prevent a 
-  possible error and its precedence was increased so that `foo <|> bar <?> "err msg"`
-  works without parenthesis around `"err msg"` part.
+  `<|>` was made right associative. Decreasing these two operators
+  prevents a compiler error (i.e. `MixedAssociativityError`)
+  without causing issues with `<$>`.
 
 New features:
 

src/Text/Parsing/Parser/Combinators.purs

@@ -119,7 +119,7 @@ import Text.Parsing.Parser (ParseError(..), ParseState(..), ParserT(..), fail)
 withErrorMessage :: forall m s a. Monad m => ParserT s m a -> String -> ParserT s m a
 withErrorMessage p msg = p <|> fail ("Expected " <> msg)
 
-infixr 2 withErrorMessage as <?>
+infixl 4 withErrorMessage as <?>
 
 -- | Provide an error message in the case of failure, but lazily. This is handy
 -- | in cases where constructing the error message is expensive, so it's
@@ -132,13 +132,13 @@ infixr 2 withErrorMessage as <?>
 withLazyErrorMessage :: forall m s a. Monad m => ParserT s m a -> (Unit -> String) -> ParserT s m a
 withLazyErrorMessage p msg = p <|> defer \_ -> fail ("Expected " <> msg unit)
 
-infixl 3 withLazyErrorMessage as <~?>
+infixl 4 withLazyErrorMessage as <~?>
 
 -- | Flipped `(<?>)`.
 asErrorMessage :: forall m s a. Monad m => String -> ParserT s m a -> ParserT s m a
 asErrorMessage = flip (<?>)
 
-infixl 3 asErrorMessage as <??>
+infixr 3 asErrorMessage as <??>
 
 -- | Wrap a parser with opening and closing markers.
 -- |

src/Text/Parsing/Parser/Expr.purs

@@ -55,7 +55,7 @@ makeParser term ops = do
     <|> lassocP x lassocOp prefixP term postfixP
     <|> nassocP x nassocOp prefixP term postfixP
     <|> pure x
-    <?> "operator"
+      <?> "operator"
   where
   accum = foldr splitOp
     { rassoc: Nil

src/Text/Parsing/Parser/Token.purs

@@ -460,9 +460,10 @@ makeTokenParser (LanguageDef languageDef) =
     folder (Just c) chars = Cons c chars
 
   stringChar :: ParserT String m (Maybe Char)
-  stringChar = (Just <$> stringLetter)
-    <|> stringEscape
-    <?> "string character"
+  stringChar =
+    (Just <$> stringLetter)
+      <|> stringEscape
+        <?> "string character"
 
   stringLetter :: ParserT String m Char
   stringLetter = satisfy (\c -> (c /= '"') && (c /= '\\') && (c > '\x1A'))
@@ -685,8 +686,9 @@ makeTokenParser (LanguageDef languageDef) =
 
   zeroNumber :: ParserT String m Int
   zeroNumber =
-    char '0' *>
-      (hexadecimal <|> octal <|> decimal <|> pure 0) <?> ""
+    char '0'
+      *> (hexadecimal <|> octal <|> decimal <|> pure 0)
+      <?> ""
 
   decimal :: ParserT String m Int
   decimal = number 10 Basic.digit
@@ -860,21 +862,23 @@ inComment langDef@(LanguageDef languageDef) =
 
 inCommentMulti :: forall m. Monad m => GenLanguageDef String m -> ParserT String m Unit
 inCommentMulti langDef@(LanguageDef languageDef) =
-  fix \p -> (void $ try (string languageDef.commentEnd))
-    <|> (multiLineComment langDef *> p)
-    <|> (skipMany1 (noneOf startEnd) *> p)
-    <|> (oneOf startEnd *> p)
-    <?> "end of comment"
+  fix \p ->
+    (void $ try (string languageDef.commentEnd))
+      <|> (multiLineComment langDef *> p)
+      <|> (skipMany1 (noneOf startEnd) *> p)
+      <|> (oneOf startEnd *> p)
+        <?> "end of comment"
   where
   startEnd :: Array Char
   startEnd = SCU.toCharArray languageDef.commentEnd <> SCU.toCharArray languageDef.commentStart
 
 inCommentSingle :: forall m. Monad m => GenLanguageDef String m -> ParserT String m Unit
 inCommentSingle (LanguageDef languageDef) =
-  fix \p -> (void $ try (string languageDef.commentEnd))
-    <|> (skipMany1 (noneOf startEnd) *> p)
-    <|> (oneOf startEnd *> p)
-    <?> "end of comment"
+  fix \p ->
+    (void $ try (string languageDef.commentEnd))
+      <|> (skipMany1 (noneOf startEnd) *> p)
+      <|> (oneOf startEnd *> p)
+        <?> "end of comment"
   where
   startEnd :: Array Char
   startEnd = SCU.toCharArray languageDef.commentEnd <> SCU.toCharArray languageDef.commentStart