Skip to content

Commit c1e9278

Browse files
garybgaryb
committed
Fix warnings
1 parent 8c7eb94 commit c1e9278

File tree

3 files changed

+68
-108
lines changed

3 files changed

+68
-108
lines changed

‎src/Data/Argonaut/Combinators.purs

Lines changed: 4 additions & 12 deletions
Original file line numberDiff line numberDiff line change
@@ -7,22 +7,14 @@ module Data.Argonaut.Combinators
77

88
import Prelude
99

10-
import Data.Argonaut.Core
11-
( foldJsonObject
12-
, fromObject
13-
, jsonSingletonObject
14-
, Json()
15-
, JAssoc()
16-
, JObject()
17-
)
18-
import Data.Argonaut.Encode (encodeJson, EncodeJson)
10+
import Data.Argonaut.Core (foldJsonObject, fromObject, jsonSingletonObject, Json(), JAssoc(), JObject())
1911
import Data.Argonaut.Decode (DecodeJson, decodeJson)
12+
import Data.Argonaut.Encode (encodeJson, EncodeJson)
2013
import Data.Either (Either(..))
2114
import Data.Maybe (Maybe(..), maybe)
15+
import Data.StrMap as M
2216
import Data.Tuple (Tuple(..))
2317

24-
import qualified Data.StrMap as M
25-
2618
infix 7 :=
2719
infix 7 .?
2820
infixr 6 ~>
@@ -34,7 +26,7 @@ infixl 1 ?>>=
3426
(~>) :: forall a. (EncodeJson a) => JAssoc -> a -> Json
3527
(~>) (Tuple k v) a = foldJsonObject (jsonSingletonObject k v) (M.insert k v >>> fromObject) (encodeJson a)
3628

37-
(?>>=) :: forall a b. Maybe a -> String -> Either String a
29+
(?>>=) :: forall a. Maybe a -> String -> Either String a
3830
(?>>=) (Just x) _ = Right x
3931
(?>>=) _ str = Left $ "Couldn't decode " ++ str
4032

‎src/Data/Argonaut/Decode.purs

Lines changed: 49 additions & 66 deletions
Original file line numberDiff line numberDiff line change
@@ -6,39 +6,23 @@ module Data.Argonaut.Decode
66
, decodeMaybe
77
) where
88

9-
import Prelude
10-
11-
import Data.Argonaut.Core
12-
( Json()
13-
, JNumber()
14-
, JString()
15-
, foldJsonNull
16-
, foldJsonBoolean
17-
, foldJsonNumber
18-
, foldJsonString
19-
, foldJsonArray
20-
, foldJsonObject
21-
, toArray
22-
, toNumber
23-
, toObject
24-
, toString
25-
, toBoolean
26-
)
9+
import Prelude
10+
11+
import Control.Alt ((<|>))
12+
import Control.Bind ((=<<))
13+
import Data.Argonaut.Core (Json(), foldJsonNull, foldJsonBoolean, foldJsonNumber, foldJsonString, toArray, toNumber, toObject, toString, toBoolean)
2714
import Data.Array (zipWithA)
2815
import Data.Either (either, Either(..))
16+
import Data.Foldable (find)
17+
import Data.Generic (Generic, GenericSpine(..), GenericSignature(..), Proxy(..), fromSpine, toSignature)
2918
import Data.Int (fromNumber)
30-
import Data.Maybe (maybe, Maybe(..))
31-
import Data.Tuple (Tuple(..))
32-
import Data.String
3319
import Data.List (List(..), toList)
34-
import Control.Alt
35-
import Control.Bind ((=<<))
20+
import Data.Map as Map
21+
import Data.Maybe (maybe, Maybe(..))
22+
import Data.String (charAt, toChar)
23+
import Data.StrMap as M
3624
import Data.Traversable (traverse, for)
37-
import Data.Foldable (find)
38-
import Data.Generic
39-
40-
import qualified Data.StrMap as M
41-
import qualified Data.Map as Map
25+
import Data.Tuple (Tuple(..))
4226

