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

Author: srghma-old

src/Data/Argonaut/Decode/Class.purs

@@ -2,9 +2,8 @@ module Data.Argonaut.Decode.Class where
 
 import Prelude (class Ord, Unit, Void, bind, ($), (<<<), (<>))
 
-import Data.Argonaut.Core (Json, fromString, toObject)
+import Data.Argonaut.Core (Json, toObject)
 import Data.Array.NonEmpty (NonEmptyArray)
-import Data.Bifunctor (lmap)
 import Data.Either (Either(..))
 import Data.Identity (Identity)
 import Data.List (List)

src/Data/Argonaut/Decode/Implementation.purs

@@ -10,7 +10,7 @@ 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 (List, fromFoldable)
 import Data.List as L
 import Data.List.NonEmpty (NonEmptyList)
 import Data.List.NonEmpty as NEL

src/Data/Argonaut/Encode.purs

@@ -1,10 +1,11 @@
 module Data.Argonaut.Encode
   ( module Data.Argonaut.Encode.Class
   , module Data.Argonaut.Encode.Combinators
+  , module Data.Argonaut.Encode.Implementation
   ) where
 
 import Data.Argonaut.Encode.Class (class EncodeJson, encodeJson)
-import Data.Argonaut.Encode.Combinators 
+import Data.Argonaut.Encode.Combinators
   ( assoc
   , assocOptional
   , extend
@@ -14,3 +15,4 @@ import Data.Argonaut.Encode.Combinators
   , (~>)
   , (~>?)
   )
+import Data.Argonaut.Encode.Implementation (Encoder)

src/Data/Argonaut/Encode/Class.purs

@@ -1,109 +1,95 @@
 module Data.Argonaut.Encode.Class where
 
-import Prelude
+import Prelude (class Ord, Unit, Void, ($))
 
-import Data.Argonaut.Core (Json, fromArray, fromBoolean, fromNumber, fromObject, fromString, jsonNull)
-import Data.Array as Arr
+import Data.Argonaut.Core (Json, fromObject)
 import Data.Array.NonEmpty (NonEmptyArray)
-import Data.Array.NonEmpty as NEA
-import Data.Either (Either, either)
-import Data.Identity (Identity(..))
-import Data.Int (toNumber)
-import Data.List (List(..), (:), toUnfoldable)
-import Data.List as L
-import Data.List.NonEmpty as NEL
+import Data.Either (Either)
+import Data.Identity (Identity)
+import Data.List (List)
 import Data.List.Types (NonEmptyList)
 import Data.Map as M
-import Data.Maybe (Maybe(..))
-import Data.NonEmpty (NonEmpty(..))
+import Data.Maybe (Maybe)
+import Data.NonEmpty (NonEmpty)
 import Data.Set as S
 import Data.String (CodePoint)
-import Data.String.CodePoints as CP
-import Data.String.CodeUnits as CU
 import Data.Symbol (class IsSymbol, SProxy(..), reflectSymbol)
-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.Encode.Implementation
 
 class EncodeJson a where
-  encodeJson :: a -> Json
+  encodeJson :: Encoder a
 
 instance encodeIdentity :: EncodeJson a => EncodeJson (Identity a) where
-  encodeJson (Identity a) = encodeJson a
+  encodeJson = encodeIdentity encodeJson
 
 instance encodeJsonMaybe :: EncodeJson a => EncodeJson (Maybe a) where
-  encodeJson = case _ of
-    Nothing -> jsonNull
-    Just a -> encodeJson a
+  encodeJson = encodeJsonMaybe encodeJson
 
 instance encodeJsonTuple :: (EncodeJson a, EncodeJson b) => EncodeJson (Tuple a b) where
-  encodeJson (Tuple a b) = encodeJson [encodeJson a, encodeJson b]
+  encodeJson = encodeJsonTuple encodeJson encodeJson
 
 instance encodeJsonEither :: (EncodeJson a, EncodeJson b) => EncodeJson (Either a b) where
