Add missing common types

Author: garyb

src/Data/Codec/Argonaut/Common.purs

@@ -1,21 +1,48 @@
 module Data.Codec.Argonaut.Common
-  ( module Data.Codec.Argonaut.Common
+  ( nonEmptyString
+  , nonEmptyArray
+  , maybe
+  , tuple
+  , either
+  , list
+  , nonEmptyList
+  , map
+  , set
+  , nonEmptySet
+  , foreignObject
   , module Data.Codec.Argonaut
   ) where
 
-import Prelude hiding (map)
+import Prelude hiding (map, void)
 
-import Data.Array as A
-import Data.Codec.Argonaut (JIndexedCodec, JPropCodec, JsonCodec, JsonDecodeError(..), array, boolean, char, decode, encode, fix, index, indexedArray, int, jarray, jobject, json, null, number, object, printJsonDecodeError, prop, record, recordProp, recordPropOptional, string, (<~<), (~))
+import Data.Array as Array
+import Data.Array.NonEmpty as NEA
+import Data.Codec.Argonaut (JIndexedCodec, JPropCodec, JsonCodec, JsonDecodeError(..), array, boolean, char, codePoint, coercible, decode, encode, fix, index, indexedArray, int, jarray, jobject, json, named, null, number, object, printJsonDecodeError, prismaticCodec, prop, record, recordProp, recordPropOptional, string, void, (<~<), (>~>), (~))
 import Data.Codec.Argonaut.Sum (taggedSum)
 import Data.Either (Either(..))
 import Data.Functor as F
-import Data.List as L
-import Data.Map as M
+import Data.List as List
+import Data.List.NonEmpty as NEL
+import Data.Map as Map
 import Data.Maybe (Maybe(..))
 import Data.Profunctor (dimap)
+import Data.Set as Set
+import Data.Set.NonEmpty as NESet
+import Data.String.NonEmpty as NEString
 import Data.Tuple (Tuple(..), fst, snd)
-import Foreign.Object as FO
+import Foreign.Object as Object
+
+-- | A codec for `NonEmptyString` values.
+-- |
+-- | Encodes as the standard type in JSON, but will fail to decode if the string is empty.
+nonEmptyString ∷ JsonCodec NEString.NonEmptyString
+nonEmptyString = prismaticCodec "NonEmptyString" NEString.fromString NEString.toString string
+
+-- | A codec for `NonEmptyArray` values.
+-- |
+-- | Encodes as the standard type in JSON, but will fail to decode if the array is empty.
+nonEmptyArray ∷ ∀ a. JsonCodec a → JsonCodec (NEA.NonEmptyArray a)
+nonEmptyArray codec = prismaticCodec "NonEmptyArray" NEA.fromArray NEA.toArray (array codec)
 
 -- | A codec for `Maybe` values.
 -- |
@@ -68,17 +95,35 @@ either codecA codecB = taggedSum "Either" printTag parseTag dec enc
 -- | A codec for `List` values.
 -- |
 -- | Encodes as an array in JSON.
-list ∷ ∀ a. JsonCodec a → JsonCodec (L.List a)
-list = dimap A.fromFoldable L.fromFoldable <<< array
+list ∷ ∀ a. JsonCodec a → JsonCodec (List.List a)
+list codec = dimap Array.fromFoldable List.fromFoldable (named "List" (array codec))
+
+-- | A codec for `NonEmptyList` values.
+-- |
+-- | Encodes as an array in JSON.
+nonEmptyList ∷ ∀ a. JsonCodec a → JsonCodec (NEL.NonEmptyList a)
+nonEmptyList codec = prismaticCodec "NonEmptyList" NEL.fromFoldable Array.fromFoldable (array codec)
 
 -- | A codec for `Map` values.
 -- |
 -- | Encodes as an array of two-element key/value arrays in JSON.
-map ∷ ∀ a b. Ord a ⇒ JsonCodec a → JsonCodec b → JsonCodec (M.Map a b)
-map codecA = dimap M.toUnfoldable M.fromFoldable <<< array <<< tuple codecA
+map ∷ ∀ a b. Ord a ⇒ JsonCodec a → JsonCodec b → JsonCodec (Map.Map a b)
+map codecA codecB = dimap Map.toUnfoldable (Map.fromFoldable) (named "Map" (array (tuple codecA codecB)))
+
+-- | A codec for `Set` values.
+-- |
+-- | Encodes as an array in JSON.
+set ∷ ∀ a. Ord a ⇒ JsonCodec a → JsonCodec (Set.Set a)
+set codec = dimap Array.fromFoldable Set.fromFoldable (named "Set" (array codec))
+
+-- | A codec for `NonEmptySet` values.
+-- |
+-- | Encodes as an array in JSON.
+nonEmptySet ∷ ∀ a. Ord a ⇒ JsonCodec a → JsonCodec (NESet.NonEmptySet a)
+nonEmptySet codec = prismaticCodec "NonEmptySet" NESet.fromFoldable NESet.toUnfoldable (array codec)
 
 -- | A codec for `StrMap` values.
 -- |
 -- | Encodes as an array of two-element key/value arrays in JSON.
-foreignObject ∷ ∀ a. JsonCodec a → JsonCodec (FO.Object a)
-foreignObject = dimap FO.toUnfoldable FO.fromFoldable <<< array <<< tuple string
+foreignObject ∷ ∀ a. JsonCodec a → JsonCodec (Object.Object a)
+foreignObject = dimap Object.toUnfoldable Object.fromFoldable <<< array <<< tuple string

src/Data/Codec/Argonaut/Compat.purs

@@ -1,17 +1,15 @@
 -- | Codecs that are compatible with `purescript-argonaut-codecs`.
 module Data.Codec.Argonaut.Compat
   ( module Data.Codec.Argonaut.Compat
-  , module Data.Codec.Argonaut
-  , module Common
+  , module Data.Codec.Argonaut.Common
   ) where
 
-import Prelude
+import Prelude hiding (void)
 
 import Data.Argonaut.Core as J
 import Data.Bifunctor as BF
 import Data.Codec (basicCodec, mapCodec)
-import Data.Codec.Argonaut (JIndexedCodec, JPropCodec, JsonCodec, JsonDecodeError(..), array, boolean, char, decode, encode, fix, index, indexedArray, int, jarray, jobject, json, null, number, object, printJsonDecodeError, prop, record, recordProp, recordPropOptional, string, (<~<), (~))
-import Data.Codec.Argonaut.Common (either, list, map, tuple) as Common
+import Data.Codec.Argonaut.Common (JIndexedCodec, JPropCodec, JsonCodec, JsonDecodeError(..), array, boolean, char, codePoint, coercible, decode, either, encode, fix, index, indexedArray, int, jarray, jobject, json, list, named, nonEmptyArray, nonEmptyList, nonEmptySet, nonEmptyString, null, number, object, printJsonDecodeError, prismaticCodec, prop, record, recordProp, recordPropOptional, set, string, tuple, void, (<~<), (>~>), (~))
 import Data.Either (Either)
 import Data.Functor as F
 import Data.Maybe (Maybe(..))