Say I want to parse a file in language *X*. Really, I'm only interested in a small part of the information within. It's easy enough to write a parser in one of Haskell's many eDSLs for that purpose (e.g. Megaparsec).

```
data Foo = Foo Int  -- the information I'm after.

parseFoo :: Parsec Text Foo
parseFoo = ...

```

That readily gives rise to a function `getFoo :: Text -> Maybe Foo`.

But now I would also like to *modify* the source of the `Foo` information, i.e. basically I want to implement

```
changeFoo :: (Foo -> Foo) -> Text -> Text

```

with the properties

```
changeFoo id ≡ id
getFoo . changeFoo f ≡ fmap f . getFoo

```

It's possible to do that by changing the result of the parser to something like a lens

```
parseFoo :: Parsec Text (Foo, Foo -> Text)
parseFoo = ...

```

but that makes the definition a lot more cumbersome – I can't just gloss over irrelevant information anymore, but need to store the match of every `string` subparse and manually reassemble it.

This could be somewhat automated by keeping the string-reassembage in a `StateT` layer around the parser monad, but I couldn't just use the existing primitive parsers.

Is there an existing solution for this problem?