@@ -1,37 +1,77 @@
1−module Common.Monad.Validation where
1+{-# LANGUAGE CPP #-}
2+{-# LANGUAGE GeneralizedNewtypeDeriving #-}
3+{-# LANGUAGE OverloadedStrings #-}
4+{-# LANGUAGE TemplateHaskell #-}
5+{-# LANGUAGE TypeFamilies #-}
6+{-# LANGUAGE UndecidableInstances #-}
27
8+module Control.Monad.Validation
9+ ( ValidationT(..)
10+ , runValidationT
11+ , runValidationTEither
12+ , handleValidationT
13+ , vError
14+ , vWarning
15+ , vErrorL
16+ , vWarningL
17+ , vZoom
18+ , vZoomL
19+ , vPromote
20+ , mmSingleton
21+ , setMempty
22+ , neConcat
23+ , textErrors
24+ , _MonoidMap
25+ , MonoidMap(..)
26+ ) where
27+
28+import Control.Applicative
329import Control.Lens hiding ((.=))
430import Control.Monad.Base
531import Control.Monad.Catch
632import Control.Monad.Except
33+import Control.Monad.Fail
734import Control.Monad.State.Strict
8−import Control.Monad.Trans.Lift.Local
35+import Control.Monad.Trans.Control
936import Data.Aeson
1037import Data.Foldable as F
38+import Data.Functor
1139import Data.List as L
1240import Data.Map.Strict as M
13−import Data.Monoid
1441import Data.Text as T
1542import Data.Vector as V
1643import Test.QuickCheck
1744
18−-- | Collects all throwed "warnings" throwed through StateT and "errors" throwed
19−-- through ExceptT to single value using Monoid
20−-- FIXME: give more instances like HReaderT and MonadBaseControl/MonadMask
45+#if MIN_VERSION_mtl(2,3,0)
46+import Control.Monad
47+import Control.Monad.Fix
48+#endif
49+
50+-- | Collects all thrown warnings in 'StateT' and errors
51+-- in 'ExceptT' into a single value using 'Monoid'.
2152newtype ValidationT e m a = ValidationT
2253 { unValidationT :: ExceptT e (StateT e m) a
2354 } deriving ( Functor, Applicative, Monad, MonadThrow, MonadCatch
24− , MonadBase b )
55+ , MonadBase b, Alternative, MonadFix, MonadFail, Contravariant
56+ , MonadIO, MonadPlus, MonadBaseControl b, MonadMask )
2557
2658instance MonadTrans (ValidationT e) where
2759 lift = ValidationT . lift . lift
2860
29−instance LiftLocal (ValidationT e) where
30− liftLocal _ l f = ValidationT . mapExceptT (mapStateT $ l f) . unValidationT
31−
3261-- | Map with 'Monoid' instance which 'mappend' its values
62+--
63+-- This can be used as the `e` in `ValidationT e m a` to provide different
64+-- sets of errors and warnings for different keys.
65+--
66+-- >>> :{
67+-- mconcat
68+-- [ MonoidMap $ M.fromList [(1, "foo"), (2, "hello, "), (3, "oh no")]
69+-- , MonoidMap $ M.fromList [(1, "bar"), (2, "world")]
70+-- ]
71+-- :}
72+-- MonoidMap (fromList [(1,"foobar"),(2,"hello, world"),(3,"oh no")])
3373newtype MonoidMap k v = MonoidMap (Map k v)
34− deriving (Eq, Ord, Show, Arbitrary)
74+ deriving (Eq, Ord, Show, Arbitrary, Foldable)
3575
3676makePrisms ''MonoidMap
3777
@@ -42,10 +82,14 @@ instance (Ord k) => Ixed (MonoidMap k v) where
4282instance (Ord k) => At (MonoidMap k v) where
4383 at key = _MonoidMap . at key
4484
85+#if MIN_VERSION_base(4,11,0)
86+instance (Ord k, Semigroup v) => Semigroup (MonoidMap k v) where
87+ (<>) = mmAppend
88+#endif
89+
4590instance (Ord k, Monoid v) => Monoid (MonoidMap k v) where
4691 mempty = MonoidMap M.empty
47− mappend (MonoidMap a) (MonoidMap b) =
48− MonoidMap $ M.unionWith (<>) a b
92+ mappend = (<>)
4993
5094instance (ToJSON k, ToJSON v) => ToJSON (MonoidMap k v) where
5195 toJSON (MonoidMap m) = toJSON $ L.map toObj $ M.toList m
@@ -55,7 +99,7 @@ instance (ToJSON k, ToJSON v) => ToJSON (MonoidMap k v) where
5599 , "value" .= v ]
56100
57101instance (Ord k, FromJSON k, FromJSON v) => FromJSON (MonoidMap k v) where
58− parseJSON v = withArray "MonoidMap" go v
102+ parseJSON = withArray "MonoidMap" go
59103 where
60104 go arr = do
61105 keyvals <- traverse fromObj arr
@@ -65,35 +109,67 @@ instance (Ord k, FromJSON k, FromJSON v) => FromJSON (MonoidMap k v) where
65109 val <- obj .: "value"
66110 return (key, val)
67111
68−-- | Convenient for 'vZoom' as first artument. Will prevent generation
69−-- of map with 'mempty' values
112+#if MIN_VERSION_base(4,11,0)
113+mmAppend :: (Ord k, Semigroup v) => MonoidMap k v -> MonoidMap k v -> MonoidMap k v
114+#else
115+mmAppend :: (Ord k, Monoid v) => MonoidMap k v -> MonoidMap k v -> MonoidMap k v
116+#endif
117+mmAppend (MonoidMap a) (MonoidMap b) = MonoidMap $ M.unionWith (<>) a b
118+
119+-- | Convenient for 'vZoom' as first argument. Will prevent generation
120+-- of map with 'mempty' values.
70121mmSingleton :: (Eq v, Monoid v, Ord k) => k -> v -> MonoidMap k v
71−mmSingleton k = memptyWrap mempty $ MonoidMap . M.singleton k
122+mmSingleton k v
123+ | v == mempty = mempty
124+ | otherwise = MonoidMap . M.singleton k $ v
72125
73−-- | Set given value to 'mempty'
126+-- | Sets given value to 'mempty'.
74127setMempty :: (Monoid s) => ASetter' s a -> a -> s
75128setMempty setter a = set setter a mempty
76129
77−memptyWrap :: (Eq a, Monoid a) => b -> (a -> b) -> a -> b
78−memptyWrap b f a
79− | a == mempty = b
80− | otherwise = f a
81−
82−-- | If given container is not 'mempty', then use given function to
83−-- append all its elements and return 'Just' result
84−neConcat
85− :: (Foldable f, Eq (f a), Monoid a, Monoid (f a))
86− => (a -> a -> a)
87− -> f a
88− -> Maybe a
89−neConcat f = memptyWrap Nothing (Just . F.foldl' f mempty)
130+neConcat :: Foldable f => (a -> a -> a) -> f a -> Maybe a
131+neConcat f a
132+ | F.null a = Nothing
133+ | otherwise = Just $ F.foldr1 f a
90134
135+-- | Returns the strings, concatanated with @", "@ if the list is not empty.
136+--
137+-- Returns Nothing if the list is empty
138+--
139+-- >>> textErrors ["foo", "bar"]
140+-- Just "foo, bar"
141+--
142+-- >>> textErrors ["foo"]
143+-- Just "foo"
144+--
145+-- >>> textErrors []
146+-- Nothing
91147textErrors :: [Text] -> Maybe Text
92148textErrors = neConcat (\a b -> a <> ", " <> b)
93149
94−-- | Returns `mempty` instead of error if no warnings was occured. So, your
95−-- error should have `Eq` instance to detect that any error was occured. Returns
96−-- Nothing for second element of tuple if compuration was interruped by 'vError'
150+-- | Returns 'mempty' instead of error if no warnings have occurred.
151+-- Returns 'Nothing' as the second element of tuple if computation was
152+-- interrupted by 'vError'.
153+--
154+-- Returns all concatenated errors and warnings and the result if no
155+-- errors have occurred (warnings could have occurred).
156+--
157+-- >>> :{
158+-- runValidationT $ do
159+-- vWarning ["warning1"]
160+-- vError ["error"]
161+-- vWarning ["warning2"]
162+-- return 8
163+-- :}
164+-- (["error","warning1"],Nothing)
165+--
166+-- >>> :{
167+-- runValidationT $ do
168+-- vWarning ["warning1"]
169+-- vWarning ["warning2"]
170+-- return 8
171+-- :}
172+-- (["warning1","warning2"],Just 8)
97173runValidationT :: (Monoid e, Monad m) => ValidationT e m a -> m (e, Maybe a)
98174runValidationT (ValidationT m) = do
99175 (res, warnings) <- runStateT (runExceptT m) mempty
@@ -101,6 +177,25 @@ runValidationT (ValidationT m) = do
101177 Left err -> (err <> warnings, Nothing)
102178 Right a -> (warnings, Just a)
103179
180+-- | Like 'runValidationT' but doesn't return the result
181+-- if any warning has occurred.
182+--
183+-- >>> :{
184+-- runValidationTEither $ do
185+-- vWarning ["warning1"]
186+-- vError ["error"]
187+-- vWarning ["warning2"]
188+-- return 8
189+-- :}
190+-- Left ["error","warning1"]
191+--
192+-- >>> :{
193+-- runValidationTEither $ do
194+-- vWarning ["warning1"]
195+-- vWarning ["warning2"]
196+-- return 8
197+-- :}
198+-- Left ["warning1","warning2"]
104199runValidationTEither
105200 :: (Monoid e, Eq e, Monad m)
106201 => ValidationT e m a
@@ -111,28 +206,71 @@ runValidationTEither action = do
111206 Just a | err == mempty -> Right a
112207 _ -> Left err
113208
209+-- | Like 'runValidationTEither', but takes an error handler instead of
210+-- returning errors and warnings.
211+--
212+-- >>> :{
213+-- handleValidationT (\_ -> return 11) $ do
214+-- vWarning ["warning1"]
215+-- vError ["error"]
216+-- vWarning ["warning2"]
217+-- return 8
218+-- :}
219+-- 11
220+--
221+-- >>> :{
222+-- handleValidationT (\_ -> return 11) $ do
223+-- vWarning ["warning1"]
224+-- vWarning ["warning2"]
225+-- return 8
226+-- :}
227+-- 11
114228handleValidationT
115229 :: (Monoid e, Monad m, Eq e)
116230 => (e -> m a)
117231 -> ValidationT e m a
118232 -> m a
119−handleValidationT handler action = do
233+handleValidationT handler action =
120234 runValidationTEither action >>= either handler return
121235
122−-- | Stops further execution of validation
236+-- | Stops further execution and appends the given error.
123237vError :: (Monad m) => e -> ValidationT e m a
124238vError e = ValidationT $ throwError e
125239
126−-- | Does not stop further execution, append warning to
240+-- | Does not stop further execution and appends the given warning.
127241vWarning :: (Monad m, Monoid e) => e -> ValidationT e m ()
128242vWarning e = ValidationT $ modify' (<> e)
129243
244+-- | Like 'vError' but allows you to use a setter to insert an error somewhere
245+-- deeper into an empty ('mempty') "e" from "ValidationT e m x", which is then
246+-- combined with all gathered warnings.
130247vErrorL :: (Monad m, Monoid e) => ASetter' e a -> a -> ValidationT e m x
131248vErrorL l a = vError $ setMempty l a
132249
250+-- | Like 'vWarning' but allows you to use a setter to insert an error somewhere
251+-- deeper into an empty ('mempty') "e" from "ValidationT e m x", which is then
252+-- combined with all gathered warnings.
133253vWarningL :: (Monad m, Monoid e) => ASetter' e a -> a -> ValidationT e m ()
134254vWarningL l a = vWarning $ setMempty l a
135255
256+-- | Allows you apply a transformation to the "e" in "ValidationT e m x".
257+--
258+-- >>> :{
259+--runValidationT . vZoom (Data.Map.singleton "password errors") $ do
260+-- vWarning ["warning1"]
261+-- vError ["error"]
262+-- vWarning ["warning2"]
263+-- return 8
264+-- :}
265+-- (fromList [("password errors",["error","warning1"])],Nothing)
266+--
267+-- >>> :{
268+-- runValidationT . vZoom (Data.Map.singleton "password errors") $ do
269+-- vWarning ["warning1"]
270+-- vWarning ["warning2"]
271+-- return 8
272+-- :}
273+-- (fromList [("password errors",["warning1","warning2"])],Just 8)
136274vZoom
137275 :: (Monad m, Monoid a, Monoid b)
138276 => (a -> b)
@@ -142,11 +280,21 @@ vZoom up action = do
142280 (err, res) <- lift $ runValidationT action
143281 case res of
144282 Nothing -> vError $ up err
145− Just a -> vWarning (up err) *> return a
283+ Just a -> vWarning (up err) $> a
146284
285+-- | Like 'vZoom' but takes a setter instead of a function.
147286vZoomL
148287 :: (Monad m, Monoid a, Monoid b)
149288 => ASetter' b a
150289 -> ValidationT a m x
151290 -> ValidationT b m x
152−vZoomL l action = vZoom (setMempty l) action
291+vZoomL l = vZoom (setMempty l)
292+
293+-- | Turn any warnings the have occurred into errors.
294+vPromote
295+ :: (Monad m, Monoid a, Eq a)
296+ => ValidationT a m x
297+ -> ValidationT a m x
298+vPromote m = do
299+ err <- lift $ runValidationTEither m
300+ either vError return err