4327
class DecodeJson a where
4428
decodeJson :: Json -> Either String a
@@ -51,61 +35,60 @@ gDecodeJson json = maybe (Left "fromSpine failed") Right <<< fromSpine
5135
-- | Decode `Json` representation of a `GenericSpine`.
5236
gDecodeJson' :: GenericSignature -> Json -> Either String GenericSpine
5337
gDecodeJson' signature json = case signature of
54-
SigNumber
55-
-> SNumber <$> mFail "Expected a number" (toNumber json)
56-
SigInt
57-
-> SInt <$> mFail "Expected an integer number" (fromNumber =<< toNumber json)
58-
SigString
59-
-> SString <$> mFail "Expected a string" (toString json)
60-
SigBoolean
61-
-> SBoolean <$> mFail "Expected a boolean" (toBoolean json)
62-
SigArray thunk
63-
-> do jArr <- mFail "Expected an array" $ toArray json
64-
SArray <$> traverse (map const <<< gDecodeJson' (thunk unit)) jArr
65-
SigRecord props
66-
-> do jObj <- mFail "Expected an object" $ toObject json
67-
SRecord <$> for props \({recLabel: lbl, recValue: val})
68-
-> do pf <- mFail ("'" <> lbl <> "' property missing") (M.lookup lbl jObj)
69-
sp <- gDecodeJson' (val unit) pf
70-
pure { recLabel: lbl, recValue: const sp }
71-
SigProd alts
72-
-> do jObj <- mFail "Expected an object" $ toObject json
73-
tag <- mFail "'tag' string property is missing" (toString =<< M.lookup "tag" jObj)
74-
case find ((tag ==) <<< _.sigConstructor) alts of
75-
Nothing -> Left ("'" <> tag <> "' isn't a valid constructor")
76-
Just { sigValues: sigValues } -> do
77-
vals <- mFail "'values' array is missing" (toArray =<< M.lookup "values" jObj)
78-
sps <- zipWithA (\k -> gDecodeJson' (k unit)) sigValues vals
79-
pure (SProd tag (const <$> sps))
38+
SigNumber -> SNumber <$> mFail "Expected a number" (toNumber json)
39+
SigInt -> SInt <$> mFail "Expected an integer number" (fromNumber =<< toNumber json)
40+
SigString -> SString <$> mFail "Expected a string" (toString json)
41+
SigChar -> SChar <$> mFail "Expected a char" (toChar =<< toString json)
42+
SigBoolean -> SBoolean <$> mFail "Expected a boolean" (toBoolean json)
43+
SigArray thunk -> do
44+
jArr <- mFail "Expected an array" $ toArray json
45+
SArray <$> traverse (map const <<< gDecodeJson' (thunk unit)) jArr
46+
SigRecord props -> do
47+
jObj <- mFail "Expected an object" $ toObject json
48+
SRecord <$> for props \({recLabel: lbl, recValue: val}) -> do
49+
pf <- mFail ("'" <> lbl <> "' property missing") (M.lookup lbl jObj)
50+
sp <- gDecodeJson' (val unit) pf
51+
pure { recLabel: lbl, recValue: const sp }
52+
SigProd alts -> do
53+
jObj <- mFail "Expected an object" $ toObject json
54+
tag <- mFail "'tag' string property is missing" (toString =<< M.lookup "tag" jObj)
55+
case find ((tag ==) <<< _.sigConstructor) alts of
56+
Nothing -> Left ("'" <> tag <> "' isn't a valid constructor")
57+
Just { sigValues: sigValues } -> do
58+
vals <- mFail "'values' array is missing" (toArray =<< M.lookup "values" jObj)
59+
sps <- zipWithA (\k -> gDecodeJson' (k unit)) sigValues vals
60+
pure (SProd tag (const <$> sps))
8061
where
81-
mFail :: forall a. String -> Maybe a -> Either String a
82-
mFail msg = maybe (Left msg) Right
62+
mFail :: forall a. String -> Maybe a -> Either String a
63+
mFail msg = maybe (Left msg) Right
8364

8465
instance decodeJsonMaybe :: (DecodeJson a) => DecodeJson (Maybe a) where
8566
decodeJson j = (Just <$> decodeJson j) <|> pure Nothing
8667

8768
instance decodeJsonTuple :: (DecodeJson a, DecodeJson b) => DecodeJson (Tuple a b) where
88-
decodeJson j = decodeJson j >>= f where
69+
decodeJson j = decodeJson j >>= f
70+
where
8971
f (Cons a (Cons b Nil)) = Tuple <$> decodeJson a <*> decodeJson b
72+
f _ = Left "Couldn't decode Tuple"
9073

9174
instance decodeJsonEither :: (DecodeJson a, DecodeJson b) => DecodeJson (Either a b) where
9275
decodeJson j = (Left <$> decodeJson j) <|> (Right <$> decodeJson j)
9376

9477
instance decodeJsonNull :: DecodeJson Unit where
95-
decodeJson = foldJsonNull (Left "Not null.") (const $ Right unit)
78+
decodeJson = foldJsonNull (Left "Not null") (const $ Right unit)
9679

9780
instance decodeJsonBoolean :: DecodeJson Boolean where
98-
decodeJson = foldJsonBoolean (Left "Not a Boolean.") Right
81+
decodeJson = foldJsonBoolean (Left "Not a Boolean") Right
9982

10083
instance decodeJsonNumber :: DecodeJson Number where
101-
decodeJson = foldJsonNumber (Left "Not a Number.") Right
84+
decodeJson = foldJsonNumber (Left "Not a Number") Right
10285

10386
instance decodeJsonInt :: DecodeJson Int where
104-
decodeJson num = foldJsonNumber (Left "Not a Number.") go num
105-
where go num = maybe (Left "Not an Int") Right $ fromNumber num
87+
decodeJson num = foldJsonNumber (Left "Not a Number") go num
88+
where go num = maybe (Left "Not an Int") Right $ fromNumber num
10689

10790
instance decodeJsonString :: DecodeJson String where
108-
decodeJson = foldJsonString (Left "Not a String.") Right
91+
decodeJson = foldJsonString (Left "Not a String") Right
10992

11093
instance decodeJsonJson :: DecodeJson Json where
11194
decodeJson = Right
@@ -116,17 +99,17 @@ instance decodeJsonChar :: DecodeJson Char where
11699
go (Just c) = Right c
117100

118101
instance decodeStrMap :: (DecodeJson a) => DecodeJson (M.StrMap a) where
119-
decodeJson json = maybe (Left "Couldn't decode.") Right $ do
102+
decodeJson json = maybe (Left "Couldn't decode StrMap") Right $ do
120103
obj <- toObject json
121104
traverse decodeMaybe obj
122105

123106
instance decodeArray :: (DecodeJson a) => DecodeJson (Array a) where
124-
decodeJson json = maybe (Left "Couldn't decode.") Right $ do
107+
decodeJson json = maybe (Left "Couldn't decode Array") Right $ do
125108
obj <- toArray json
126109
traverse decodeMaybe obj
127110

128111
instance decodeList :: (DecodeJson a) => DecodeJson (List a) where
129-
decodeJson json = maybe (Left "Couldn't decode.") Right $ do
112+
decodeJson json = maybe (Left "Couldn't decode List") Right $ do
130113
lst <- toList <$> toArray json
131114
traverse decodeMaybe lst
132115

‎src/Data/Argonaut/Encode.purs

Lines changed: 15 additions & 30 deletions
Original file line numberDiff line numberDiff line change
@@ -1,38 +1,23 @@
11
module Data.Argonaut.Encode
2-
( EncodeJson
3-
, encodeJson
4-
, gEncodeJson
5-
, gEncodeJson'
6-
) where
2+
( EncodeJson
3+
, encodeJson
4+
, gEncodeJson
5+
, gEncodeJson'
6+
) where
77

88
import Prelude
99

10-
import Data.Argonaut.Core
11-
( Json()
12-
, foldJsonObject
13-
, jsonNull
14-
, fromNull
15-
, fromBoolean
16-
, fromNumber
17-
, fromString
18-
, fromArray
19-
, fromObject
20-
, jsonEmptyArray
21-
, jsonEmptyObject
22-
, jsonSingletonObject
23-
)
24-
import Data.String (fromChar)
25-
import Data.Maybe
26-
import Data.Either
27-
import Data.List (List(..), fromList, toList)
10+
import Data.Argonaut.Core (Json(), jsonNull, fromBoolean, fromNumber, fromString, fromArray, fromObject)
11+
import Data.Either (Either(..))
12+
import Data.Foldable (foldr)
13+
import Data.Generic (Generic, GenericSpine(..), toSpine)
2814
import Data.Int (toNumber)
29-
import Data.Unfoldable ()
30-
import Data.Foldable (foldMap, foldr)
15+
import Data.List (List(..), fromList)
16+
import Data.Map as M
17+
import Data.Maybe (Maybe(..))
18+
import Data.String (fromChar)
19+
import Data.StrMap as SM
3120
import Data.Tuple (Tuple(..))
32-
import Data.Generic
33-
34-
import qualified Data.StrMap as SM
35-
import qualified Data.Map as M
3621

3722
class EncodeJson a where
3823
encodeJson :: a -> Json
@@ -46,6 +31,7 @@ gEncodeJson' :: GenericSpine -> Json
4631
gEncodeJson' spine = case spine of
4732
SInt x -> fromNumber $ toNumber x
4833
SString x -> fromString x
34+
SChar x -> fromString $ fromChar x
4935
SNumber x -> fromNumber x
5036
SBoolean x -> fromBoolean x
5137
SArray thunks -> fromArray (gEncodeJson' <<< (unit #) <$> thunks)
@@ -102,4 +88,3 @@ instance encodeStrMap :: (EncodeJson a) => EncodeJson (SM.StrMap a) where
10288

10389
instance encodeMap :: (Ord a, EncodeJson a, EncodeJson b) => EncodeJson (M.Map a b) where
10490
encodeJson = encodeJson <<< M.toList
105-

0 commit comments

Comments
 (0)