Use unit rather than {}.

Author: joneshf

src/Text/Parsing/Parser/Combinators.purs

@@ -29,9 +29,9 @@ between open close p = do
 option :: forall m s a. (Monad m) => a -> ParserT s m a -> ParserT s m a
 option a p = p <|> return a
 
-optional :: forall m s a. (Monad m) => ParserT s m a -> ParserT s m {}
+optional :: forall m s a. (Monad m) => ParserT s m a -> ParserT s m Unit
 optional p = (do p
-                 return {}) <|> return {}
+                 return unit) <|> return unit
 
 optionMaybe :: forall m s a. (Functor m, Monad m) => ParserT s m a -> ParserT s m (Maybe a)
 optionMaybe p = option Nothing (Just <$> p)
@@ -106,14 +106,14 @@ choice []   = fail "Nothing to parse"
 choice [x]  = x
 choice (x:xs) = x <|> choice xs
 
-skipMany :: forall s a m. (Monad m) => ParserT s m a -> ParserT s m {}
-skipMany p = skipMany1 p <|> return {}
+skipMany :: forall s a m. (Monad m) => ParserT s m a -> ParserT s m Unit
+skipMany p = skipMany1 p <|> return unit
 
-skipMany1 :: forall s a m. (Monad m) => ParserT s m a -> ParserT s m {}
+skipMany1 :: forall s a m. (Monad m) => ParserT s m a -> ParserT s m Unit
 skipMany1 p = do
   x <- p
   xs <- skipMany p
-  return {}
+  return unit
 
 lookAhead :: forall s a m. (Monad m) => ParserT s m a -> ParserT s m a
 lookAhead (ParserT p) = ParserT \s -> do

src/Text/Parsing/Parser/String.purs

@@ -14,10 +14,10 @@ import Control.Monad.State.Class
 import Text.Parsing.Parser
 import Text.Parsing.Parser.Combinators
 
-eof :: forall m. (Monad m) => ParserT String m {}
+eof :: forall m. (Monad m) => ParserT String m Unit
 eof = ParserT $ \s ->
   return $ case s of
-    "" -> { consumed: false, input: s, result: Right {} }
+    "" -> { consumed: false, input: s, result: Right unit }
     _ -> { consumed: false, input: s, result: Left (strMsg "Expected EOF") }
 
 string :: forall m. (Monad m) => String -> ParserT String m String
@@ -43,10 +43,10 @@ whiteSpace = do
   list <- many $ string "\n" <|> string "\r" <|> string " " <|> string "\t"
   return $ foldMap id list
 
-skipSpaces :: forall m. (Monad m) => ParserT String m {}
+skipSpaces :: forall m. (Monad m) => ParserT String m Unit
 skipSpaces = do
   whiteSpace
-  return {}
+  return unit
 
 oneOf :: forall s m a. (Monad m) => [String] -> ParserT String m String
 oneOf ss = satisfy (flip elem ss)