sparsec

commit 59aa556e7760664f7e18e8a837fc1a23377a7c79
parent 03a59e42504d4ac54b0dcedb60d04a8bb7e941e3
Author: Robert Russell <robert@rr3.xyz>
Date:   Sun, 14 Dec 2025 11:36:38 -0800

Rename Ok to Success

Diffstat:
M
Sparsec.hs
 | 
35
+++++++++++++++++------------------

1 file changed, 17 insertions(+), 18 deletions(-)
diff --git a/Sparsec.hs b/Sparsec.hs
@@ -201,14 +201,14 @@ instance Show Span where
 data Result e a
     = Failure
     | Error e
-    | Ok a ByteString Loc
+    | Success a ByteString Loc
     deriving (Eq)
 
 instance (Show e, Show a) => Show (Result e a) where
     show = \case
         Failure -> "failure"
         Error e -> "error: " ++ show e
-        Ok a rest _ ->
+        Success a rest _ ->
             if BS.null rest
                 then
                     printf "ok: %s" (show a)
@@ -222,7 +222,7 @@ instance Functor (Result e) where
     fmap f = \case
         Failure -> Failure
         Error e -> Error e
-        Ok a rest loc -> Ok (f a) rest loc
+        Success a rest loc -> Success (f a) rest loc
 
 --------------------------------------------------------------------------------
 -- Parse monad and core combinators
@@ -261,7 +261,7 @@ mapParse f = mapParseT (Identity . f . runIdentity)
 --     runParseT p input loc >>= \case
 --         Failure -> runParseT hf input loc
 --         Error e -> runParseT (he e) input loc
---         Ok a input' loc' -> runParseT (ho a) input' loc'
+--         Success a input' loc' -> runParseT (ho a) input' loc'
 -- bind2 :: (Monad m) => (a -> ParseT e m a') -> ParseT e m a -> ParseT e m a'
 -- bind2 h = handle fail err h
 -- catch2 :: (Monad m) => (e -> ParseT e' m a) -> ParseT e m a -> ParseT e' m a
@@ -270,7 +270,6 @@ mapParse f = mapParseT (Identity . f . runIdentity)
 -- alt2 h = handle h err pure
 -- branch2 :: (Monad m) => ParseT e m a' -> (a -> ParseT e m a') -> ParseT e m a -> ParseT e m a'
 -- branch2 hf ho = handle hf err ho
--- -- TODO: Rename Ok to Success
 -- succeed :: (Monad m) => a -> ParseT e m a
 -- succeed = pure
 
@@ -278,7 +277,7 @@ instance (Monad m) => Functor (ParseT e m) where
     fmap = liftM
 
 instance (Monad m) => Applicative (ParseT e m) where
-    pure a = ParseT \input loc -> pure $ Ok a input loc
+    pure a = ParseT \input loc -> pure $ Success a input loc
 
     (<*>) = ap
 
@@ -287,7 +286,7 @@ instance (Monad m) => Monad (ParseT e m) where
         runParseT p input loc >>= \case
             Failure -> pure Failure
             Error e -> pure $ Error e
-            Ok a input' loc' -> runParseT (k a) input' loc'
+            Success a input' loc' -> runParseT (k a) input' loc'
 
 instance (Monad m) => Alternative (ParseT e m) where
     empty = ParseT \_ _ -> pure Failure
@@ -296,10 +295,10 @@ instance (Monad m) => Alternative (ParseT e m) where
         runParseT p input loc >>= \case
             Failure -> runParseT q input loc
             Error e -> pure $ Error e
-            Ok a input' loc' -> pure $ Ok a input' loc'
+            Success a input' loc' -> pure $ Success a input' loc'
 
 instance MonadTrans (ParseT e) where
-    lift m = ParseT \input loc -> (\a -> Ok a input loc) <$> m
+    lift m = ParseT \input loc -> (\a -> Success a input loc) <$> m
 
 instance (MonadReader r m) => MonadReader r (ParseT e m) where
     ask = lift ask
@@ -316,25 +315,25 @@ instance (MonadState s m) => MonadState s (ParseT e m) where
 
 -- | Read the entire input without consuming it.
 read :: (Monad m) => ParseT e m ByteString
-read = ParseT \input loc -> pure $ Ok input input loc
+read = ParseT \input loc -> pure $ Success input input loc
 
 -- | Replace the entire input without affecting the current location.
 write :: (Monad m) => ByteString -> ParseT e m ()
-write input = ParseT \_ loc -> pure $ Ok () input loc
+write input = ParseT \_ loc -> pure $ Success () input loc
 
 getLoc :: (Monad m) => ParseT e m Loc
-getLoc = ParseT \input loc -> pure $ Ok loc input loc
+getLoc = ParseT \input loc -> pure $ Success loc input loc
 
 putLoc :: (Monad m) => Loc -> ParseT e m ()
-putLoc loc = ParseT \input _ -> pure $ Ok () input loc
+putLoc loc = ParseT \input _ -> pure $ Success () input loc
 
 -- | Save parsing state. This is effectively a combination of read and getLoc.
 save :: (Monad m) => ParseT e m (ByteString, Loc)
-save = ParseT \input loc -> pure $ Ok (input, loc) input loc
+save = ParseT \input loc -> pure $ Success (input, loc) input loc
 
 -- | Load parsing state. This is effectively a combination of write and putLoc.
 load :: (Monad m) => (ByteString, Loc) -> ParseT e m ()
-load (input, loc) = ParseT \_ _ -> pure $ Ok () input loc
+load (input, loc) = ParseT \_ _ -> pure $ Success () input loc
 
 fail :: (Monad m) => ParseT e m a
 fail = empty
@@ -343,9 +342,9 @@ fail = empty
 notp :: (Monad m) => ParseT e m a -> ParseT e m ()
 notp p = ParseT \input loc ->
     runParseT p input loc >>= \case
-        Failure -> pure $ Ok () input loc
+        Failure -> pure $ Success () input loc
         Error e -> pure $ Error e
-        Ok{} -> pure Failure
+        Success{} -> pure Failure
 
 err :: (Monad m) => e -> ParseT e m a
 err e = ParseT \_ _ -> pure $ Error e
@@ -356,7 +355,7 @@ p `catch` h = ParseT \input loc ->
     runParseT p input loc >>= \case
         Failure -> pure Failure
         Error e -> runParseT (h e) input loc
-        Ok a input' loc' -> pure $ Ok a input' loc'
+        Success a input' loc' -> pure $ Success a input' loc'
 
 --------------------------------------------------------------------------------
 -- General combinators