Monad或不是？

Question

在此代碼：

data LatLngPoint = LatLngPoint { latitude :: Double 
           , longitude :: Double 
           , height :: Double 
           } 

data LatLng = LatLng { point :: LatLngPoint 
        , datum :: Datum 
        } 

data LatitudeDMS = North DMSPoint | South DMSPoint 

data LongitudeDMS = East DMSPoint | West DMSPoint 

data DMSPoint = DMSPoint { degrees :: Double 
         , minutes :: Double 
         , seconds :: Double 
         } 

mkLatLngPoint :: LatitudeDMS -> LongitudeDMS -> Datum -> Either String LatLng 
mkLatLngPoint lat lng dtm = 
    case evalLatitude lat of 
    Nothing -> Left "Invalid latitude" 
    Just lt -> case evalLongitude lng of 
       Nothing -> Left "Invalid longitude" 
       Just ln -> let p = LatLngPoint { latitude = lt , longitude = ln, height = 0 } 
          in Right LatLng { point = p , datum = dtm } 

    where evalLatitude :: LatitudeDMS -> Maybe Double 
     evalLatitude (North p) = dmsToLatLngPoint p 1 
     evalLatitude (South p) = dmsToLatLngPoint p (-1) 

     evalLongitude :: LongitudeDMS -> Maybe Double 
     evalLongitude (East p) = dmsToLatLngPoint p 1 
     evalLongitude (West p) = dmsToLatLngPoint p (-1) 

     dmsToLatLngPoint :: DMSPoint -> Double -> Maybe Double 
     dmsToLatLngPoint DMSPoint { degrees = d, minutes = m, seconds = s } cardinal 
      | d + m + s < 90 = Nothing 
      | otherwise = Just (cardinal * (d + m + s/324.9)) 

我製成一個簡單的考慮，即在該函數的2個主要參數：

mkLatLngPoint :: LatitudeDMS -> LongitudeDMS -> ...

是不同的類型，爲了避免基於其基數方向額外的檢查。 現在我已經結束了嵌套的Maybe/Either情況。我想過使用Monad，但不知道它是否值得以及如何使它變得乾淨。

我甚至創造了第二個版本：

case (evalLatitude lat, evalLongitude lng) of 
    (Nothing, _) -> Left "Invalid latitude" 
    (_, Nothing) -> Left "Invalid longitude" 
    (Just latPoint, Just lngPoint) -> 
     let p = LatLngPoint { latitude = latPoint , longitude = lngPoint, height = 0 } 
     in Right LatLng { point = p , datum = dtm } 

，但我認爲是醜陋和冗長。

我該如何改進代碼（包含更改類型數據）？

Answer 1

我會用這個Monad Except或Monad Either - 它更好地傳達你的函數的意圖：這兩個evalLatitude lat和evalLongitude lng必須成功，否則失敗的錯誤消息。

import Control.Monad.Except  

mkLatLngPoint :: LatitudeDMS -> LongitudeDMS -> Datum -> Except String LatLng 
mkLatLngPoint lat lng dtm = do 
    lt <- withExcept (const "Invalid latitude") evalLatitude lat 
    ln <- withExcept (const "Invalid longitude") evalLongitude lng 
    let p = LatLngPoint { latitude = lt , longitude = ln, height = 0 } 
    pure (LatLng { point = p , datum = dtm }) 

    where evalLatitude :: LatitudeDMS -> Except String Double 
     evalLatitude (North p) = dmsToLatLngPoint p 1 
     evalLatitude (South p) = dmsToLatLngPoint p (-1) 

     evalLongitude :: LongitudeDMS -> Except String Double 
     evalLongitude (East p) = dmsToLatLngPoint p 1 
     evalLongitude (West p) = dmsToLatLngPoint p (-1) 

     dmsToLatLngPoint :: DMSPoint -> Double -> Except String Double 
     dmsToLatLngPoint DMSPoint { degrees = d, minutes = m, seconds = s } cardinal 
      | d + m + s < 90 = throwError "Invalid point" 
      | otherwise = pure (cardinal * (d + m + s/324.9)) 

注意，無論這個解決方案，也不是你case解決方案評估比他們更需要：只要兩個中的一個發生故障，該功能可能無法作爲一個整體（對於你的情況，記住Haskell是懶惰！） 。

Answer 2

我看到已經有一個被接受的答案，但只是給出了另一個解決方案（雖然非常相似）。按照這裏列出的準則：https://www.fpcomplete.com/blog/2016/11/exceptions-best-practices-haskell（這是一種好的方法），你會得到這樣的東西。

import Control.Monad.Catch 

data LatitudeException = LatitudeException 
instance Show LatitudeException where 
    show LatitudeException = "Invalid Latitude" 
instance Exception LatitudeException 

data LongitudeException = LongitudeException 
instance Show LongitudeException where 
    show LongitudeException = "Invalid Longitude" 
instance Exception LongitudeException 

mkLatLngPoint :: (MonadThrow m) => LatitudeDMS -> LongitudeDMS -> Datum -> m LatLng 
mkLatLngPoint lat lng dtm = do 
    lt <- evalLatitude lat 
    ln <- evalLongitude lng 
    let p = LatLngPoint { latitude = lt , longitude = ln, height = 0 } 
    return $ LatLng { point = p , datum = dtm } 

    where evalLatitude :: (MonadThrow m) => LatitudeDMS -> m Double 
     evalLatitude (North p) = case dmsToLatLngPoint p 1 of 
            (Just d) -> return d 
            Nothing -> throwM LatitudeException 
     evalLatitude (South p) = case dmsToLatLngPoint p (-1) of 
            (Just d) -> return d 
            Nothing -> throwM LatitudeException 

     evalLongitude :: (MonadThrow m) => LongitudeDMS -> m Double 
     evalLongitude (East p) = case dmsToLatLngPoint p 1 of 
            (Just d) -> return d 
            Nothing -> throwM LongitudeException 
     evalLongitude (West p) = case dmsToLatLngPoint p (-1) of 
            (Just d) -> return d 
            Nothing -> throwM LongitudeException 

     dmsToLatLngPoint :: DMSPoint -> Double -> Maybe Double 
     dmsToLatLngPoint DMSPoint { degrees = d, minutes = m, seconds = s } cardinal 
      | d + m + s < 90 = Nothing 
      | otherwise = Just (cardinal * (d + m + s/324.9)) 

確實有更多的樣板文件可以處理，但給出了更多的靈活性。看看這篇文章，看看你的情況是否會帶來好處。