Digamos que tengo el siguiente modelo de datos, para realizar un seguimiento de las estadísticas de los jugadores de béisbol, equipos y entrenadores:

data BBTeam = BBTeam { teamname :: String, 
                       manager :: Coach,
                       players :: [BBPlayer] }  
     deriving (Show)

data Coach = Coach { coachname :: String, 
                     favcussword :: String,
                     diet :: Diet }  
     deriving (Show)

data Diet = Diet { dietname :: String, 
                   steaks :: Integer, 
                   eggs :: Integer }  
     deriving (Show)

data BBPlayer = BBPlayer { playername :: String, 
                           hits :: Integer,
                           era :: Double }  
     deriving (Show)

Ahora digamos que los gerentes, que generalmente son fanáticos de los filetes, quieren comer aún más filetes, por lo que debemos poder aumentar el contenido de filetes de la dieta de un gerente. Aquí hay dos implementaciones posibles para esta función:

1) Esto utiliza muchas coincidencias de patrones y tengo que obtener todos los argumentos para todos los constructores correctamente ... dos veces. Parece que no se escalaría muy bien o sería muy fácil de mantener / legible.

addManagerSteak :: BBTeam -> BBTeam
addManagerSteak (BBTeam tname (Coach cname cuss (Diet dname oldsteaks oldeggs)) players) = BBTeam tname newcoach players
  where
    newcoach = Coach cname cuss (Diet dname (oldsteaks + 1) oldeggs)

2) Esto utiliza todos los accesores provistos por la sintaxis de registro de Haskell, pero también es feo y repetitivo, y creo que es difícil de mantener y leer.

addManStk :: BBTeam -> BBTeam
addManStk team = newteam
  where
    newteam = BBTeam (teamname team) newmanager (players team)
    newmanager = Coach (coachname oldcoach) (favcussword oldcoach) newdiet
    oldcoach = manager team
    newdiet = Diet (dietname olddiet) (oldsteaks + 1) (eggs olddiet)
    olddiet = diet oldcoach
    oldsteaks = steaks olddiet

Mi pregunta es, ¿es uno de estos mejor que el otro, o más preferido dentro de la comunidad de Haskell? ¿Hay una mejor manera de hacer esto (para modificar un valor dentro de una estructura de datos manteniendo el contexto)? No me preocupa la eficiencia, solo codifique elegancia / generalidad / mantenibilidad.

Me di cuenta de que hay algo para este problema (¿o un problema similar?) En Clojure:update-in - así que creo que estoy tratando de entenderupdate-in en el contexto de la programación funcional y Haskell y la escritura estática.