-  encodeJson = either (obj "Left") (obj "Right")
-    where
-    obj :: forall c. EncodeJson c => String -> c -> Json
-    obj tag x =
-      fromObject 
-        $ FO.fromFoldable 
-        $ Tuple "tag" (fromString tag) : Tuple "value" (encodeJson x) : Nil
+  encodeJson = encodeJsonEither encodeJson encodeJson
 
 instance encodeJsonUnit :: EncodeJson Unit where
-  encodeJson = const jsonNull
+  encodeJson = encodeJsonUnit
 
 instance encodeJsonJBoolean :: EncodeJson Boolean where
-  encodeJson = fromBoolean
+  encodeJson = encodeJsonJBoolean
 
 instance encodeJsonJNumber :: EncodeJson Number where
-  encodeJson = fromNumber
+  encodeJson = encodeJsonJNumber
 
 instance encodeJsonInt :: EncodeJson Int where
-  encodeJson = fromNumber <<< toNumber
+  encodeJson = encodeJsonInt
 
 instance encodeJsonJString :: EncodeJson String where
-  encodeJson = fromString
+  encodeJson = encodeJsonJString
 
 instance encodeJsonJson :: EncodeJson Json where
-  encodeJson = identity
+  encodeJson = encodeJsonJson
 
 instance encodeJsonCodePoint :: EncodeJson CodePoint where
-  encodeJson = encodeJson <<< CP.singleton
+  encodeJson = encodeJsonCodePoint
 
 instance encodeJsonNonEmpty_Array :: (EncodeJson a) => EncodeJson (NonEmpty Array a) where
-  encodeJson (NonEmpty h t) = encodeJson (Arr.cons h t)
+  encodeJson = encodeJsonNonEmpty_Array encodeJson
 
 instance encodeJsonNonEmptyArray :: (EncodeJson a) => EncodeJson (NonEmptyArray a) where
-  encodeJson = encodeJson <<< NEA.toArray
+  encodeJson = encodeJsonNonEmptyArray encodeJson
 
 instance encodeJsonNonEmpty_List :: (EncodeJson a) => EncodeJson (NonEmpty List a) where
-  encodeJson (NonEmpty h t) = encodeJson (L.insertAt 0 h t)
+  encodeJson = encodeJsonNonEmpty_List encodeJson
 
 instance encodeJsonNonEmptyList :: (EncodeJson a) => EncodeJson (NonEmptyList a) where
-  encodeJson = encodeJson <<< NEL.toList
+  encodeJson = encodeJsonNonEmptyList encodeJson
 
 instance encodeJsonChar :: EncodeJson Char where
-  encodeJson = encodeJson <<< CU.singleton
+  encodeJson = encodeJsonChar
 
 instance encodeJsonArray :: EncodeJson a => EncodeJson (Array a) where
-  encodeJson = fromArray <<< map encodeJson
+  encodeJson = encodeJsonArray encodeJson
 
 instance encodeJsonList :: EncodeJson a => EncodeJson (List a) where
-  encodeJson = fromArray <<< map encodeJson <<< toUnfoldable
+  encodeJson = encodeJsonList encodeJson
 
 instance encodeForeignObject :: EncodeJson a => EncodeJson (FO.Object a) where
-  encodeJson = fromObject <<< map encodeJson
+  encodeJson = encodeForeignObject encodeJson
 
 instance encodeSet :: (Ord a, EncodeJson a) => EncodeJson (S.Set a) where
-  encodeJson = encodeJson <<< (S.toUnfoldable :: S.Set a -> List a)
+  encodeJson = encodeSet encodeJson
 
 instance encodeMap :: (Ord a, EncodeJson a, EncodeJson b) => EncodeJson (M.Map a b) where
-  encodeJson = encodeJson <<< (M.toUnfoldable :: M.Map a b -> List (Tuple a b))
+  encodeJson = encodeMap encodeJson encodeJson
 
 instance encodeVoid :: EncodeJson Void where
