decoder implementation that is not dependent on class -> move implementation to Implementation module (#74)

* feat: decoder implementation that is not dependent on class -> move implementation to Implementation module

* feat: encoder implementation that is not dependent on class -> move implementation to Implementation module

* refactor: review notes -> rename Implementation to Decoders/Encoders

* refactor: review notes -> encodeJsonXXX to encodeXXX, remove encodeJson function as it is done for decoders

* feat: review notes -> remove Decoder/Encoder types

Author: Serhii Khoma

src/Data/Argonaut/Decode.purs

@@ -4,4 +4,4 @@ module Data.Argonaut.Decode
   ) where
 
 import Data.Argonaut.Decode.Class (class DecodeJson, decodeJson)
-import Data.Argonaut.Decode.Combinators ( getField, getFieldDeprecated, getFieldOptional, getFieldOptionalDeprecated, getFieldOptional', defaultField, defaultFieldDeprecated, (.:), (.?), (.:!), (.:?), (.??), (.!=), (.?=))
+import Data.Argonaut.Decode.Combinators (getField, getFieldDeprecated, getFieldOptional, getFieldOptionalDeprecated, getFieldOptional', defaultField, defaultFieldDeprecated, (.:), (.?), (.:!), (.:?), (.??), (.!=), (.?=))

src/Data/Argonaut/Decode/Class.purs

@@ -1,142 +1,92 @@
 module Data.Argonaut.Decode.Class where
 
-import Prelude
+import Prelude (class Ord, Unit, Void, bind, ($), (<<<), (<>))
 
-import Control.Apply (lift2)
-import Data.Argonaut.Core (Json, isNull, caseJsonNull, caseJsonBoolean, caseJsonNumber, caseJsonString, toArray, toObject, toString, stringify)
-import Data.Array as Arr
+import Data.Argonaut.Core (Json, toObject)
 import Data.Array.NonEmpty (NonEmptyArray)
-import Data.Array.NonEmpty as NEA
-import Data.Bifunctor (lmap, rmap)
-import Data.Either (Either(..), note)
-import Data.Identity (Identity(..))
-import Data.Int (fromNumber)
-import Data.List (List, fromFoldable)
-import Data.List as L
+import Data.Either (Either(..))
+import Data.Identity (Identity)
+import Data.List (List)
 import Data.List.NonEmpty (NonEmptyList)
-import Data.List.NonEmpty as NEL
 import Data.Map as M
-import Data.Maybe (maybe, Maybe(..))
-import Data.NonEmpty (NonEmpty, (:|))
+import Data.Maybe (Maybe(..))
+import Data.NonEmpty (NonEmpty)
 import Data.Set as S
-import Data.String (CodePoint, codePointAt)
+import Data.String (CodePoint)
 import Data.Symbol (class IsSymbol, SProxy(..), reflectSymbol)
-import Data.Traversable (traverse)
-import Data.TraversableWithIndex (traverseWithIndex)
-import Data.Tuple (Tuple(..))
+import Data.Tuple (Tuple)
 import Foreign.Object as FO
 import Prim.Row as Row
 import Prim.RowList as RL
 import Record as Record
 import Type.Data.RowList (RLProxy(..))
+import Data.Argonaut.Decode.Decoders
 
 class DecodeJson a where
   decodeJson :: Json -> Either String a
 
 instance decodeIdentity :: DecodeJson a => DecodeJson (Identity a) where
-  decodeJson j = Identity <$> decodeJson j
+  decodeJson = decodeIdentity decodeJson
 
 instance decodeJsonMaybe :: DecodeJson a => DecodeJson (Maybe a) where
-  decodeJson j
-    | isNull j = pure Nothing
-    | otherwise = Just <$> decodeJson j
+  decodeJson = decodeMaybe decodeJson
 
 instance decodeJsonTuple :: (DecodeJson a, DecodeJson b) => DecodeJson (Tuple a b) where
-  decodeJson j = do
-    decoded <- decodeJson j
-    case decoded of
-      [a, b] -> lift2 Tuple (decodeJson a) (decodeJson b)
-      _ -> Left "Couldn't decode Tuple"
+  decodeJson = decodeTuple decodeJson decodeJson
 
 instance decodeJsonEither :: (DecodeJson a, DecodeJson b) => DecodeJson (Either a b) where
-  decodeJson json =
-    lmap ("Couldn't decode Either: " <> _) $
-      decodeJObject json >>= \obj -> do
-        tag <- maybe (Left "Expected field 'tag'") Right $ FO.lookup "tag" obj
-        val <- maybe (Left "Expected field 'value'") Right $ FO.lookup "value" obj
-        case toString tag of
-          Just "Right" -> Right <$> decodeJson val
-          Just "Left" -> Left <$> decodeJson val
-          _ -> Left "'tag' field was not \"Left\" or \"Right\""
+  decodeJson = decodeEither decodeJson decodeJson
 
 instance decodeJsonNull :: DecodeJson Unit where
-  decodeJson = caseJsonNull (Left "Value is not a null") (const $ Right unit)
+  decodeJson = decodeNull
 
 instance decodeJsonBoolean :: DecodeJson Boolean where
-  decodeJson = caseJsonBoolean (Left "Value is not a Boolean") Right
+  decodeJson = decodeBoolean
 
 instance decodeJsonNumber :: DecodeJson Number where
-  decodeJson = caseJsonNumber (Left "Value is not a Number") Right
+  decodeJson = decodeNumber
 
 instance decodeJsonInt :: DecodeJson Int where
-  decodeJson =
-    maybe (Left "Value is not an integer") Right
-      <<< fromNumber
-      <=< decodeJson
+  decodeJson = decodeInt
 
 instance decodeJsonString :: DecodeJson String where
-  decodeJson = caseJsonString (Left "Value is not a String") Right
+  decodeJson = decodeString
 
 instance decodeJsonJson :: DecodeJson Json where
   decodeJson = Right
 
 instance decodeJsonNonEmpty_Array :: (DecodeJson a) => DecodeJson (NonEmpty Array a) where
-  decodeJson =
-    lmap ("Couldn't decode NonEmpty Array: " <> _)
-      <<< (traverse decodeJson <=< (lmap ("JSON Array" <> _) <<< rmap (\x -> x.head :| x.tail) <<< note " is empty" <<< Arr.uncons) <=< decodeJArray)
+  decodeJson = decodeNonEmpty_Array decodeJson
 
 instance decodeJsonNonEmptyArray :: (DecodeJson a) => DecodeJson (NonEmptyArray a) where
-  decodeJson =
-    lmap ("Couldn't decode NonEmptyArray: " <> _)
-      <<< (traverse decodeJson <=< (lmap ("JSON Array" <> _) <<< rmap (\x -> NEA.cons' x.head x.tail) <<< note " is empty" <<< Arr.uncons) <=< decodeJArray)
+  decodeJson = decodeNonEmptyArray decodeJson
 
 instance decodeJsonNonEmpty_List :: (DecodeJson a) => DecodeJson (NonEmpty List a) where
-  decodeJson =
-    lmap ("Couldn't decode NonEmpty List: " <> _)
-      <<< (traverse decodeJson <=< (lmap ("JSON Array" <> _) <<< rmap (\x -> x.head :| x.tail) <<< note " is empty" <<< L.uncons) <=< map (map fromFoldable) decodeJArray)
+  decodeJson = decodeNonEmpty_List decodeJson
 
 instance decodeJsonNonEmptyList :: (DecodeJson a) => DecodeJson (NonEmptyList a) where
-  decodeJson =
-    lmap ("Couldn't decode NonEmptyList: " <> _)
-      <<< (traverse decodeJson <=< (lmap ("JSON Array" <> _) <<< rmap (\x -> NEL.cons' x.head x.tail) <<< note " is empty" <<< L.uncons) <=< map (map fromFoldable) decodeJArray)
+  decodeJson = decodeNonEmptyList decodeJson
 
-instance decodeJsonChar :: DecodeJson CodePoint where
-  decodeJson j =
-    maybe (Left $ "Expected character but found: " <> stringify j) Right
-      =<< codePointAt 0 <$> decodeJson j
+instance decodeJsonCodePoint :: DecodeJson CodePoint where
+  decodeJson = decodeCodePoint
 
 instance decodeForeignObject :: DecodeJson a => DecodeJson (FO.Object a) where
-  decodeJson =
-    lmap ("Couldn't decode ForeignObject: " <> _)
-      <<< (traverse decodeJson <=< decodeJObject)
+  decodeJson = decodeForeignObject decodeJson
 
 instance decodeArray :: DecodeJson a => DecodeJson (Array a) where
-  decodeJson =
-    lmap ("Couldn't decode Array (" <> _)
-      <<< (traverseWithIndex f <=< decodeJArray)
-    where
-    msg i m = "Failed at index " <> show i <> "): " <> m
-    f i = lmap (msg i) <<< decodeJson
+  decodeJson = decodeArray decodeJson
 
 instance decodeList :: DecodeJson a => DecodeJson (List a) where
-  decodeJson =
-    lmap ("Couldn't decode List: " <> _)
-      <<< (traverse decodeJson <=< map (map fromFoldable) decodeJArray)
+  decodeJson = decodeList decodeJson
 
 instance decodeSet :: (Ord a, DecodeJson a) => DecodeJson (S.Set a) where
-  decodeJson = map (S.fromFoldable :: List a -> S.Set a) <<< decodeJson
+  decodeJson = decodeSet decodeJson
 
 instance decodeMap :: (Ord a, DecodeJson a, DecodeJson b) => DecodeJson (M.Map a b) where
-  decodeJson = map (M.fromFoldable :: List (Tuple a b) -> M.Map a b) <<< decodeJson
+  decodeJson = decodeMap decodeJson decodeJson
 
 instance decodeVoid :: DecodeJson Void where
-  decodeJson _ = Left "Value cannot be Void"
-
-decodeJArray :: Json -> Either String (Array Json)
-decodeJArray = maybe (Left "Value is not an Array") Right <<< toArray
-
-decodeJObject :: Json -> Either String (FO.Object Json)
-decodeJObject = maybe (Left "Value is not an Object") Right <<< toObject
+  decodeJson = decodeVoid
 
 instance decodeRecord
   :: ( GDecodeJson row list
@@ -178,9 +128,3 @@ instance gDecodeJsonCons
 
       Nothing ->
         Left $ "JSON was missing expected field: " <> fieldName
-
-elaborateFailure :: ∀ a. String -> Either String a -> Either String a
-elaborateFailure s e =
-  lmap msg e
-  where
-    msg m = "Failed to decode key '" <> s <> "': " <> m

src/Data/Argonaut/Decode/Combinators.purs

@@ -15,25 +15,22 @@ module Data.Argonaut.Decode.Combinators
   , (.?=)
   ) where
 
-import Prelude
+import Prelude ((<$>))
 
-import Data.Argonaut.Core (Json, isNull)
-import Data.Argonaut.Decode.Class (class DecodeJson, decodeJson, elaborateFailure)
-import Data.Either (Either(..))
-import Data.Maybe (Maybe(..), fromMaybe, maybe)
+import Data.Argonaut.Core (Json)
+import Data.Argonaut.Decode.Class (class DecodeJson, decodeJson)
+import Data.Either (Either)
+import Data.Maybe (Maybe, fromMaybe)
 import Foreign.Object as FO
 import Prim.TypeError (class Warn, Text)
+import Data.Argonaut.Decode.Decoders as Decoders
 
 -- | Attempt to get the value for a given key on an `Object Json`.
 -- |
 -- | Use this accessor if the key and value *must* be present in your object.
 -- | If the key and value are optional, use `getFieldOptional'` (`.:?`) instead.
 getField :: forall a. DecodeJson a => FO.Object Json -> String -> Either String a
-getField o s =
-  maybe
-    (Left $ "Expected field " <> show s)
-    (elaborateFailure s <<< decodeJson)
-    (FO.lookup s o)
+getField = Decoders.getField decodeJson
 
 infix 7 getField as .:
 
@@ -55,16 +52,7 @@ infix 7 getFieldDeprecated as .?
 -- | Use this accessor if the key and value are optional in your object.
 -- | If the key and value are mandatory, use `getField` (`.:`) instead.
 getFieldOptional' :: forall a. DecodeJson a => FO.Object Json -> String -> Either String (Maybe a)
-getFieldOptional' o s =
-  maybe
-    (pure Nothing)
-    decode
-    (FO.lookup s o)
-  where
-    decode json =
-      if isNull json
-        then pure Nothing
-        else Just <$> (elaborateFailure s <<< decodeJson) json
+getFieldOptional' = Decoders.getFieldOptional' decodeJson
 
 infix 7 getFieldOptional' as .:?
 
@@ -77,13 +65,7 @@ infix 7 getFieldOptional' as .:?
 -- | If you would like to treat `null` values the same as absent values, use
 -- | `getFieldOptional'` (`.:?`) instead.
 getFieldOptional :: forall a. DecodeJson a => FO.Object Json -> String -> Either String (Maybe a)
-getFieldOptional o s =
-  maybe
-    (pure Nothing)
-    decode
-    (FO.lookup s o)
-  where
-    decode json = Just <$> (elaborateFailure s <<< decodeJson) json
+getFieldOptional = Decoders.getFieldOptional decodeJson
 
 infix 7 getFieldOptional as .:!
 
@@ -93,7 +75,7 @@ getFieldOptionalDeprecated
   => FO.Object Json
   -> String
   -> Either String (Maybe a)
-getFieldOptionalDeprecated = getFieldOptional
+getFieldOptionalDeprecated = Decoders.getFieldOptional decodeJson
 
 infix 7 getFieldOptionalDeprecated as .??