Parsing and functor combinator - Haskell

module Main where

import Prelude
import Data.Maybe
import Data.Tuple
import Data.String

import Effect (Effect)
import Effect.Console (log)



newtype Parser a = Parser (String -> Maybe (Tuple a String))

runParser :: forall a. Parser a -> String -> (Maybe (Tuple a String))
runParser (Parser f) = f

instance parserFunctor :: Functor Parser where
  map g parser =
    let
      underTuple (Tuple x y) = Tuple (g x) y
    in
      Parser (\x -> underTuple <$> (runParser parser x))

instance parserApplicative :: Apply Parser where
  apply atob a = Parser applied
    where
      applied content = do
        Tuple f rest <- runParser atob content
        Tuple result rest' <- runParser a rest
        pure $ Tuple (f result) rest'

instance parserMonad :: Bind Parser where
  bind ma atomb = Parser bound
    where
      bound str = do
        Tuple x rest <- runParser ma str
        runParser (atomb x) rest

charParser :: Parser CodePoint
charParser = Parser (\str -> trafficateUncons <$> (uncons str))
  where
    trafficateUncons :: { head::CodePoint, tail::String} -> Tuple CodePoint String
    trafficateUncons { head, tail} = Tuple head tail

specificCharParser :: Char -> Parser Unit
specificCharParser cp = Parser specificCharChecker
  where
    specificCharChecker :: String -> (Maybe (Tuple Unit String))
    specificCharChecker str = do
      Tuple head tail <- runParser charParser str
      if head == (codePointFromChar cp)
        then pure $ Tuple unit tail
        else Nothing



main :: Effect Unit
main = do
  log $ show $ runParser (specificCharParser 'b') "a "