feat: prove lawful instances of Functor, Applicative and Alternative for Parser

Author: null-char

parser-combinators.cabal

@@ -4,7 +4,7 @@ cabal-version: 1.12
 --
 -- see: https://github.com/sol/hpack
 --
--- hash: 431ab4fb1b73226f52fcb1b718332fbbedb7a2139aaf244e7c3dbeb952b40bc8
+-- hash: 71f3ca8abf5da7454836ff89392289ab895d955597e20575edd7257de0129f98
 
 name:           parser-combinators
 version:        0.1.0.0
@@ -29,6 +29,7 @@ library
   exposed-modules:
       Lib
       Parser
+      Primitives
   other-modules:
       Paths_parser_combinators
   hs-source-dirs:

src/Parser.hs

@@ -1,41 +1,43 @@
 {-# LANGUAGE OverloadedStrings #-}
 
 module Parser
-  (
+  ( runParser,
+    Parser (..),
   )
 where
 
-import qualified Data.Map as M
+import Control.Applicative
 import qualified Data.Text as T
-import Text.Read (readMaybe)
-
-data JsonVal
-  = -- Maybe indicates the fractional part of the number. This will obviously be `Nothing` if it's
-    -- just a plain integer.
-    JsonNumber Integer (Maybe Integer)
-  | JsonBool Bool
-  | JsonNull
-  | JsonString T.Text
-  | JsonArray [JsonVal]
-  | JsonObj (M.Map T.Text JsonVal)
-  deriving (Eq, Show)
 
+-- | Wraps a `parse` function into a newtype called `Parser` parameterized by some type `a`.
 newtype Parser a = Parser {parse :: T.Text -> Maybe (a, T.Text)}
 
+-- Lawful instance of Functor implemented for Parser
+instance Functor Parser where
+  -- Applies a function to the parsed stream yielding another Parser with the transformed stream
+  fmap f p = Parser $ \s -> do
+    (x, rest) <- parse p s
+    Just (f x, rest)
+
+instance Applicative Parser where
+  pure x = Parser $ \s -> Just (x, s)
+
+  -- This is how we'll essentially end up chaining parsers together
+  (<*>) (Parser p1) (Parser p2) = Parser $ \s -> do
+    (f, s') <- p1 s
+    (x, s'') <- p2 s'
+    Just (f x, s'')
+
+instance Alternative Parser where
+  -- Picks the first non-empty `Maybe`
+  (<|>) (Parser p1) (Parser p2) = Parser $ \s -> p1 s <|> p2 s
+
+  -- The "empty" value for Parser will be a parser that parses to `Nothing` which indicates a failure
+  empty = Parser $ \_ -> Nothing
+
 runParser :: Parser a -> T.Text -> a
 runParser m s =
   case parse m s of
     Just (res, "") -> res
     Just (_, rest) -> error "Parser did not consume the entire stream"
     Nothing -> error "Parser did not manage to parse anything"
-
--- A test parser
-digit :: Parser Int
-digit = Parser $ \s ->
-  case s of
-    "" -> Nothing
-    t ->
-      let ch = T.head t; cs = T.tail t
-       in case readMaybe [ch] of
-            Just x -> Just (x, cs)
-            Nothing -> Nothing