Digamos que possuo o seguinte modelo de dados, para acompanhar as estatísticas de jogadores, equipes e treinadores de beisebol:

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)

Agora, digamos que os gerentes, que geralmente são fanáticos por bife, querem comer ainda mais bife - por isso, precisamos aumentar o conteúdo de bife da dieta de um gerente. Aqui estão duas implementações possíveis para esta função:

1) Isso usa muita correspondência de padrões e eu tenho que obter todos os argumentos ordenados para todos os construtores corretamente ... duas vezes. Parece que não seria muito bem dimensionado ou seria de fácil manutenção / legível.

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) Isso usa todos os acessadores fornecidos pela sintaxe de registro de Haskell, mas também é feio e repetitivo, e difícil de manter e ler, eu ach

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

A minha pergunta é: um deles é melhor que o outro ou é o mais preferido na comunidade Haskell? Existe uma maneira melhor de fazer isso (modificar um valor profundamente dentro de uma estrutura de dados, mantendo o contexto)? Não estou preocupado com eficiência, apenas codifique a elegância / generalidade / manutenção.

Notei que existe algo para esse problema (ou um problema semelhante?) No Clojure:update-in - então acho que estou tentando entenderupdate-ino contexto de programação funcional e Haskell e digitação estátic