Haskell - Modo più efficiente per completare l'algoritmo?

Question

Ho creato un algoritmo che accetta un valore Int non negativo, che rappresenta un numero totale di minuti, e restituisce una tripla che fornisce (giorni, ore, minuti) a cui questo corrisponde.

Ecco il mio codice:

calcdays :: Int -> Int 
calcdays x = x `div` (24*60) 

calchours :: Int -> Int 
calchours x = (x - ((calcdays x)*24*60)) `div` 60 

calcmins :: Int -> Int 
calcmins x = (x - ((calcdays x)*24*60) - ((calchours x)*60)) 

dayshoursmins :: Int -> (Int,Int,Int) 
dayshoursmins x = (calcdays x, calchours x, calcmins x) 

Usando solo operazioni di base Haskell (guardie, div, mods, ecc), c'è un modo più semplice di programmazione di questa funzione?

EDIT:

ho usato un suggerimento di seguito per rendere questo codice più semplice, mentre non è così semplice come la soluzione qoutRem, ho pensato che avrei potuto pubblicarlo:

calcdays :: Int -> Int 
calcdays x = x `div` (24*60) 

calchours :: Int -> Int 
calchours x = (x `mod` (24*60)) `div` 60 

calcmins :: Int -> Int 
calcmins x = (x `mod` (24*60)) `mod` 60 

dayshoursmins :: Int -> (Int,Int,Int) 
dayshoursmins x = (calcdays x, calchours x, calcmins x) 

Answer 1

Penso somethink come questo

dayshoursmins x = (d,hr,mr) where 
(h,mr) = quotRem x 60 
(d,hr) = quotRem h 24 

Answer 2

È possibile utilizzare

a `mod` b 

per ottenere direttamente il resto.

E è possibile utilizzare let or where per calcolare una sottoespressione.