u/CodeNameGodTri

Hi,

I'm a newbie and I’m working through the CodeCrafters shell challenge in Haskell, specifically the single-quote parsing stage.

https://preview.redd.it/460fqxjtsj9h1.png?width=1694&format=png&auto=webp&s=7070c14c1308836086925b9c16b460aac44b51be

My source code:
https://github.com/tri97nguyen/codecrafters-shell-haskell/blob/6995a88feabc92bdd3e3d5b04912c89675fac196/app/Main.hs

The codebase includes other completed stages, so the relevant entry point is cmdLineArgParser around line 111.

I’m using Megaparsec, and although I’ve learned the basic idea of parser combinators, my solution feels too mechanical and fragile. I keep having to tweak small parser details to force the behavior I want, instead of expressing the grammar clearly.

For example, “parse everything between two single quotes” sounds trivial, but around line 84 I ended up needing logic like:

try . lookAhead $ endQuote

just to make sure I’m not accidentally treating an adjacent quote as the wrong boundary.

The result works, but it does not feel idiomatic. It feels like I’m fighting Megaparsec rather than encoding the grammar. Worse, when I come back to this parser a few days later, I can understand that it works, but not why the structure is the right one.

Is this just the normal learning curve for parser combinators, or is it a sign that I’m modeling the shell grammar at the wrong level? How would you structure this parser so that single quotes, adjacent quoted strings, and unquoted words are handled cleanly?

Thank you for your help!

Hello everyone,

I'm a beginner looking for feedback. I wrote my own splitOn because words only splits on whitespace, and I didn’t want to pull in the split package just for one small utility function.

I ended up using a State monad approach. I know the state monad is probably overkill here, but I couldn’t think of a more idiomatic Haskell to mutate/build out a new list. I also used Seq to idiomatically access the last item efficiently O(1) instead of List

Please give me feedback on:

• more idiomatic Haskell style
• whether State here is considered bad practice
• other cleaner solution not using State, I initally thought of fold but my brain froze

import Control.Monad.State (State, get, put, runState, execState)
import System.Environment (getEnv)
import Data.Sequence (Seq((:<|), (:|>), Empty), (|>), singleton)
import Data.Foldable (toList)

splitOn :: String -> Char -> [String]
splitOn text delimiter =
    toList $ execState (splitString text) (singleton "")

    where
    splitString :: String -> State (Seq String) ()
    splitString "" = return ()
    splitString (char : tail) = do
        parseChar char
        splitString tail


    parseChar :: Char -> State (Seq String) ()
    parseChar char = do
        currentState <- get
        if char == delimiter then put $ currentState |> ""
        else do
            let (front :|> lastItem) = currentState
                newLastItem = lastItem <> [char]
            put (front :|> newLastItem)

Appreciate any feedback or suggestions.