-  encodeJson = absurd
+  encodeJson = encodeVoid
 
 instance encodeRecord
   :: ( GEncodeJson row list

src/Data/Argonaut/Encode/Combinators.purs

@@ -9,20 +9,19 @@
 -- | ```
 module Data.Argonaut.Encode.Combinators where
 
-import Prelude
 
-import Data.Argonaut.Core (Json, caseJsonObject, fromObject, jsonSingletonObject)
+import Data.Argonaut.Core (Json)
 import Data.Argonaut.Encode.Class (class EncodeJson, encodeJson)
-import Data.Maybe (Maybe(..))
-import Data.Tuple (Tuple(..))
-import Foreign.Object as FO
+import Data.Maybe (Maybe)
+import Data.Tuple (Tuple)
+import Data.Argonaut.Encode.Implementation as Implementation
 
 -- | Creates a `Tuple String Json` entry, representing a key/value pair for an object.
 infix 7 assoc as :=
 
 -- | The named implementation of the `(:=)` operator.
 assoc :: forall a. EncodeJson a => String -> a -> Tuple String Json
-assoc k = Tuple k <<< encodeJson
+assoc = Implementation.assoc encodeJson
 
 -- | Creates an optional `Tuple String Json` entry, representing an optional key/value pair for an object.
 infix 7 assocOptional as :=?
@@ -34,23 +33,18 @@ assocOptional
   => String
   -> Maybe a
   -> Maybe (Tuple String Json)
-assocOptional k = (<$>) (((:=) k) <<< encodeJson)
+assocOptional = Implementation.assocOptional encodeJson
 
 -- | Extends a Json object with a `Tuple String Json` property.
 infixr 6 extend as ~>
 
 -- | The named implementation of the `(~>)` operator.
 extend :: forall a. EncodeJson a => Tuple String Json -> a -> Json
-extend (Tuple k v) =
-  caseJsonObject
-    (jsonSingletonObject k v)
-    (FO.insert k v >>> fromObject)
-    <<< encodeJson
+extend = Implementation.extend encodeJson
 
 -- | Optionally extends a Json object with an optional `Tuple String Json` property.
 infixr 6 extendOptional as ~>?
 
 -- | The named implementation of the `(~>?)` operator.
 extendOptional :: forall a. EncodeJson a => Maybe (Tuple String Json) -> a -> Json
-extendOptional (Just kv) = (~>) kv
-extendOptional Nothing = encodeJson
+extendOptional = Implementation.extendOptional encodeJson

src/Data/Argonaut/Encode/Implementation.purs

@@ -0,0 +1,122 @@
+module Data.Argonaut.Encode.Implementation where
+
+import Prelude
+
+import Data.Argonaut.Core (Json, fromArray, fromBoolean, fromNumber, fromObject, fromString, jsonNull, caseJsonObject, jsonSingletonObject)
+import Data.Array as Arr
+import Data.Array.NonEmpty (NonEmptyArray)
+import Data.Array.NonEmpty as NEA
+import Data.Either (Either, either)
+import Data.Identity (Identity(..))
+import Data.Int (toNumber)
+import Data.List (List(..), (:), toUnfoldable)
+import Data.List.NonEmpty as NEL
+import Data.List.Types (NonEmptyList)
+import Data.Map as M
+import Data.Maybe (Maybe(..))
+import Data.NonEmpty (NonEmpty(..))
+import Data.Set as S
+import Data.String (CodePoint)
+import Data.String.CodePoints as CP
+import Data.String.CodeUnits as CU
+import Data.Tuple (Tuple(..))
+import Foreign.Object as FO
+
+type Encoder a = a -> Json
+
+encodeIdentity :: forall a . Encoder a -> Encoder (Identity a)
+encodeIdentity encoder (Identity a) = encoder a
+
+encodeJsonMaybe :: forall a . Encoder a -> Encoder (Maybe a)
+encodeJsonMaybe encoder = case _ of
+    Nothing -> jsonNull
+    Just a -> encoder a
+
+encodeJsonTuple :: forall a b . Encoder a -> Encoder b -> Encoder (Tuple a b)
+encodeJsonTuple encoderA encoderB (Tuple a b) = fromArray [encoderA a, encoderB b]
+
+encodeJsonEither :: forall a b . Encoder a -> Encoder b -> Encoder (Either a b)
+encodeJsonEither encoderA encoderB = either (obj encoderA "Left") (obj encoderB "Right")
+    where
+    obj :: forall c. Encoder c -> String -> c -> Json
+    obj encoder tag x =
+      fromObject
+        $ FO.fromFoldable
+        $ Tuple "tag" (fromString tag) : Tuple "value" (encoder x) : Nil
+
+encodeJsonUnit :: Encoder Unit
+encodeJsonUnit = const jsonNull
+
+encodeJsonJBoolean :: Encoder Boolean
+encodeJsonJBoolean = fromBoolean
+
+encodeJsonJNumber :: Encoder Number
+encodeJsonJNumber = fromNumber
+
+encodeJsonInt :: Encoder Int
+encodeJsonInt = fromNumber <<< toNumber
+
+encodeJsonJString :: Encoder String
+encodeJsonJString = fromString
+
+encodeJsonJson :: Encoder Json
+encodeJsonJson = identity
+
+encodeJsonCodePoint :: Encoder CodePoint
+encodeJsonCodePoint = encodeJsonJString <<< CP.singleton
+
+encodeJsonNonEmpty_Array :: forall a . (Encoder a) -> Encoder (NonEmpty Array a)
+encodeJsonNonEmpty_Array encoder (NonEmpty h t) = encodeJsonArray encoder (Arr.cons h t)
+
+encodeJsonNonEmptyArray :: forall a . (Encoder a) -> Encoder (NonEmptyArray a)
+encodeJsonNonEmptyArray encoder = encodeJsonArray encoder <<< NEA.toArray
+
+encodeJsonNonEmpty_List :: forall a . (Encoder a) -> Encoder (NonEmpty List a)
+encodeJsonNonEmpty_List encoder (NonEmpty h t) = encodeJsonList encoder (h : t)
+
+encodeJsonNonEmptyList :: forall a . (Encoder a) -> Encoder (NonEmptyList a)
+encodeJsonNonEmptyList encoder = encodeJsonList encoder <<< NEL.toList
+
+encodeJsonChar :: Encoder Char
+encodeJsonChar = encodeJsonJString <<< CU.singleton
+
+encodeJsonArray :: forall a . Encoder a -> Encoder (Array a)
+encodeJsonArray encoder = fromArray <<< map encoder
+
+encodeJsonList :: forall a . Encoder a -> Encoder (List a)
+encodeJsonList encoder = fromArray <<< map encoder <<< toUnfoldable
+
+encodeForeignObject :: forall a . Encoder a -> Encoder (FO.Object a)
+encodeForeignObject encoder = fromObject <<< map encoder
+
+encodeSet :: forall a . (Ord a) => Encoder a -> Encoder (S.Set a)
+encodeSet encoder = encodeJsonList encoder <<< (S.toUnfoldable :: S.Set a -> List a)
+
+encodeMap :: forall a b . (Ord a) => Encoder a -> Encoder b -> Encoder (M.Map a b)
+encodeMap encoderA encoderB = encodeJsonList (encodeJsonTuple encoderA encoderB) <<< (M.toUnfoldable :: M.Map a b -> List (Tuple a b))
+
+encodeVoid :: Encoder Void
+encodeVoid = absurd
+
+assoc :: forall a. Encoder a -> String -> a -> Tuple String Json
+assoc encoder k = Tuple k <<< encoder
+
+assocOptional
+  :: forall a
+   . Encoder a
+  -> String
+  -> Maybe a
+  -> Maybe (Tuple String Json)
+assocOptional encoder k = (<$>) (Tuple k <<< encoder)
+
+extend :: forall a. Encoder a -> Tuple String Json -> a -> Json
+extend encoder (Tuple k v) =
+  caseJsonObject
+    (jsonSingletonObject k v)
+    (FO.insert k v >>> fromObject)
+    <<< encoder
+
+-- | The named implementation of the `(~>?)` operator.
+extendOptional :: forall a. Encoder a -> Maybe (Tuple String Json) -> a -> Json
+extendOptional encoder (Just kv) = extend encoder kv
+extendOptional encoder Nothing = encoder