avro 0.4.6.0 → 0.4.7.0

raw patch · 30 files changed

+1215/−207 lines, 30 filesdep +HasBigDecimaldep +timedep +uuidPVP: major bump suggested

API removals or changes: PVP suggests a major version bump

Dependencies added: HasBigDecimal, time, uuid

API changes (from Hackage documentation)

Files

• README.md +4/−0
• avro.cabal +12/−1
• bench/Bench/Time.hs +6/−6
• src/Data/Avro/Decode/Lazy.hs +10/−10
• src/Data/Avro/Decode/Lazy/Deconflict.hs +9/−9
• src/Data/Avro/Decode/Lazy/FromLazyAvro.hs +35/−0
• src/Data/Avro/Decode/Strict/Internal.hs +10/−10
• src/Data/Avro/Deconflict.hs +9/−9
• src/Data/Avro/Deriving.hs +39/−22
• src/Data/Avro/Deriving/Lift.hs +6/−0
• src/Data/Avro/EitherN.hs +576/−0
• src/Data/Avro/Encode.hs +34/−11
• src/Data/Avro/FromAvro.hs +35/−1
• src/Data/Avro/HasAvroSchema.hs +50/−26
• src/Data/Avro/Schema.hs +195/−66
• src/Data/Avro/ToAvro.hs +25/−0
• src/Data/Avro/Types/Decimal.hs +33/−0
• src/Data/Avro/Types/Time.hs +28/−0
• src/Data/Avro/Types/Value.hs +1/−1
• test/Avro/Codec/Int64Spec.hs +1/−1
• test/Avro/Codec/NestedSpec.hs +3/−3
• test/Avro/Codec/TextSpec.hs +1/−1
• test/Avro/DefaultsSpec.hs +1/−1
• test/Avro/JSONSpec.hs +19/−3
• test/Avro/THUnionSpec.hs +42/−18
• test/Avro/ToAvroSpec.hs +4/−4
• test/Example1.hs +2/−2
• test/data/unions-object-a.json +7/−1
• test/data/unions-object-b.json +11/−0
• test/data/unions.avsc +7/−1

@@ -1,5 +1,8 @@ # Native Haskell implementation of Avro +[![CircleCI](https://circleci.com/gh/haskell-works/avro.svg?style=svg)](https://circleci.com/gh/haskell-works/avro)+[![Hackage](https://img.shields.io/hackage/v/avro.svg?logo=haskell)](https://hackage.haskell.org/package/avro)+ This is a Haskell [Avro](https://avro.apache.org/) library useful for decoding and encoding Avro data structures.  Avro can be thought of as a serialization format and RPC specification which induces three separable tasks:@@ -26,6 +29,7 @@ | ByteString        | "bytes"                         | | Maybe a           | ["null", "a"]                   | | Either a b        | ["a", "b"]                      |+| Identity a        | ["a"]                           | | Map Text a        | {"type": "map", "value": "a"}   | | Map String a      | {"type": "map", "value": "a"}   | | HashMap Text a    | {"type": "map", "value": "a"}   |

@@ -1,7 +1,7 @@ cabal-version: 2.2  name:                   avro-version:                0.4.6.0+version:                0.4.7.0 synopsis:               Avro serialization support for Haskell description:            Avro serialization and deserialization support for Haskell category:               Data@@ -55,6 +55,7 @@ common avro                     { build-depends: avro                                               } common base16-bytestring        { build-depends: base16-bytestring                                  } common bifunctors               { build-depends: bifunctors                                         }+common big-decimal              { build-depends: HasBigDecimal                                      } common binary                   { build-depends: binary                                             } common bytestring               { build-depends: bytestring                                         } common containers               { build-depends: containers                                         }@@ -78,9 +79,11 @@ common semigroups               { build-depends: semigroups                                         } common tagged                   { build-depends: tagged                                             } common text                     { build-depends: text                     >= 1.2.3      && < 1.3    }+common time                     { build-depends: time                                               } common tf-random                { build-depends: tf-random                                          } common transformers             { build-depends: transformers                                       } common unordered-containers     { build-depends: unordered-containers                               }+common uuid                     { build-depends: uuid                                               } common vector                   { build-depends: vector                                             } common zlib                     { build-depends: zlib                                               } @@ -98,6 +101,7 @@                       , array                       , base16-bytestring                       , bifunctors+                      , big-decimal                       , binary                       , bytestring                       , containers@@ -111,8 +115,10 @@                       , semigroups                       , tagged                       , text+                      , time                       , tf-random                       , unordered-containers+                      , uuid                       , vector                       , zlib   exposed-modules:      Data.Avro@@ -140,9 +146,11 @@                         Data.Avro.Schema                         Data.Avro.ToAvro                         Data.Avro.Types+                        Data.Avro.Types.Decimal                         Data.Avro.Types.Value                         Data.Avro.Zag                         Data.Avro.Zig+  other-modules:        Data.Avro.Types.Time   hs-source-dirs:       src   other-extensions:     OverloadedStrings @@ -153,6 +161,7 @@                       , avro                       , base16-bytestring                       , bifunctors+                      , big-decimal                       , binary                       , bytestring                       , containers@@ -172,8 +181,10 @@                       , tagged                       , text                       , tf-random+                      , time                       , transformers                       , unordered-containers+                      , uuid                       , vector   type:                 exitcode-stdio-1.0   ghc-options:          -threaded

@@ -61,8 +61,8 @@           ]         recordSchema = Schema.Record "Rec" [] Nothing Nothing           [ Schema.Field "b" [] Nothing Nothing Schema.Boolean Nothing-          , Schema.Field "i" [] Nothing Nothing Schema.Int Nothing-          , Schema.Field "l" [] Nothing Nothing Schema.Long Nothing+          , Schema.Field "i" [] Nothing Nothing Schema.Int' Nothing+          , Schema.Field "l" [] Nothing Nothing Schema.Long' Nothing           ]  encodeAvro :: Value Schema -> LBS.ByteString@@ -79,9 +79,9 @@   [ bench "bools" $       nf (decodeAvro $ Schema.Array Schema.Boolean) bools   , bench "ints" $-      nf (decodeAvro $ Schema.Array Schema.Int) ints+      nf (decodeAvro $ Schema.Array Schema.Int') ints   , bench "longs" $-      nf (decodeAvro $ Schema.Array Schema.Long) longs+      nf (decodeAvro $ Schema.Array Schema.Long') longs   , bench "records" $       nf (decodeAvro $ Schema.Array recordSchema) records   ]@@ -107,8 +107,8 @@           ]         recordSchema = Schema.Record "Rec" [] Nothing Nothing           [ Schema.Field "b" [] Nothing Nothing Schema.Boolean Nothing-          , Schema.Field "i" [] Nothing Nothing Schema.Int Nothing-          , Schema.Field "l" [] Nothing Nothing Schema.Long Nothing+          , Schema.Field "i" [] Nothing Nothing Schema.Int' Nothing+          , Schema.Field "l" [] Nothing Nothing Schema.Long' Nothing           ]  decodeAvro :: Schema -> LBS.ByteString -> Value Schema

@@ -294,16 +294,16 @@   go :: Schema -> BL.ByteString -> (BL.ByteString, T.LazyValue Schema)   go ty bs =     case ty of-      Null    -> (bs, T.Null)-      Boolean -> decodeGet T.Boolean  bs-      Int     -> decodeGet T.Int      bs-      Long    -> decodeGet T.Long     bs-      Float   -> decodeGet T.Float    bs-      Double  -> decodeGet T.Double   bs-      Bytes   -> decodeGet T.Bytes    bs-      String  -> decodeGet T.String   bs-      Array t -> T.Array . V.fromList . mconcat <$> getElements bs (go t)-      Map t   -> T.Map . HashMap.fromList . mconcat <$> getKVPairs bs (go t)+      Null     -> (bs, T.Null)+      Boolean  -> decodeGet T.Boolean  bs+      Int _    -> decodeGet T.Int      bs+      Long _   -> decodeGet T.Long     bs+      Float    -> decodeGet T.Float    bs+      Double   -> decodeGet T.Double   bs+      Bytes _  -> decodeGet T.Bytes    bs+      String _ -> decodeGet T.String   bs+      Array t  -> T.Array . V.fromList . mconcat <$> getElements bs (go t)+      Map t    -> T.Map . HashMap.fromList . mconcat <$> getKVPairs bs (go t)       NamedType tn ->         case runGetOrFail (env tn) bs of           Left (bs', _, err) -> (bs', T.Error err)

@@ -78,15 +78,15 @@         withSchemaIn tyVal xs $ \sch -> deconflictValue sch nonUnion val     go eTy dTy val =       case val of-        T.Int i32  | dTy == S.Long   -> T.Long   (fromIntegral i32)-                   | dTy == S.Float  -> T.Float  (fromIntegral i32)-                   | dTy == S.Double -> T.Double (fromIntegral i32)-        T.Long i64 | dTy == S.Float  -> T.Float (fromIntegral i64)-                   | dTy == S.Double -> T.Double (fromIntegral i64)-        T.Float f  | dTy == S.Double -> T.Double (realToFrac f)-        T.String s | dTy == S.Bytes  -> T.Bytes (Text.encodeUtf8 s)-        T.Bytes bs | dTy == S.String -> T.String (Text.decodeUtf8 bs)-        _                            -> T.Error $ "Can not resolve differing writer and reader schemas: " ++ show (eTy, dTy)+        T.Int i32  | S.Long _ <- dTy   -> T.Long   (fromIntegral i32)+                   | dTy == S.Float    -> T.Float  (fromIntegral i32)+                   | dTy == S.Double   -> T.Double (fromIntegral i32)+        T.Long i64 | dTy == S.Float    -> T.Float (fromIntegral i64)+                   | dTy == S.Double   -> T.Double (fromIntegral i64)+        T.Float f  | dTy == S.Double   -> T.Double (realToFrac f)+        T.String s | S.Bytes _ <- dTy  -> T.Bytes (Text.encodeUtf8 s)+        T.Bytes bs | S.String _ <- dTy -> T.String (Text.decodeUtf8 bs)+        _                              -> T.Error $ "Can not resolve differing writer and reader schemas: " ++ show (eTy, dTy)  -- The writer's symbol must be present in the reader's enum deconflictEnum :: Schema -> Schema -> T.LazyValue Schema -> T.LazyValue Schema

@@ -6,11 +6,14 @@  where +import           Control.Monad.Identity          (Identity(..)) import           Control.Arrow                   (first) import           Data.Avro.Decode.Lazy.LazyValue as T import qualified Data.Avro.Encode                as E import           Data.Avro.HasAvroSchema import           Data.Avro.Schema                as S+import           Data.Avro.Types.Decimal         as D+import           Data.Avro.Types.Time import qualified Data.ByteString                 as B import           Data.ByteString.Lazy            (ByteString) import qualified Data.ByteString.Lazy            as BL@@ -24,9 +27,12 @@ import           Data.Text                       (Text) import qualified Data.Text                       as Text import qualified Data.Text.Lazy                  as TL+import qualified Data.Time                       as Time+import qualified Data.UUID                       as UUID import qualified Data.Vector                     as V import qualified Data.Vector.Unboxed             as U import           Data.Word+import           GHC.TypeLits  -- |  'FromLazyAvro' is a clone of 'FromAvro' except that -- it works for lazy values ('LazyValue').@@ -44,6 +50,13 @@     Nothing -> fail $ "Requested field not available: " <> show key     Just v  -> fromLazyAvro v +instance (FromLazyAvro a) => FromLazyAvro (Identity a) where+  fromLazyAvro e@(T.Union _ branch x)+    | S.matches branch sch = Identity  <$> fromLazyAvro x+    | otherwise            = badValue e "Identity"+    where Tagged sch = schema :: Tagged a Schema+  fromLazyAvro x = badValue x "Identity"+ instance (FromLazyAvro a, FromLazyAvro b) => FromLazyAvro (Either a b) where   fromLazyAvro e@(T.Union _ branch x)     | S.matches branch schemaA = Left  <$> fromLazyAvro x@@ -88,6 +101,28 @@ instance FromLazyAvro Float where   fromLazyAvro (T.Float f) = pure f   fromLazyAvro v           = badValue v "Float"++instance (KnownNat p, KnownNat s) => FromLazyAvro (D.Decimal p s) where+  fromLazyAvro (T.Long n) = pure $ D.fromUnderlyingValue $ fromIntegral n+  fromLazyAvro (T.Int  n) = pure $ D.fromUnderlyingValue $ fromIntegral n+  fromLazyAvro v          = badValue v "Decimal"++instance FromLazyAvro UUID.UUID where+  fromLazyAvro v@(T.String s)+    = case UUID.fromText s of+        Nothing -> badValue v "UUID"+        Just u  -> pure u+  fromLazyAvro v = badValue v "UUID"++instance FromLazyAvro Time.Day where+  fromLazyAvro (T.Int  v) = pure $ fromDaysSinceEpoch (toInteger v)+  fromLazyAvro (T.Long v) = pure $ fromDaysSinceEpoch (toInteger v)+  fromLazyAvro v = badValue v "Date"++instance FromLazyAvro Time.DiffTime where+  fromLazyAvro (T.Int  v) = pure $ microsToDiffTime (toInteger v)+  fromLazyAvro (T.Long v) = pure $ microsToDiffTime (toInteger v)+  fromLazyAvro v = badValue v "TimeMicros"  instance FromLazyAvro a => FromLazyAvro (Maybe a) where   fromLazyAvro (T.Union ts _ v) = case (V.toList ts, v) of

@@ -48,18 +48,18 @@  go :: Schema -> Get (T.Value Schema)  go ty =   case ty of-    Null    -> return T.Null-    Boolean -> T.Boolean <$> getAvro-    Int     -> T.Int     <$> getAvro-    Long    -> T.Long    <$> getAvro-    Float   -> T.Float   <$> getAvro-    Double  -> T.Double  <$> getAvro-    Bytes   -> T.Bytes   <$> getAvro-    String  -> T.String  <$> getAvro-    Array t ->+    Null     -> return T.Null+    Boolean  -> T.Boolean <$> getAvro+    Int _    -> T.Int     <$> getAvro+    Long _   -> T.Long    <$> getAvro+    Float    -> T.Float   <$> getAvro+    Double   -> T.Double  <$> getAvro+    Bytes _  -> T.Bytes   <$> getAvro+    String _ -> T.String  <$> getAvro+    Array t  ->       do vals <- getBlocksOf t          return $ T.Array (V.fromList $ mconcat vals)-    Map  t  ->+    Map  t   ->       do kvs <- getKVBlocks t          return $ T.Map (HashMap.fromList $ mconcat kvs)     NamedType tn -> env tn >>= go

@@ -80,15 +80,15 @@        withSchemaIn tyVal xs $ \sch -> deconflictValue sch nonUnion val   go eTy dTy val =     case val of-      T.Int i32  | dTy == S.Long   -> Right $ T.Long   (fromIntegral i32)-                 | dTy == S.Float  -> Right $ T.Float  (fromIntegral i32)-                 | dTy == S.Double -> Right $ T.Double (fromIntegral i32)-      T.Long i64 | dTy == S.Float  -> Right $ T.Float (fromIntegral i64)-                 | dTy == S.Double -> Right $ T.Double (fromIntegral i64)-      T.Float f  | dTy == S.Double -> Right $ T.Double (realToFrac f)-      T.String s | dTy == S.Bytes  -> Right $ T.Bytes (Text.encodeUtf8 s)-      T.Bytes bs | dTy == S.String -> Right $ T.String (Text.decodeUtf8 bs)-      _                            -> Left $ "Can not resolve differing writer and reader schemas: " ++ show (eTy, dTy)+      T.Int i32  | S.Long _ <- dTy   -> Right $ T.Long   (fromIntegral i32)+                 | dTy == S.Float    -> Right $ T.Float  (fromIntegral i32)+                 | dTy == S.Double   -> Right $ T.Double (fromIntegral i32)+      T.Long i64 | dTy == S.Float    -> Right $ T.Float (fromIntegral i64)+                 | dTy == S.Double   -> Right $ T.Double (fromIntegral i64)+      T.Float f  | dTy == S.Double   -> Right $ T.Double (realToFrac f)+      T.String s | S.Bytes _ <- dTy  -> Right $ T.Bytes (Text.encodeUtf8 s)+      T.Bytes bs | S.String _ <- dTy -> Right $ T.String (Text.decodeUtf8 bs)+      _                              -> Left $ "Can not resolve differing writer and reader schemas: " ++ show (eTy, dTy)  -- The writer's symbol must be present in the reader's enum deconflictEnum :: Schema -> Schema -> T.Value Schema -> Either String (T.Value Schema)

@@ -33,15 +33,16 @@ ) where -import           Control.Monad      (join)-import           Data.Aeson         (eitherDecode)-import qualified Data.Aeson         as J-import           Data.Avro          hiding (decode, encode)-import           Data.Avro.Schema   as S-import qualified Data.Avro.Types    as AT-import           Data.ByteString    (ByteString)-import qualified Data.ByteString    as B-import           Data.Char          (isAlphaNum)+import           Control.Monad          (join)+import           Control.Monad.Identity (Identity)+import           Data.Aeson             (eitherDecode)+import qualified Data.Aeson             as J+import           Data.Avro              hiding (decode, encode)+import           Data.Avro.Schema       as S+import qualified Data.Avro.Types        as AT+import           Data.ByteString        (ByteString)+import qualified Data.ByteString        as B+import           Data.Char              (isAlphaNum) import           Data.Int import           Data.List.NonEmpty (NonEmpty ((:|))) import qualified Data.List.NonEmpty as NE@@ -49,6 +50,8 @@ import           Data.Maybe         (fromMaybe) import           Data.Semigroup     ((<>)) import qualified Data.Text          as Text+import           Data.Time          (Day, DiffTime)+import           Data.UUID          (UUID)  import GHC.Generics (Generic) @@ -175,8 +178,8 @@       case S.fldType field of         S.Null    -> True         S.Boolean -> True-        S.Int     -> True-        S.Long    -> True+        S.Int _   -> True+        S.Long _  -> True         S.Float   -> True         S.Double  -> True         _         -> False@@ -346,7 +349,7 @@            $(genFromAvroFieldsExp (mkDataTypeName namespaceBehavior n) fs) r         fromAvro value           = $( [|\v -> badValue v $(mkTextLit $ S.renderFullname n)|] ) value   |]-genFromAvro namespaceBehavior (S.Fixed n _ s) =+genFromAvro namespaceBehavior (S.Fixed n _ s _) =   [d| instance FromAvro $(conT $ mkDataTypeName namespaceBehavior n) where         fromAvro (AT.Fixed _ v)           | BS.length v == s = pure $ $(conE (mkDataTypeName namespaceBehavior n)) v@@ -377,7 +380,7 @@            $(genFromLazyAvroFieldsExp (mkDataTypeName namespaceBehavior n) fs) r         fromLazyAvro value           = $( [|\v -> badValue v $(mkTextLit $ S.renderFullname n)|] ) value   |]-genFromLazyAvro namespaceBehavior (S.Fixed n _ s) =+genFromLazyAvro namespaceBehavior (S.Fixed n _ s _) =   [d| instance FromLazyAvro $(conT $ mkDataTypeName namespaceBehavior n) where         fromLazyAvro (LV.Fixed _ v)           | BS.length v == s = pure $ $(conE (mkDataTypeName namespaceBehavior n)) v@@ -448,7 +451,7 @@                 )             |] -genToAvro opts s@(S.Fixed n _ size) =+genToAvro opts s@(S.Fixed n _ size _) =   toAvroInstance (mkSchemaValueName (namespaceBehavior opts) n)   where     toAvroInstance sname =@@ -483,7 +486,7 @@ genType opts (S.Enum n _ _ vs) = do   let dname = mkDataTypeName (namespaceBehavior opts) n   sequenceA [genEnum dname (mkAdtCtorName (namespaceBehavior opts) n <$> (V.toList vs))]-genType opts (S.Fixed n _ s) = do+genType opts (S.Fixed n _ s _) = do   let dname = mkDataTypeName (namespaceBehavior opts) n   sequenceA [genNewtype dname] genType _ _ = pure []@@ -491,30 +494,44 @@ mkFieldTypeName :: NamespaceBehavior -> S.Schema -> Q TH.Type mkFieldTypeName namespaceBehavior = \case   S.Boolean          -> [t| Bool |]-  S.Long             -> [t| Int64 |]-  S.Int              -> [t| Int32 |]+  S.Long (Just (DecimalL (Decimal p s)))+                     -> [t| Decimal $(litT $ numTyLit p) $(litT $ numTyLit s) |]+  S.Long (Just TimeMicros)+                     -> [t| DiffTime |]+  S.Long _           -> [t| Int64 |]+  S.Int (Just Date)  -> [t| Day |]+  S.Int _            -> [t| Int32 |]   S.Float            -> [t| Float |]   S.Double           -> [t| Double |]-  S.Bytes            -> [t| ByteString |]-  S.String           -> [t| Text |]+  S.Bytes _          -> [t| ByteString |]+  S.String Nothing   -> [t| Text |]+  S.String (Just UUID) -> [t| UUID |]   S.Union branches   -> union (V.toList branches)   S.Record n _ _ _ _ -> [t| $(conT $ mkDataTypeName namespaceBehavior n) |]   S.Map x            -> [t| Map Text $(go x) |]   S.Array x          -> [t| [$(go x)] |]   S.NamedType n      -> [t| $(conT $ mkDataTypeName namespaceBehavior n)|]-  S.Fixed n _ _      -> [t| $(conT $ mkDataTypeName namespaceBehavior n)|]+  S.Fixed n _ _ _    -> [t| $(conT $ mkDataTypeName namespaceBehavior n)|]   S.Enum n _ _ _     -> [t| $(conT $ mkDataTypeName namespaceBehavior n)|]   t                  -> error $ "Avro type is not supported: " <> show t   where go = mkFieldTypeName namespaceBehavior         union = \case+          []              ->+            error "Empty union types are not supported"+          [x]             -> [t| Identity $(go x) |]           [Null, x]       -> [t| Maybe $(go x) |]           [x, Null]       -> [t| Maybe $(go x) |]           [x, y]          -> [t| Either $(go x) $(go y) |]           [a, b, c]       -> [t| Either3 $(go a) $(go b) $(go c) |]           [a, b, c, d]    -> [t| Either4 $(go a) $(go b) $(go c) $(go d) |]           [a, b, c, d, e] -> [t| Either5 $(go a) $(go b) $(go c) $(go d) $(go e) |]-          _               ->-            error "Unions with more than 5 elements are not yet supported"+          [a, b, c, d, e, f] -> [t| Either6 $(go a) $(go b) $(go c) $(go d) $(go e) $(go f) |]+          [a, b, c, d, e, f, g] -> [t| Either7 $(go a) $(go b) $(go c) $(go d) $(go e) $(go f) $(go g)|]+          [a, b, c, d, e, f, g, h] -> [t| Either8 $(go a) $(go b) $(go c) $(go d) $(go e) $(go f) $(go g) $(go h)|]+          [a, b, c, d, e, f, g, h, i] -> [t| Either9 $(go a) $(go b) $(go c) $(go d) $(go e) $(go f) $(go g) $(go h) $(go i)|]+          [a, b, c, d, e, f, g, h, i, j] -> [t| Either10 $(go a) $(go b) $(go c) $(go d) $(go e) $(go f) $(go g) $(go h) $(go i) $(go j)|]+          ls              ->+            error $ "Unions with more than 10 elements are not yet supported: Union has " <> (show . length) ls <> " elements"  updateFirst :: (Text -> Text) -> Text -> Text updateFirst f t =

@@ -34,4 +34,10 @@ deriving instance Lift Schema.Field deriving instance Lift Schema.Order deriving instance Lift Schema.TypeName+deriving instance Lift Schema.Decimal+deriving instance Lift Schema.LogicalTypeBytes+deriving instance Lift Schema.LogicalTypeFixed+deriving instance Lift Schema.LogicalTypeInt+deriving instance Lift Schema.LogicalTypeLong+deriving instance Lift Schema.LogicalTypeString deriving instance Lift Schema.Schema

@@ -23,6 +23,16 @@  data Either5 a b c d e = E5_1 a | E5_2 b | E5_3 c | E5_4 d | E5_5 e deriving (Eq, Ord, Show, Generic, Functor, Foldable, Traversable) +data Either6 a b c d e f = E6_1 a | E6_2 b | E6_3 c | E6_4 d | E6_5 e | E6_6 f deriving (Eq, Ord, Show, Generic, Functor, Foldable, Traversable)++data Either7 a b c d e f g = E7_1 a | E7_2 b | E7_3 c | E7_4 d | E7_5 e | E7_6 f | E7_7 g deriving (Eq, Ord, Show, Generic, Functor, Foldable, Traversable)++data Either8 a b c d e f g h = E8_1 a | E8_2 b | E8_3 c | E8_4 d | E8_5 e | E8_6 f | E8_7 g | E8_8 h deriving (Eq, Ord, Show, Generic, Functor, Foldable, Traversable)++data Either9 a b c d e f g h i = E9_1 a | E9_2 b | E9_3 c | E9_4 d | E9_5 e | E9_6 f | E9_7 g | E9_8 h | E9_9 i deriving (Eq, Ord, Show, Generic, Functor, Foldable, Traversable)++data Either10 a b c d e f g h i j = E10_1 a | E10_2 b | E10_3 c | E10_4 d | E10_5 e | E10_6 f | E10_7 g | E10_8 h | E10_9 i | E10_10 j deriving (Eq, Ord, Show, Generic, Functor, Foldable, Traversable)+ instance Applicative (Either3 a b) where   pure = E3_3   E3_1 a <*> _ = E3_1 a@@ -44,6 +54,61 @@   E5_4 a <*> _ = E5_4 a   E5_5 f <*> r = fmap f r +instance Applicative (Either6 a b c d e) where+  pure = E6_6+  E6_1 a <*> _ = E6_1 a+  E6_2 a <*> _ = E6_2 a+  E6_3 a <*> _ = E6_3 a+  E6_4 a <*> _ = E6_4 a+  E6_5 a <*> _ = E6_5 a+  E6_6 f <*> r = fmap f r++instance Applicative (Either7 a b c d e f) where+  pure = E7_7+  E7_1 a <*> _ = E7_1 a+  E7_2 a <*> _ = E7_2 a+  E7_3 a <*> _ = E7_3 a+  E7_4 a <*> _ = E7_4 a+  E7_5 a <*> _ = E7_5 a+  E7_6 a <*> _ = E7_6 a+  E7_7 f <*> r = fmap f r++instance Applicative (Either8 a b c d e f g) where+  pure = E8_8+  E8_1 a <*> _ = E8_1 a+  E8_2 a <*> _ = E8_2 a+  E8_3 a <*> _ = E8_3 a+  E8_4 a <*> _ = E8_4 a+  E8_5 a <*> _ = E8_5 a+  E8_6 a <*> _ = E8_6 a+  E8_7 a <*> _ = E8_7 a+  E8_8 f <*> r = fmap f r++instance Applicative (Either9 a b c d e f g h) where+  pure = E9_9+  E9_1 a <*> _ = E9_1 a+  E9_2 a <*> _ = E9_2 a+  E9_3 a <*> _ = E9_3 a+  E9_4 a <*> _ = E9_4 a+  E9_5 a <*> _ = E9_5 a+  E9_6 a <*> _ = E9_6 a+  E9_7 a <*> _ = E9_7 a+  E9_8 a <*> _ = E9_8 a+  E9_9 f <*> r = fmap f r++instance Applicative (Either10 a b c d e f g h i) where+  pure = E10_10+  E10_1 a <*> _ = E10_1 a+  E10_2 a <*> _ = E10_2 a+  E10_3 a <*> _ = E10_3 a+  E10_4 a <*> _ = E10_4 a+  E10_5 a <*> _ = E10_5 a+  E10_6 a <*> _ = E10_6 a+  E10_7 a <*> _ = E10_7 a+  E10_8 a <*> _ = E10_8 a+  E10_9 a <*> _ = E10_9 a+  E10_10 f <*> r = fmap f r+ instance Bifunctor (Either3 a) where   bimap _ _ (E3_1 a) = E3_1 a   bimap f _ (E3_2 a) = E3_2 (f a)@@ -62,6 +127,56 @@   bimap f _ (E5_4 a) = E5_4 (f a)   bimap _ g (E5_5 a) = E5_5 (g a) +instance Bifunctor (Either6 a b c d) where+  bimap _ _ (E6_1 a) = E6_1 a+  bimap _ _ (E6_2 a) = E6_2 a+  bimap _ _ (E6_3 a) = E6_3 a+  bimap _ _ (E6_4 a) = E6_4 a+  bimap f _ (E6_5 a) = E6_5 (f a)+  bimap _ g (E6_6 a) = E6_6 (g a)++instance Bifunctor (Either7 a b c d e) where+  bimap _ _ (E7_1 a) = E7_1 a+  bimap _ _ (E7_2 a) = E7_2 a+  bimap _ _ (E7_3 a) = E7_3 a+  bimap _ _ (E7_4 a) = E7_4 a+  bimap _ _ (E7_5 a) = E7_5 a+  bimap f _ (E7_6 a) = E7_6 (f a)+  bimap _ g (E7_7 a) = E7_7 (g a)++instance Bifunctor (Either8 a b c d e f) where+  bimap _ _ (E8_1 a) = E8_1 a+  bimap _ _ (E8_2 a) = E8_2 a+  bimap _ _ (E8_3 a) = E8_3 a+  bimap _ _ (E8_4 a) = E8_4 a+  bimap _ _ (E8_5 a) = E8_5 a+  bimap _ _ (E8_6 a) = E8_6 a+  bimap f _ (E8_7 a) = E8_7 (f a)+  bimap _ g (E8_8 a) = E8_8 (g a)++instance Bifunctor (Either9 a b c d e f g) where+  bimap _ _ (E9_1 a) = E9_1 a+  bimap _ _ (E9_2 a) = E9_2 a+  bimap _ _ (E9_3 a) = E9_3 a+  bimap _ _ (E9_4 a) = E9_4 a+  bimap _ _ (E9_5 a) = E9_5 a+  bimap _ _ (E9_6 a) = E9_6 a+  bimap _ _ (E9_7 a) = E9_7 a+  bimap f _ (E9_8 a) = E9_8 (f a)+  bimap _ g (E9_9 a) = E9_9 (g a)++instance Bifunctor (Either10 a b c d e f g h) where+  bimap _ _ (E10_1 a) = E10_1 a+  bimap _ _ (E10_2 a) = E10_2 a+  bimap _ _ (E10_3 a) = E10_3 a+  bimap _ _ (E10_4 a) = E10_4 a+  bimap _ _ (E10_5 a) = E10_5 a+  bimap _ _ (E10_6 a) = E10_6 a+  bimap _ _ (E10_7 a) = E10_7 a+  bimap _ _ (E10_8 a) = E10_8 a+  bimap f _ (E10_9 a) = E10_9 (f a)+  bimap _ g (E10_10 a) = E10_10 (g a)+ instance Monad (Either3 a b) where   E3_1 a >>= _ = E3_1 a   E3_2 a >>= _ = E3_2 a@@ -80,6 +195,56 @@   E5_4 a >>= _ = E5_4 a   E5_5 a >>= f = f a +instance Monad (Either6 a b c d e) where+  E6_1 a >>= _ = E6_1 a+  E6_2 a >>= _ = E6_2 a+  E6_3 a >>= _ = E6_3 a+  E6_4 a >>= _ = E6_4 a+  E6_5 a >>= _ = E6_5 a+  E6_6 a >>= f = f a++instance Monad (Either7 a b c d e f) where+  E7_1 a >>= _ = E7_1 a+  E7_2 a >>= _ = E7_2 a+  E7_3 a >>= _ = E7_3 a+  E7_4 a >>= _ = E7_4 a+  E7_5 a >>= _ = E7_5 a+  E7_6 a >>= _ = E7_6 a+  E7_7 a >>= f = f a++instance Monad (Either8 a b c d e f g) where+  E8_1 a >>= _ = E8_1 a+  E8_2 a >>= _ = E8_2 a+  E8_3 a >>= _ = E8_3 a+  E8_4 a >>= _ = E8_4 a+  E8_5 a >>= _ = E8_5 a+  E8_6 a >>= _ = E8_6 a+  E8_7 a >>= _ = E8_7 a+  E8_8 a >>= f = f a++instance Monad (Either9 a b c d e f g h) where+  E9_1 a >>= _ = E9_1 a+  E9_2 a >>= _ = E9_2 a+  E9_3 a >>= _ = E9_3 a+  E9_4 a >>= _ = E9_4 a+  E9_5 a >>= _ = E9_5 a+  E9_6 a >>= _ = E9_6 a+  E9_7 a >>= _ = E9_7 a+  E9_8 a >>= _ = E9_8 a+  E9_9 a >>= f = f a++instance Monad (Either10 a b c d e f g h i) where+  E10_1 a >>= _ = E10_1 a+  E10_2 a >>= _ = E10_2 a+  E10_3 a >>= _ = E10_3 a+  E10_4 a >>= _ = E10_4 a+  E10_5 a >>= _ = E10_5 a+  E10_6 a >>= _ = E10_6 a+  E10_7 a >>= _ = E10_7 a+  E10_8 a >>= _ = E10_8 a+  E10_9 a >>= _ = E10_9 a+  E10_10 a >>= f = f a+ instance Bifoldable (Either3 a) where   bifoldMap f _ (E3_2 a) = f a   bifoldMap _ g (E3_3 a) = g a@@ -95,6 +260,31 @@   bifoldMap _ g (E5_5 a) = g a   bifoldMap _ _ _        = mempty +instance Bifoldable (Either6 a b c d) where+  bifoldMap f _ (E6_5 a) = f a+  bifoldMap _ g (E6_6 a) = g a+  bifoldMap _ _ _        = mempty++instance Bifoldable (Either7 a b c d e) where+  bifoldMap f _ (E7_6 a) = f a+  bifoldMap _ g (E7_7 a) = g a+  bifoldMap _ _ _        = mempty++instance Bifoldable (Either8 a b c d e f) where+  bifoldMap f _ (E8_7 a) = f a+  bifoldMap _ g (E8_8 a) = g a+  bifoldMap _ _ _        = mempty++instance Bifoldable (Either9 a b c d e f g) where+  bifoldMap f _ (E9_8 a) = f a+  bifoldMap _ g (E9_9 a) = g a+  bifoldMap _ _ _        = mempty++instance Bifoldable (Either10 a b c d e f g h) where+  bifoldMap f _ (E10_9 a) = f a+  bifoldMap _ g (E10_10 a) = g a+  bifoldMap _ _ _        = mempty+ instance Bitraversable (Either3 a) where   bitraverse _ _ (E3_1 a) = pure (E3_1 a)   bitraverse f _ (E3_2 a) = E3_2 <$> f a@@ -113,6 +303,56 @@   bitraverse f _ (E5_4 a) = E5_4 <$> f a   bitraverse _ g (E5_5 a) = E5_5 <$> g a +instance Bitraversable (Either6 a b c d) where+  bitraverse _ _ (E6_1 a) = pure (E6_1 a)+  bitraverse _ _ (E6_2 a) = pure (E6_2 a)+  bitraverse _ _ (E6_3 a) = pure (E6_3 a)+  bitraverse _ _ (E6_4 a) = pure (E6_4 a)+  bitraverse f _ (E6_5 a) = E6_5 <$> f a+  bitraverse _ g (E6_6 a) = E6_6 <$> g a++instance Bitraversable (Either7 a b c d e) where+  bitraverse _ _ (E7_1 a) = pure (E7_1 a)+  bitraverse _ _ (E7_2 a) = pure (E7_2 a)+  bitraverse _ _ (E7_3 a) = pure (E7_3 a)+  bitraverse _ _ (E7_4 a) = pure (E7_4 a)+  bitraverse _ _ (E7_5 a) = pure (E7_5 a)+  bitraverse f _ (E7_6 a) = E7_6 <$> (f a)+  bitraverse _ g (E7_7 a) = E7_7 <$> (g a)++instance Bitraversable (Either8 a b c d e f) where+  bitraverse _ _ (E8_1 a) = pure (E8_1 a)+  bitraverse _ _ (E8_2 a) = pure (E8_2 a)+  bitraverse _ _ (E8_3 a) = pure (E8_3 a)+  bitraverse _ _ (E8_4 a) = pure (E8_4 a)+  bitraverse _ _ (E8_5 a) = pure (E8_5 a)+  bitraverse _ _ (E8_6 a) = pure (E8_6 a)+  bitraverse f _ (E8_7 a) = E8_7 <$> (f a)+  bitraverse _ g (E8_8 a) = E8_8 <$> (g a)++instance Bitraversable (Either9 a b c d e f g) where+  bitraverse _ _ (E9_1 a) = pure (E9_1 a)+  bitraverse _ _ (E9_2 a) = pure (E9_2 a)+  bitraverse _ _ (E9_3 a) = pure (E9_3 a)+  bitraverse _ _ (E9_4 a) = pure (E9_4 a)+  bitraverse _ _ (E9_5 a) = pure (E9_5 a)+  bitraverse _ _ (E9_6 a) = pure (E9_6 a)+  bitraverse _ _ (E9_7 a) = pure (E9_7 a)+  bitraverse f _ (E9_8 a) = E9_8 <$> (f a)+  bitraverse _ g (E9_9 a) = E9_9 <$> (g a)++instance Bitraversable (Either10 a b c d e f g h) where+  bitraverse _ _ (E10_1 a) = pure (E10_1 a)+  bitraverse _ _ (E10_2 a) = pure (E10_2 a)+  bitraverse _ _ (E10_3 a) = pure (E10_3 a)+  bitraverse _ _ (E10_4 a) = pure (E10_4 a)+  bitraverse _ _ (E10_5 a) = pure (E10_5 a)+  bitraverse _ _ (E10_6 a) = pure (E10_6 a)+  bitraverse _ _ (E10_7 a) = pure (E10_7 a)+  bitraverse _ _ (E10_8 a) = pure (E10_8 a)+  bitraverse f _ (E10_9 a) = E10_9 <$> (f a)+  bitraverse _ g (E10_10 a) = E10_10 <$> (g a)+ instance (HasAvroSchema a, HasAvroSchema b, HasAvroSchema c) => HasAvroSchema (Either3 a b c) where   schema = Tagged $ mkUnion (untag (schema :: Tagged a Schema) :| [                              untag (schema :: Tagged b Schema),@@ -134,6 +374,67 @@                              untag (schema :: Tagged e Schema)                             ]) +instance (HasAvroSchema a, HasAvroSchema b, HasAvroSchema c, HasAvroSchema d, HasAvroSchema e, HasAvroSchema f)+  => HasAvroSchema (Either6 a b c d e f) where+    schema = Tagged $ mkUnion (untag (schema :: Tagged a Schema) :| [+                               untag (schema :: Tagged b Schema),+                               untag (schema :: Tagged c Schema),+                               untag (schema :: Tagged d Schema),+                               untag (schema :: Tagged e Schema),+                               untag (schema :: Tagged f Schema)+                              ])++instance (HasAvroSchema a, HasAvroSchema b, HasAvroSchema c, HasAvroSchema d, HasAvroSchema e, HasAvroSchema f, HasAvroSchema g)+  => HasAvroSchema (Either7 a b c d e f g) where+    schema = Tagged $ mkUnion (untag (schema :: Tagged a Schema) :| [+                               untag (schema :: Tagged b Schema),+                               untag (schema :: Tagged c Schema),+                               untag (schema :: Tagged d Schema),+                               untag (schema :: Tagged e Schema),+                               untag (schema :: Tagged f Schema),+                               untag (schema :: Tagged g Schema)+                              ])++instance (HasAvroSchema a, HasAvroSchema b, HasAvroSchema c, HasAvroSchema d, HasAvroSchema e, HasAvroSchema f, HasAvroSchema g, HasAvroSchema h)+  => HasAvroSchema (Either8 a b c d e f g h) where+    schema = Tagged $ mkUnion (untag (schema :: Tagged a Schema) :| [+                               untag (schema :: Tagged b Schema),+                               untag (schema :: Tagged c Schema),+                               untag (schema :: Tagged d Schema),+                               untag (schema :: Tagged e Schema),+                               untag (schema :: Tagged f Schema),+                               untag (schema :: Tagged g Schema),+                               untag (schema :: Tagged h Schema)+                              ])++instance (HasAvroSchema a, HasAvroSchema b, HasAvroSchema c, HasAvroSchema d, HasAvroSchema e, HasAvroSchema f, HasAvroSchema g, HasAvroSchema h, HasAvroSchema i)+  => HasAvroSchema (Either9 a b c d e f g h i) where+    schema = Tagged $ mkUnion (untag (schema :: Tagged a Schema) :| [+                               untag (schema :: Tagged b Schema),+                               untag (schema :: Tagged c Schema),+                               untag (schema :: Tagged d Schema),+                               untag (schema :: Tagged e Schema),+                               untag (schema :: Tagged f Schema),+                               untag (schema :: Tagged g Schema),+                               untag (schema :: Tagged h Schema),+                               untag (schema :: Tagged i Schema)+                              ])++instance (HasAvroSchema a, HasAvroSchema b, HasAvroSchema c, HasAvroSchema d, HasAvroSchema e, HasAvroSchema f, HasAvroSchema g, HasAvroSchema h, HasAvroSchema i, HasAvroSchema j)+  => HasAvroSchema (Either10 a b c d e f g h i j) where+    schema = Tagged $ mkUnion (untag (schema :: Tagged a Schema) :| [+                               untag (schema :: Tagged b Schema),+                               untag (schema :: Tagged c Schema),+                               untag (schema :: Tagged d Schema),+                               untag (schema :: Tagged e Schema),+                               untag (schema :: Tagged f Schema),+                               untag (schema :: Tagged g Schema),+                               untag (schema :: Tagged h Schema),+                               untag (schema :: Tagged i Schema),+                               untag (schema :: Tagged j Schema)+                              ])++ instance (FromAvro a, FromAvro b, FromAvro c) => FromAvro (Either3 a b c) where   fromAvro e@(T.Union _ branch x)     | matches branch schemaA = E3_1 <$> fromAvro x@@ -173,6 +474,111 @@           Tagged schemaE = schema :: Tagged e Schema   fromAvro x = badValue x "Either5" +instance (FromAvro a, FromAvro b, FromAvro c, FromAvro d, FromAvro e, FromAvro f) => FromAvro (Either6 a b c d e f) where+  fromAvro e@(T.Union _ branch x)+    | matches branch schemaA = E6_1 <$> fromAvro x+    | matches branch schemaB = E6_2 <$> fromAvro x+    | matches branch schemaC = E6_3 <$> fromAvro x+    | matches branch schemaD = E6_4 <$> fromAvro x+    | matches branch schemaE = E6_5 <$> fromAvro x+    | matches branch schemaF = E6_6 <$> fromAvro x+    | otherwise              = badValue e "Either6"+    where Tagged schemaA = schema :: Tagged a Schema+          Tagged schemaB = schema :: Tagged b Schema+          Tagged schemaC = schema :: Tagged c Schema+          Tagged schemaD = schema :: Tagged d Schema+          Tagged schemaE = schema :: Tagged e Schema+          Tagged schemaF = schema :: Tagged f Schema+  fromAvro x = badValue x "Either6"++instance (FromAvro a, FromAvro b, FromAvro c, FromAvro d, FromAvro e, FromAvro f, FromAvro g) => FromAvro (Either7 a b c d e f g) where+  fromAvro e@(T.Union _ branch x)+    | matches branch schemaA = E7_1 <$> fromAvro x+    | matches branch schemaB = E7_2 <$> fromAvro x+    | matches branch schemaC = E7_3 <$> fromAvro x+    | matches branch schemaD = E7_4 <$> fromAvro x+    | matches branch schemaE = E7_5 <$> fromAvro x+    | matches branch schemaF = E7_6 <$> fromAvro x+    | matches branch schemaG = E7_7 <$> fromAvro x+      | otherwise              = badValue e "Either7"+    where Tagged schemaA = schema :: Tagged a Schema+          Tagged schemaB = schema :: Tagged b Schema+          Tagged schemaC = schema :: Tagged c Schema+          Tagged schemaD = schema :: Tagged d Schema+          Tagged schemaE = schema :: Tagged e Schema+          Tagged schemaF = schema :: Tagged f Schema+          Tagged schemaG = schema :: Tagged g Schema+  fromAvro x = badValue x "Either7"++instance (FromAvro a, FromAvro b, FromAvro c, FromAvro d, FromAvro e, FromAvro f, FromAvro g, FromAvro h) => FromAvro (Either8 a b c d e f g h) where+  fromAvro e@(T.Union _ branch x)+    | matches branch schemaA = E8_1 <$> fromAvro x+    | matches branch schemaB = E8_2 <$> fromAvro x+    | matches branch schemaC = E8_3 <$> fromAvro x+    | matches branch schemaD = E8_4 <$> fromAvro x+    | matches branch schemaE = E8_5 <$> fromAvro x+    | matches branch schemaF = E8_6 <$> fromAvro x+    | matches branch schemaG = E8_7 <$> fromAvro x+    | matches branch schemaH = E8_8 <$> fromAvro x+    | otherwise              = badValue e "Either8"+    where Tagged schemaA = schema :: Tagged a Schema+          Tagged schemaB = schema :: Tagged b Schema+          Tagged schemaC = schema :: Tagged c Schema+          Tagged schemaD = schema :: Tagged d Schema+          Tagged schemaE = schema :: Tagged e Schema+          Tagged schemaF = schema :: Tagged f Schema+          Tagged schemaG = schema :: Tagged g Schema+          Tagged schemaH = schema :: Tagged h Schema+  fromAvro x = badValue x "Either8"++instance (FromAvro a, FromAvro b, FromAvro c, FromAvro d, FromAvro e, FromAvro f, FromAvro g, FromAvro h, FromAvro i) => FromAvro (Either9 a b c d e f g h i) where+  fromAvro e@(T.Union _ branch x)+    | matches branch schemaA = E9_1 <$> fromAvro x+    | matches branch schemaB = E9_2 <$> fromAvro x+    | matches branch schemaC = E9_3 <$> fromAvro x+    | matches branch schemaD = E9_4 <$> fromAvro x+    | matches branch schemaE = E9_5 <$> fromAvro x+    | matches branch schemaF = E9_6 <$> fromAvro x+    | matches branch schemaG = E9_7 <$> fromAvro x+    | matches branch schemaH = E9_8 <$> fromAvro x+    | matches branch schemaI = E9_9 <$> fromAvro x+    | otherwise              = badValue e "Either9"+    where Tagged schemaA = schema :: Tagged a Schema+          Tagged schemaB = schema :: Tagged b Schema+          Tagged schemaC = schema :: Tagged c Schema+          Tagged schemaD = schema :: Tagged d Schema+          Tagged schemaE = schema :: Tagged e Schema+          Tagged schemaF = schema :: Tagged f Schema+          Tagged schemaG = schema :: Tagged g Schema+          Tagged schemaH = schema :: Tagged h Schema+          Tagged schemaI = schema :: Tagged i Schema+  fromAvro x = badValue x "Either9"++instance (FromAvro a, FromAvro b, FromAvro c, FromAvro d, FromAvro e, FromAvro f, FromAvro g, FromAvro h, FromAvro i, FromAvro j) => FromAvro (Either10 a b c d e f g h i j) where+  fromAvro e@(T.Union _ branch x)+    | matches branch schemaA = E10_1 <$> fromAvro x+    | matches branch schemaB = E10_2 <$> fromAvro x+    | matches branch schemaC = E10_3 <$> fromAvro x+    | matches branch schemaD = E10_4 <$> fromAvro x+    | matches branch schemaE = E10_5 <$> fromAvro x+    | matches branch schemaF = E10_6 <$> fromAvro x+    | matches branch schemaG = E10_7 <$> fromAvro x+    | matches branch schemaH = E10_8 <$> fromAvro x+    | matches branch schemaI = E10_9 <$> fromAvro x+    | matches branch schemaJ = E10_10 <$> fromAvro x+    | otherwise              = badValue e "Either10"+    where Tagged schemaA = schema :: Tagged a Schema+          Tagged schemaB = schema :: Tagged b Schema+          Tagged schemaC = schema :: Tagged c Schema+          Tagged schemaD = schema :: Tagged d Schema+          Tagged schemaE = schema :: Tagged e Schema+          Tagged schemaF = schema :: Tagged f Schema+          Tagged schemaG = schema :: Tagged g Schema+          Tagged schemaH = schema :: Tagged h Schema+          Tagged schemaI = schema :: Tagged i Schema+          Tagged schemaJ = schema :: Tagged j Schema+  fromAvro x = badValue x "Either10"+ instance (FromLazyAvro a, FromLazyAvro b, FromLazyAvro c) => FromLazyAvro (Either3 a b c) where   fromLazyAvro e@(AL.Union _ branch x)     | matches branch schemaA = E3_1 <$> fromLazyAvro x@@ -212,6 +618,111 @@           Tagged schemaE = schema :: Tagged e Schema   fromLazyAvro x = badValue x "Either5" +instance (FromLazyAvro a, FromLazyAvro b, FromLazyAvro c, FromLazyAvro d, FromLazyAvro e, FromLazyAvro f) => FromLazyAvro (Either6 a b c d e f) where+  fromLazyAvro e@(AL.Union _ branch x)+    | matches branch schemaA = E6_1 <$> fromLazyAvro x+    | matches branch schemaB = E6_2 <$> fromLazyAvro x+    | matches branch schemaC = E6_3 <$> fromLazyAvro x+    | matches branch schemaD = E6_4 <$> fromLazyAvro x+    | matches branch schemaE = E6_5 <$> fromLazyAvro x+    | matches branch schemaF = E6_6 <$> fromLazyAvro x+    | otherwise              = badValue e "Either6"+    where Tagged schemaA = schema :: Tagged a Schema+          Tagged schemaB = schema :: Tagged b Schema+          Tagged schemaC = schema :: Tagged c Schema+          Tagged schemaD = schema :: Tagged d Schema+          Tagged schemaE = schema :: Tagged e Schema+          Tagged schemaF = schema :: Tagged f Schema+  fromLazyAvro x = badValue x "Either6"++instance (FromLazyAvro a, FromLazyAvro b, FromLazyAvro c, FromLazyAvro d, FromLazyAvro e, FromLazyAvro f, FromLazyAvro g) => FromLazyAvro (Either7 a b c d e f g) where+  fromLazyAvro e@(AL.Union _ branch x)+    | matches branch schemaA = E7_1 <$> fromLazyAvro x+    | matches branch schemaB = E7_2 <$> fromLazyAvro x+    | matches branch schemaC = E7_3 <$> fromLazyAvro x+    | matches branch schemaD = E7_4 <$> fromLazyAvro x+    | matches branch schemaE = E7_5 <$> fromLazyAvro x+    | matches branch schemaF = E7_6 <$> fromLazyAvro x+    | matches branch schemaG = E7_7 <$> fromLazyAvro x+      | otherwise              = badValue e "Either7"+    where Tagged schemaA = schema :: Tagged a Schema+          Tagged schemaB = schema :: Tagged b Schema+          Tagged schemaC = schema :: Tagged c Schema+          Tagged schemaD = schema :: Tagged d Schema+          Tagged schemaE = schema :: Tagged e Schema+          Tagged schemaF = schema :: Tagged f Schema+          Tagged schemaG = schema :: Tagged g Schema+  fromLazyAvro x = badValue x "Either7"++instance (FromLazyAvro a, FromLazyAvro b, FromLazyAvro c, FromLazyAvro d, FromLazyAvro e, FromLazyAvro f, FromLazyAvro g, FromLazyAvro h) => FromLazyAvro (Either8 a b c d e f g h) where+  fromLazyAvro e@(AL.Union _ branch x)+    | matches branch schemaA = E8_1 <$> fromLazyAvro x+    | matches branch schemaB = E8_2 <$> fromLazyAvro x+    | matches branch schemaC = E8_3 <$> fromLazyAvro x+    | matches branch schemaD = E8_4 <$> fromLazyAvro x+    | matches branch schemaE = E8_5 <$> fromLazyAvro x+    | matches branch schemaF = E8_6 <$> fromLazyAvro x+    | matches branch schemaG = E8_7 <$> fromLazyAvro x+    | matches branch schemaH = E8_8 <$> fromLazyAvro x+    | otherwise              = badValue e "Either8"+    where Tagged schemaA = schema :: Tagged a Schema+          Tagged schemaB = schema :: Tagged b Schema+          Tagged schemaC = schema :: Tagged c Schema+          Tagged schemaD = schema :: Tagged d Schema+          Tagged schemaE = schema :: Tagged e Schema+          Tagged schemaF = schema :: Tagged f Schema+          Tagged schemaG = schema :: Tagged g Schema+          Tagged schemaH = schema :: Tagged h Schema+  fromLazyAvro x = badValue x "Either8"++instance (FromLazyAvro a, FromLazyAvro b, FromLazyAvro c, FromLazyAvro d, FromLazyAvro e, FromLazyAvro f, FromLazyAvro g, FromLazyAvro h, FromLazyAvro i) => FromLazyAvro (Either9 a b c d e f g h i) where+  fromLazyAvro e@(AL.Union _ branch x)+    | matches branch schemaA = E9_1 <$> fromLazyAvro x+    | matches branch schemaB = E9_2 <$> fromLazyAvro x+    | matches branch schemaC = E9_3 <$> fromLazyAvro x+    | matches branch schemaD = E9_4 <$> fromLazyAvro x+    | matches branch schemaE = E9_5 <$> fromLazyAvro x+    | matches branch schemaF = E9_6 <$> fromLazyAvro x+    | matches branch schemaG = E9_7 <$> fromLazyAvro x+    | matches branch schemaH = E9_8 <$> fromLazyAvro x+    | matches branch schemaI = E9_9 <$> fromLazyAvro x+    | otherwise              = badValue e "Either9"+    where Tagged schemaA = schema :: Tagged a Schema+          Tagged schemaB = schema :: Tagged b Schema+          Tagged schemaC = schema :: Tagged c Schema+          Tagged schemaD = schema :: Tagged d Schema+          Tagged schemaE = schema :: Tagged e Schema+          Tagged schemaF = schema :: Tagged f Schema+          Tagged schemaG = schema :: Tagged g Schema+          Tagged schemaH = schema :: Tagged h Schema+          Tagged schemaI = schema :: Tagged i Schema+  fromLazyAvro x = badValue x "Either9"++instance (FromLazyAvro a, FromLazyAvro b, FromLazyAvro c, FromLazyAvro d, FromLazyAvro e, FromLazyAvro f, FromLazyAvro g, FromLazyAvro h, FromLazyAvro i, FromLazyAvro j) => FromLazyAvro (Either10 a b c d e f g h i j) where+  fromLazyAvro e@(AL.Union _ branch x)+    | matches branch schemaA = E10_1 <$> fromLazyAvro x+    | matches branch schemaB = E10_2 <$> fromLazyAvro x+    | matches branch schemaC = E10_3 <$> fromLazyAvro x+    | matches branch schemaD = E10_4 <$> fromLazyAvro x+    | matches branch schemaE = E10_5 <$> fromLazyAvro x+    | matches branch schemaF = E10_6 <$> fromLazyAvro x+    | matches branch schemaG = E10_7 <$> fromLazyAvro x+    | matches branch schemaH = E10_8 <$> fromLazyAvro x+    | matches branch schemaI = E10_9 <$> fromLazyAvro x+    | matches branch schemaJ = E10_10 <$> fromLazyAvro x+    | otherwise              = badValue e "Either10"+    where Tagged schemaA = schema :: Tagged a Schema+          Tagged schemaB = schema :: Tagged b Schema+          Tagged schemaC = schema :: Tagged c Schema+          Tagged schemaD = schema :: Tagged d Schema+          Tagged schemaE = schema :: Tagged e Schema+          Tagged schemaF = schema :: Tagged f Schema+          Tagged schemaG = schema :: Tagged g Schema+          Tagged schemaH = schema :: Tagged h Schema+          Tagged schemaI = schema :: Tagged i Schema+          Tagged schemaJ = schema :: Tagged j Schema+  fromLazyAvro x = badValue x "Either10"+ instance (ToAvro a, ToAvro b, ToAvro c) => ToAvro (Either3 a b c) where   toAvro e =     let sch = options (schemaOf e)@@ -238,3 +749,68 @@       E5_3 c -> T.Union sch (schemaOf c) (toAvro c)       E5_4 d -> T.Union sch (schemaOf d) (toAvro d)       E5_5 e -> T.Union sch (schemaOf e) (toAvro e)++instance (ToAvro a, ToAvro b, ToAvro c, ToAvro d, ToAvro e, ToAvro f) => ToAvro (Either6 a b c d e f) where+  toAvro e =+    let sch = options (schemaOf e)+    in case e of+      E6_1 a -> T.Union sch (schemaOf a) (toAvro a)+      E6_2 b -> T.Union sch (schemaOf b) (toAvro b)+      E6_3 c -> T.Union sch (schemaOf c) (toAvro c)+      E6_4 d -> T.Union sch (schemaOf d) (toAvro d)+      E6_5 e -> T.Union sch (schemaOf e) (toAvro e)+      E6_6 f -> T.Union sch (schemaOf f) (toAvro f)++instance (ToAvro a, ToAvro b, ToAvro c, ToAvro d, ToAvro e, ToAvro f, ToAvro g) => ToAvro (Either7 a b c d e f g) where+  toAvro e =+    let sch = options (schemaOf e)+    in case e of+      E7_1 a -> T.Union sch (schemaOf a) (toAvro a)+      E7_2 b -> T.Union sch (schemaOf b) (toAvro b)+      E7_3 c -> T.Union sch (schemaOf c) (toAvro c)+      E7_4 d -> T.Union sch (schemaOf d) (toAvro d)+      E7_5 e -> T.Union sch (schemaOf e) (toAvro e)+      E7_6 f -> T.Union sch (schemaOf f) (toAvro f)+      E7_7 g -> T.Union sch (schemaOf g) (toAvro g)++instance (ToAvro a, ToAvro b, ToAvro c, ToAvro d, ToAvro e, ToAvro f, ToAvro g, ToAvro h) => ToAvro (Either8 a b c d e f g h) where+  toAvro e =+    let sch = options (schemaOf e)+    in case e of+      E8_1 a -> T.Union sch (schemaOf a) (toAvro a)+      E8_2 b -> T.Union sch (schemaOf b) (toAvro b)+      E8_3 c -> T.Union sch (schemaOf c) (toAvro c)+      E8_4 d -> T.Union sch (schemaOf d) (toAvro d)+      E8_5 e -> T.Union sch (schemaOf e) (toAvro e)+      E8_6 f -> T.Union sch (schemaOf f) (toAvro f)+      E8_7 g -> T.Union sch (schemaOf g) (toAvro g)+      E8_8 h -> T.Union sch (schemaOf h) (toAvro h)++instance (ToAvro a, ToAvro b, ToAvro c, ToAvro d, ToAvro e, ToAvro f, ToAvro g, ToAvro h, ToAvro i) => ToAvro (Either9 a b c d e f g h i) where+  toAvro e =+    let sch = options (schemaOf e)+    in case e of+      E9_1 a -> T.Union sch (schemaOf a) (toAvro a)+      E9_2 b -> T.Union sch (schemaOf b) (toAvro b)+      E9_3 c -> T.Union sch (schemaOf c) (toAvro c)+      E9_4 d -> T.Union sch (schemaOf d) (toAvro d)+      E9_5 e -> T.Union sch (schemaOf e) (toAvro e)+      E9_6 f -> T.Union sch (schemaOf f) (toAvro f)+      E9_7 g -> T.Union sch (schemaOf g) (toAvro g)+      E9_8 h -> T.Union sch (schemaOf h) (toAvro h)+      E9_9 i -> T.Union sch (schemaOf i) (toAvro i)++instance (ToAvro a, ToAvro b, ToAvro c, ToAvro d, ToAvro e, ToAvro f, ToAvro g, ToAvro h, ToAvro i, ToAvro j) => ToAvro (Either10 a b c d e f g h i j) where+  toAvro e =+    let sch = options (schemaOf e)+    in case e of+      E10_1 a -> T.Union sch (schemaOf a) (toAvro a)+      E10_2 b -> T.Union sch (schemaOf b) (toAvro b)+      E10_3 c -> T.Union sch (schemaOf c) (toAvro c)+      E10_4 d -> T.Union sch (schemaOf d) (toAvro d)+      E10_5 e -> T.Union sch (schemaOf e) (toAvro e)+      E10_6 f -> T.Union sch (schemaOf f) (toAvro f)+      E10_7 g -> T.Union sch (schemaOf g) (toAvro g)+      E10_8 h -> T.Union sch (schemaOf h) (toAvro h)+      E10_9 i -> T.Union sch (schemaOf i) (toAvro i)+      E10_10 j -> T.Union sch (schemaOf j) (toAvro j)

@@ -3,7 +3,6 @@ {-# LANGUAGE RecordWildCards      #-} {-# LANGUAGE ScopedTypeVariables  #-} {-# LANGUAGE TypeFamilies         #-}-{-# LANGUAGE TypeSynonymInstances #-}  module Data.Avro.Encode   ( -- * High level interface@@ -40,7 +39,7 @@ import           Data.List                  as DL import           Data.List.NonEmpty         (NonEmpty (..)) import qualified Data.List.NonEmpty         as NE-import           Data.Maybe                 (catMaybes, mapMaybe)+import           Data.Maybe                 (catMaybes, mapMaybe, fromJust) import           Data.Monoid import           Data.Proxy import qualified Data.Set                   as S@@ -49,9 +48,12 @@ import qualified Data.Text.Encoding         as T import qualified Data.Text.Lazy             as TL import qualified Data.Text.Lazy.Encoding    as TL+import qualified Data.Time                  as Time+import qualified Data.UUID                  as UUID import qualified Data.Vector                as V import qualified Data.Vector.Unboxed        as U import           Data.Word+import           GHC.TypeLits import           Prelude                    as P import           System.Random.TF.Init      (initTFGen) import           System.Random.TF.Instances (randoms)@@ -61,6 +63,8 @@ import Data.Avro.HasAvroSchema import Data.Avro.Schema        as S import Data.Avro.Types         as T+import Data.Avro.Types.Decimal as D+import Data.Avro.Types.Time import Data.Avro.Zag import Data.Avro.Zig @@ -176,10 +180,10 @@   avro :: a -> AvroM  avroInt :: forall a. (FiniteBits a, Integral a, EncodeRaw a) => a -> AvroM-avroInt n = AvroM (encodeRaw n, S.Int)+avroInt n = AvroM (encodeRaw n, S.Int Nothing)  avroLong :: forall a. (FiniteBits a, Integral a, EncodeRaw a) => a -> AvroM-avroLong n = AvroM (encodeRaw n, S.Long)+avroLong n = AvroM (encodeRaw n, S.Long Nothing)  -- Put a Haskell Int. putI :: Int -> Builder@@ -206,17 +210,17 @@ instance EncodeAvro Text where   avro t =     let bs = T.encodeUtf8 t-    in AvroM (encodeRaw (B.length bs) <> byteString bs, S.String)+    in AvroM (encodeRaw (B.length bs) <> byteString bs, S.String') instance EncodeAvro TL.Text where   avro t =     let bs = TL.encodeUtf8 t-    in AvroM (encodeRaw (BL.length bs) <> lazyByteString bs, S.String)+    in AvroM (encodeRaw (BL.length bs) <> lazyByteString bs, S.String')  instance EncodeAvro ByteString where-  avro bs = AvroM (encodeRaw (BL.length bs) <> lazyByteString bs, S.Bytes)+  avro bs = AvroM (encodeRaw (BL.length bs) <> lazyByteString bs, S.Bytes Nothing)  instance EncodeAvro B.ByteString where-  avro bs = AvroM (encodeRaw (B.length bs) <> byteString bs, S.Bytes)+  avro bs = AvroM (encodeRaw (B.length bs) <> byteString bs, S.Bytes Nothing)  instance EncodeAvro String where   avro s = let t = T.pack s in avro t@@ -227,6 +231,25 @@ instance EncodeAvro Float where   avro d = AvroM (word32LE (IEEE.floatToWord d), S.Float) +instance (KnownNat p, KnownNat s) => EncodeAvro (D.Decimal p s) where+  avro d = AvroM (encodeRaw val, S.Long (Just (DecimalL (S.Decimal pp ss))))+    where ss = natVal (Proxy :: Proxy s)+          pp = natVal (Proxy :: Proxy p)+          val :: Int = fromJust $ D.underlyingValue d++instance EncodeAvro UUID.UUID where+  avro d =+    let bs = T.encodeUtf8 (UUID.toText d)+    in AvroM (encodeRaw (B.length bs) <> byteString bs, S.String (Just UUID))++instance EncodeAvro Time.Day where+  avro d = AvroM ( encodeRaw (fromIntegral $ daysSinceEpoch d :: Int)+                 , S.Int (Just Date) )++instance EncodeAvro Time.DiffTime where+  avro d = AvroM ( encodeRaw (fromIntegral $ diffTimeToMicros d :: Int)+                 , S.Long (Just TimeMicros) )+ -- Terminating word for array and map types. long0 :: Builder long0 = encodeRaw (0 :: Word64)@@ -265,8 +288,8 @@  -- | Maybe is modeled as a sum type `{null, a}`. instance EncodeAvro a => EncodeAvro (Maybe a) where-  avro Nothing  = AvroM (putI 0             , S.mkUnion (S.Null:|[S.Int]))-  avro (Just x) = AvroM (putI 1 <> putAvro x, S.mkUnion (S.Null:|[S.Int]))+  avro Nothing  = AvroM (putI 0             , S.mkUnion (S.Null:|[S.Int']))+  avro (Just x) = AvroM (putI 1 <> putAvro x, S.mkUnion (S.Null:|[S.Int']))  instance EncodeAvro () where   avro () = AvroM (mempty, S.Null)@@ -301,7 +324,7 @@       T.Enum sch@S.Enum{..} ix t -> AvroM (putI ix, sch)       T.Fixed ty bs  ->         if (B.length bs == size ty)-          then AvroM (byteString bs, S.Bytes)+          then AvroM (byteString bs, S.Bytes Nothing)           else error $ "Fixed type "  <> show (name ty)                       <> " has size " <> show (size ty)                       <> " but the value has length " <> show (B.length bs)

@@ -8,10 +8,13 @@ where  import           Control.Arrow           (first)+import           Control.Monad.Identity  (Identity(..)) import qualified Data.Avro.Encode        as E import           Data.Avro.HasAvroSchema import           Data.Avro.Schema        as S import           Data.Avro.Types         as T+import           Data.Avro.Types.Decimal as D+import           Data.Avro.Types.Time import qualified Data.ByteString         as B import           Data.ByteString.Lazy    (ByteString) import qualified Data.ByteString.Lazy    as BL@@ -25,9 +28,12 @@ import           Data.Text               (Text) import qualified Data.Text               as Text import qualified Data.Text.Lazy          as TL+import qualified Data.Time               as Time+import qualified Data.UUID               as UUID import qualified Data.Vector             as V import qualified Data.Vector.Unboxed     as U import           Data.Word+import           GHC.TypeLits  class HasAvroSchema a => FromAvro a where   fromAvro :: Value Schema -> Result a@@ -38,6 +44,13 @@     Nothing -> fail $ "Requested field not available: " <> show key     Just v  -> fromAvro v +instance (FromAvro a) => FromAvro (Identity a) where+  fromAvro e@(T.Union _ branch x)+    | S.matches branch sch = Identity <$> fromAvro x+    | otherwise            = badValue e "Identity"+    where Tagged sch = schema :: Tagged a Schema+  fromAvro x = badValue x "Identity"+ instance (FromAvro a, FromAvro b) => FromAvro (Either a b) where   fromAvro e@(T.Union _ branch x)     | S.matches branch schemaA = Left  <$> fromAvro x@@ -83,6 +96,28 @@   fromAvro (T.Float f) = pure f   fromAvro v           = badValue v "Float" +instance (KnownNat p, KnownNat s) => FromAvro (D.Decimal p s) where+  fromAvro (T.Long n) = pure $ D.fromUnderlyingValue $ fromIntegral n+  fromAvro (T.Int  n) = pure $ D.fromUnderlyingValue $ fromIntegral n+  fromAvro v          = badValue v "Decimal"++instance FromAvro UUID.UUID where+  fromAvro v@(T.String s)+    = case UUID.fromText s of+        Nothing -> badValue v "UUID"+        Just u  -> pure u+  fromAvro v = badValue v "UUID"++instance FromAvro Time.Day where+  fromAvro (T.Int  v) = pure $ fromDaysSinceEpoch (toInteger v)+  fromAvro (T.Long v) = pure $ fromDaysSinceEpoch (toInteger v)+  fromAvro v = badValue v "Date"++instance FromAvro Time.DiffTime where+  fromAvro (T.Int  v) = pure $ microsToDiffTime (toInteger v)+  fromAvro (T.Long v) = pure $ microsToDiffTime (toInteger v)+  fromAvro v = badValue v "TimeMicros"+ instance FromAvro a => FromAvro (Maybe a) where   fromAvro (T.Union ts _ v) = case (V.toList ts, v) of     ([S.Null, _], T.Null) -> pure Nothing@@ -119,4 +154,3 @@   fromAvro (T.Record _ mp) = mapM fromAvro mp   fromAvro (T.Map mp)      = mapM fromAvro mp   fromAvro v               = badValue v "HashMap Text a"-

@@ -1,30 +1,34 @@ {-# LANGUAGE ConstraintKinds      #-} {-# LANGUAGE FlexibleInstances    #-} {-# LANGUAGE ScopedTypeVariables  #-}-{-# LANGUAGE TypeSynonymInstances #-} module Data.Avro.HasAvroSchema where -import qualified Data.Array           as Ar-import           Data.Avro.Schema     as S-import           Data.Avro.Types      as T-import qualified Data.ByteString      as B-import           Data.ByteString.Lazy (ByteString)-import qualified Data.ByteString.Lazy as BL-import qualified Data.HashMap.Strict  as HashMap+import           Control.Monad.Identity  (Identity)+import qualified Data.Array              as Ar+import           Data.Avro.Schema        as S+import           Data.Avro.Types         as T+import           Data.Avro.Types.Decimal as D+import qualified Data.ByteString         as B+import           Data.ByteString.Lazy    (ByteString)+import qualified Data.ByteString.Lazy    as BL+import qualified Data.HashMap.Strict     as HashMap import           Data.Int-import           Data.Ix              (Ix)-import           Data.List.NonEmpty   (NonEmpty (..))-import qualified Data.Map             as Map-import           Data.Monoid          ((<>))+import           Data.Ix                (Ix)+import           Data.List.NonEmpty     (NonEmpty (..))+import qualified Data.Map               as Map+import           Data.Monoid            ((<>)) import           Data.Proxy-import qualified Data.Set             as S+import qualified Data.Set               as S import           Data.Tagged import           Data.Text            (Text) import qualified Data.Text            as Text import qualified Data.Text.Lazy       as TL+import qualified Data.Time            as Time+import qualified Data.UUID            as UUID import qualified Data.Vector          as V import qualified Data.Vector.Unboxed  as U import           Data.Word+import           GHC.TypeLits  class HasAvroSchema a where   schema :: Tagged a Schema@@ -33,16 +37,16 @@ schemaOf = witness schema  instance HasAvroSchema Word8 where-  schema = Tagged S.Int+  schema = Tagged S.Int'  instance HasAvroSchema Word16 where-  schema = Tagged S.Int+  schema = Tagged S.Int'  instance HasAvroSchema Word32 where-  schema = Tagged S.Long+  schema = Tagged S.Long'  instance HasAvroSchema Word64 where-  schema = Tagged S.Long+  schema = Tagged S.Long'  instance HasAvroSchema Bool where   schema = Tagged S.Boolean@@ -51,19 +55,19 @@   schema = Tagged S.Null  instance HasAvroSchema Int where-  schema = Tagged S.Long+  schema = Tagged S.Long'  instance HasAvroSchema Int8 where-  schema = Tagged S.Int+  schema = Tagged S.Int'  instance HasAvroSchema Int16 where-  schema = Tagged S.Int+  schema = Tagged S.Int'  instance HasAvroSchema Int32 where-  schema = Tagged S.Int+  schema = Tagged S.Int'  instance HasAvroSchema Int64 where-  schema = Tagged S.Long+  schema = Tagged S.Long'  instance HasAvroSchema Double where   schema = Tagged S.Double@@ -72,16 +76,36 @@   schema = Tagged S.Float  instance HasAvroSchema Text.Text where-  schema = Tagged S.String+  schema = Tagged S.String'  instance HasAvroSchema TL.Text where-  schema = Tagged S.String+  schema = Tagged S.String'  instance HasAvroSchema B.ByteString where-  schema = Tagged S.Bytes+  schema = Tagged S.Bytes'  instance HasAvroSchema BL.ByteString where-  schema = Tagged S.Bytes+  schema = Tagged S.Bytes'++instance (KnownNat p, KnownNat s) => HasAvroSchema (D.Decimal p s) where+  schema = Tagged $ S.Long (Just (DecimalL (S.Decimal pp ss)))+    where ss = natVal (Proxy :: Proxy s)+          pp = natVal (Proxy :: Proxy p)++instance HasAvroSchema UUID.UUID where+  schema = Tagged $ S.String (Just UUID)++instance HasAvroSchema Time.Day where+  schema = Tagged $ S.Int (Just Date)++instance HasAvroSchema Time.DiffTime where+  schema = Tagged $ S.Long (Just TimeMicros)++instance HasAvroSchema Time.UTCTime where+  schema = Tagged $ S.Long (Just TimestampMicros)++instance (HasAvroSchema a) => HasAvroSchema (Identity a) where+  schema = Tagged $ S.Union $ V.fromListN 1 [untag (schema :: Tagged a Schema)]  instance (HasAvroSchema a, HasAvroSchema b) => HasAvroSchema (Either a b) where   schema = Tagged $ S.Union $ V.fromListN 2 [untag (schema :: Tagged a Schema), untag (schema :: Tagged b Schema)]

@@ -6,6 +6,7 @@ {-# LANGUAGE MultiParamTypeClasses #-} {-# LANGUAGE NamedFieldPuns        #-} {-# LANGUAGE OverloadedStrings     #-}+{-# LANGUAGE PatternSynonyms       #-} {-# LANGUAGE RecordWildCards       #-} {-# LANGUAGE ScopedTypeVariables   #-} {-# LANGUAGE TupleSections         #-}@@ -20,9 +21,13 @@ module Data.Avro.Schema   (    -- * Schema description types-    Schema(..), Type+    Schema(.., Int', Long', Bytes', String'), Type   , Field(..), Order(..)   , TypeName(..)+  , Decimal(..)+  , LogicalTypeBytes(..), LogicalTypeFixed(..)+  , LogicalTypeInt(..), LogicalTypeLong(..)+  , LogicalTypeString(..)   , renderFullname   , parseFullname   , mkEnum, mkUnion@@ -94,11 +99,13 @@       -- Basic types         Null       | Boolean-      | Int   | Long+      | Int    { logicalTypeI :: Maybe LogicalTypeInt }+      | Long   { logicalTypeL :: Maybe LogicalTypeLong }       | Float | Double-      | Bytes | String-      | Array { item :: Schema }-      | Map   { values :: Schema }+      | Bytes  { logicalTypeB :: Maybe LogicalTypeBytes }+      | String { logicalTypeS :: Maybe LogicalTypeString }+      | Array  { item :: Schema }+      | Map    { values :: Schema }       | NamedType TypeName       -- Declared types       | Record { name    :: TypeName@@ -114,33 +121,63 @@              }       | Union { options     :: V.Vector Schema               }-      | Fixed { name    :: TypeName-              , aliases :: [TypeName]-              , size    :: Int+      | Fixed { name         :: TypeName+              , aliases      :: [TypeName]+              , size         :: Int+              , logicalTypeF :: Maybe LogicalTypeFixed               }-    deriving (Show, Generic, NFData)+    deriving (Ord, Show, Generic, NFData) +pattern Int'    = Int    Nothing+pattern Long'   = Long   Nothing+pattern Bytes'  = Bytes  Nothing+pattern String' = String Nothing++data Decimal+  = Decimal { precision :: Integer, scale :: Integer }+  deriving (Eq, Show, Ord, Generic, NFData)++newtype LogicalTypeBytes+  = DecimalB Decimal+  deriving (Eq, Show, Ord, Generic, NFData)++data LogicalTypeFixed+  = DecimalF Decimal | Duration+  deriving (Eq, Show, Ord, Generic, NFData)++data LogicalTypeInt+  = DecimalI Decimal | Date | TimeMillis+  deriving (Eq, Show, Ord, Generic, NFData)++data LogicalTypeLong+  = DecimalL Decimal | TimeMicros | TimestampMillis | TimestampMicros+  deriving (Eq, Show, Ord, Generic, NFData)++data LogicalTypeString+  = UUID+  deriving (Eq, Show, Ord, Generic, NFData)+ instance Eq Schema where   Null == Null = True   Boolean == Boolean = True-  Int == Int = True-  Long == Long = True+  Int lt1 == Int lt2 = lt1 == lt2+  Long lt1 == Long lt2 = lt1 == lt2   Float == Float = True   Double == Double = True-  Bytes == Bytes = True-  String == String = True+  Bytes lt1 == Bytes lt2 = lt1 == lt2+  String lt1 == String lt2 = lt1 == lt2    Array ty == Array ty2 = ty == ty2   Map ty == Map ty2 = ty == ty2   NamedType t == NamedType t2 = t == t2    Record name1 _ _ _ fs1 == Record name2 _ _ _ fs2 =-    and [name1 == name2, fs1 == fs2]+    (name1 == name2) && (fs1 == fs2)   Enum name1 _ _ s == Enum name2 _ _ s2 =-    and [name1 == name2, s == s2]+    (name1 == name2) && (s == s2)   Union a == Union b = a == b-  Fixed name1 _ s == Fixed name2 _ s2 =-    and [name1 == name2, s == s2]+  Fixed name1 _ s lt1 == Fixed name2 _ s2 lt2 =+    (name1 == name2) && (s == s2) && (lt1 == lt2)    _ == _ = False @@ -256,7 +293,7 @@   | isFullName name = parseFullname name   | otherwise       = case ns of       Just ns -> TN name $ filter (/= "") (T.splitOn "." ns)-      Nothing -> TN name $ fromMaybe [] $ namespace <$> context+      Nothing -> TN name $ maybe [] namespace context   where isFullName = isJust . T.find (== '.')  -- | This lets us write 'TypeName's as string literals in a fully@@ -275,19 +312,42 @@ typeName :: Schema -> Text typeName bt =   case bt of-    Null           -> "null"-    Boolean        -> "boolean"-    Int            -> "int"-    Long           -> "long"-    Float          -> "float"-    Double         -> "double"-    Bytes          -> "bytes"-    String         -> "string"-    Array _        -> "array"-    Map   _        -> "map"-    NamedType name -> renderFullname name-    Union ts       -> typeName (V.head ts)-    _              -> renderFullname $ name bt+    Null            -> "null"+    Boolean         -> "boolean"+    Int Nothing     -> "int"+    Int (Just (DecimalI d))+                    -> decimalName d+    Int (Just Date) -> "date"+    Int (Just TimeMillis)+                    -> "time-millis"+    Long Nothing    -> "long"+    Long (Just (DecimalL d))+                    -> decimalName d+    Long (Just TimeMicros)+                    -> "time-micros"+    Long (Just TimestampMillis)+                    -> "timestamp-millis"+    Long (Just TimestampMicros)+                    -> "timestamp-micros"+    Float           -> "float"+    Double          -> "double"+    Bytes Nothing   -> "bytes"+    Bytes (Just (DecimalB d))+                    -> decimalName d+    String Nothing  -> "string"+    String (Just UUID)+                    -> "uuid"+    Array _         -> "array"+    Map   _         -> "map"+    NamedType name  -> renderFullname name+    Union ts        -> typeName (V.head ts)+    Fixed _ _ _ (Just (DecimalF d))+                    -> decimalName d+    Fixed _ _ _ (Just Duration)+                    -> "duration"+    _               -> renderFullname $ name bt+  where+    decimalName (Decimal prec sc) = "decimal(" <> T.pack (show prec) <> "," <> T.pack (show sc) <> ")"  data Field = Field { fldName    :: Text                    , fldAliases :: [Text]@@ -296,7 +356,7 @@                    , fldType    :: Schema                    , fldDefault :: Maybe (Ty.Value Schema)                    }-  deriving (Eq, Show, Generic, NFData)+  deriving (Eq, Ord, Show, Generic, NFData)  data Order = Ascending | Descending | Ignore   deriving (Eq, Ord, Show, Generic, NFData)@@ -318,12 +378,18 @@   A.String s -> case s of     "null"    -> return Null     "boolean" -> return Boolean-    "int"     -> return Int-    "long"    -> return Long+    "int"     -> return $ Int Nothing+    "long"    -> return $ Long Nothing     "float"   -> return Float     "double"  -> return Double-    "bytes"   -> return Bytes-    "string"  -> return String+    "bytes"   -> return $ Bytes Nothing+    "string"  -> return $ String Nothing+    "uuid"    -> return $ String (Just UUID)+    "date"    -> return $ Int (Just Date)+    "time-millis" -> return $ Int (Just TimeMillis)+    "time-micros" -> return $ Long (Just TimeMicros)+    "timestamp-millis" -> return $ Long (Just TimestampMillis)+    "timestamp-micros" -> return $ Long (Just TimestampMicros)     somename  -> return $ NamedType $ mkTypeName context somename Nothing   A.Array arr     | V.length arr > 0 ->@@ -334,6 +400,37 @@     ty                        <- o .: "type"      case logicalType of+      Just "decimal" -> do+        prec <- o .: "precision"+        sc   <- fromMaybe 0 <$> o .:? "scale"+        let dec = Decimal prec sc+        case ty of+          "bytes" -> pure $ Bytes (Just (DecimalB dec))+          "fixed" -> (\fx -> fx { logicalTypeF = Just (DecimalF dec) }) <$> parseFixed o+          "int"   -> pure $ Int (Just (DecimalI dec))+          "long"  -> pure $ Long (Just (DecimalL dec))+          s       -> fail $ "Unsupported underlying type: " <> T.unpack s+      Just "uuid" -> case ty of+          "string" -> pure $ String (Just UUID)+          s        -> fail $ "Unsupported underlying type: " <> T.unpack s+      Just "date" -> case ty of+          "int" -> pure $ Int (Just Date)+          s     -> fail $ "Unsupported underlying type: " <> T.unpack s+      Just "time-millis" -> case ty of+          "int" -> pure $ Int (Just TimeMillis)+          s     -> fail $ "Unsupported underlying type: " <> T.unpack s+      Just "time-micros" -> case ty of+          "long" -> pure $ Long (Just TimeMicros)+          s      -> fail $ "Unsupported underlying type: " <> T.unpack s+      Just "timestamp-millis" -> case ty of+          "long" -> pure $ Long (Just TimestampMillis)+          s      -> fail $ "Unsupported underlying type: " <> T.unpack s+      Just "timestamp-micros" -> case ty of+          "long" -> pure $ Long (Just TimestampMicros)+          s      -> fail $ "Unsupported underlying type: " <> T.unpack s+      Just "duration" -> case ty of+          "fixed" -> (\fx -> fx { logicalTypeF = Just Duration }) <$> parseFixed o+          s      -> fail $ "Unsupported underlying type: " <> T.unpack s       Just _  -> parseJSON (A.String ty)       Nothing -> case ty of         "map"    -> Map <$> (parseSchemaJSON context =<< o .: "values")@@ -357,26 +454,29 @@           doc     <- o .:? "doc"           symbols <- o .: "symbols"           pure $ mkEnum typeName aliases doc symbols-        "fixed"  -> do-          name      <- o .: "name"-          namespace <- o .:? "namespace"-          let typeName = mkTypeName context name namespace-              mkAlias name = mkTypeName (Just typeName) name Nothing-          aliases <- mkAliases typeName <$> (o .:? "aliases" .!= [])-          size    <- o .: "size"-          pure $ Fixed typeName aliases size+        "fixed"   -> parseFixed o         "null"    -> pure Null         "boolean" -> pure Boolean-        "int"     -> pure Int-        "long"    -> pure Long+        "int"     -> pure $ Int Nothing+        "long"    -> pure $ Long Nothing         "float"   -> pure Float         "double"  -> pure Double-        "bytes"   -> pure Bytes-        "string"  -> pure String+        "bytes"   -> pure $ Bytes Nothing+        "string"  -> pure $ String Nothing         s        -> fail $ "Unrecognized object type: " <> T.unpack s    invalid    -> typeMismatch "Invalid JSON for Avro Schema" invalid +  where+    parseFixed o = do+      name      <- o .: "name"+      namespace <- o .:? "namespace"+      let typeName = mkTypeName context name namespace+          mkAlias name = mkTypeName (Just typeName) name Nothing+      aliases <- mkAliases typeName <$> (o .:? "aliases" .!= [])+      size    <- o .: "size"+      pure $ Fixed typeName aliases size Nothing+ -- | Parse aliases, inferring the namespace based on the type being aliases. mkAliases :: TypeName              -- ^ The name of the type being aliased.@@ -428,20 +528,41 @@                 -- ^ The schema to serialize to JSON.              -> A.Value schemaToJSON context = \case-  Null           -> A.String "null"-  Boolean        -> A.String "boolean"-  Int            -> A.String "int"-  Long           -> A.String "long"-  Float          -> A.String "float"-  Double         -> A.String "double"-  Bytes          -> A.String "bytes"-  String         -> A.String "string"-  Array tn       ->+  Null            -> A.String "null"+  Boolean         -> A.String "boolean"+  Int Nothing     -> A.String "int"+  Int (Just (DecimalI (Decimal prec sc))) ->+    object [ "type" .= ("int" :: Text), "logicalType" .= ("decimal" :: Text)+           , "precision" .= prec, "scale" .= sc ]+  Int (Just Date) ->+    object [ "type" .= ("int" :: Text), "logicalType" .= ("date" :: Text) ]+  Int (Just TimeMillis) ->+    object [ "type" .= ("int" :: Text), "logicalType" .= ("time-millis" :: Text) ]+  Long Nothing    -> A.String "long"+  Long (Just (DecimalL (Decimal prec sc))) ->+    object [ "type" .= ("long" :: Text), "logicalType" .= ("decimal" :: Text)+           , "precision" .= prec, "scale" .= sc ]+  Long (Just TimeMicros) ->+    object [ "type" .= ("long" :: Text), "logicalType" .= ("time-micros" :: Text) ]+  Long (Just TimestampMillis) ->+    object [ "type" .= ("long" :: Text), "logicalType" .= ("timestamp-millis" :: Text) ]+  Long (Just TimestampMicros) ->+    object [ "type" .= ("long" :: Text), "logicalType" .= ("timestamp-micros" :: Text) ]+  Float           -> A.String "float"+  Double          -> A.String "double"+  Bytes Nothing   -> A.String "bytes"+  Bytes (Just (DecimalB (Decimal prec sc))) ->+    object [ "type" .= ("bytes" :: Text), "logicalType" .= ("decimal" :: Text)+           , "precision" .= prec, "scale" .= sc ]+  String Nothing  -> A.String "string"+  String (Just UUID) -> +    object [ "type" .= ("string" :: Text), "logicalType" .= ("uuid" :: Text) ]+  Array tn        ->     object [ "type" .= ("array" :: Text), "items" .= schemaToJSON context tn ]-  Map tn         ->+  Map tn          ->     object [ "type" .= ("map" :: Text), "values" .= schemaToJSON context tn ]-  NamedType name -> toJSON $ render context name-  Record {..}    ->+  NamedType name  -> toJSON $ render context name+  Record {..}     ->     let opts = catMaybes           [ ("order" .=) <$> order           , ("doc" .=)   <$> doc@@ -462,11 +583,19 @@        ]   Union  {..} -> toJSON $ schemaToJSON context <$> options   Fixed  {..} ->-    object [ "type"    .= ("fixed" :: Text)+    let basic = +           [ "type"    .= ("fixed" :: Text)            , "name"    .= render context name            , "aliases" .= (render (Just name) <$> aliases)            , "size"    .= size            ]+        extended = case logicalTypeF of+          Nothing       -> []+          Just Duration -> [ "logicalType" .= ("duration" :: Text) ]+          Just (DecimalF (Decimal prec sc))+                   -> [ "logicalType" .= ("decimal" :: Text)+                      , "precision" .= prec, "scale" .= sc ]+    in object (basic ++ extended)   where render context typeName           | Just ctx <- context           , namespace ctx == namespace typeName = baseName typeName@@ -588,17 +717,17 @@   case env name of     Nothing -> fail $ "Could not resolve type name for " <> T.unpack (renderFullname name)     Just t  -> parseAvroJSON union env t av-parseAvroJSON union _ u@Union{} av             = union u av+parseAvroJSON union _ u@Union{} av             = u `union` av parseAvroJSON union env ty av                  =     case av of       A.String s      ->         case ty of-          String      -> return $ Ty.String s+          String _    -> return $ Ty.String s           Enum {..}   ->               case s `V.elemIndex` symbols of                 Just i  -> pure $ Ty.Enum ty i s                 Nothing -> fail $ "JSON string is not one of the expected symbols for enum '" <> show name <> "': " <> T.unpack s-          Bytes       -> Ty.Bytes <$> parseBytes s+          Bytes _     -> Ty.Bytes <$> parseBytes s           Fixed {..}  -> do             bytes <- parseBytes s             let len = B.length bytes@@ -610,8 +739,8 @@                           _       -> avroTypeMismatch ty "boolean"       A.Number i     ->         case ty of-          Int    -> return $ Ty.Int    (floor i)-          Long   -> return $ Ty.Long   (floor i)+          Int _  -> return $ Ty.Int    (floor i)+          Long _ -> return $ Ty.Long   (floor i)           Float  -> return $ Ty.Float  (realToFrac i)           Double -> return $ Ty.Double (realToFrac i)           _      -> avroTypeMismatch ty "number"

@@ -5,10 +5,13 @@  where +import           Control.Monad.Identity  (Identity(..)) import           Control.Arrow           (first) import           Data.Avro.HasAvroSchema import           Data.Avro.Schema        as S import           Data.Avro.Types         as T+import           Data.Avro.Types.Decimal as D+import           Data.Avro.Types.Time import qualified Data.ByteString         as B import           Data.ByteString.Lazy    (ByteString) import qualified Data.ByteString.Lazy    as BL@@ -16,13 +19,17 @@ import           Data.Int import           Data.List.NonEmpty      (NonEmpty (..)) import qualified Data.Map                as Map+import           Data.Maybe              (fromJust) import           Data.Tagged import           Data.Text               (Text) import qualified Data.Text               as Text import qualified Data.Text.Lazy          as TL+import qualified Data.Time               as Time+import qualified Data.UUID               as UUID import qualified Data.Vector             as V import qualified Data.Vector.Unboxed     as U import           Data.Word+import           GHC.TypeLits  class HasAvroSchema a => ToAvro a where   toAvro :: a -> T.Value Schema@@ -62,6 +69,24 @@  instance ToAvro BL.ByteString where   toAvro = T.Bytes . BL.toStrict++instance (KnownNat p, KnownNat s) => ToAvro (D.Decimal p s) where+  toAvro = T.Long . fromIntegral . fromJust . D.underlyingValue++instance ToAvro UUID.UUID where+  toAvro = T.String . UUID.toText++instance ToAvro Time.Day where+  toAvro = T.Long . fromIntegral . daysSinceEpoch++instance ToAvro Time.DiffTime where+  toAvro = T.Long . fromIntegral . diffTimeToMicros++instance (ToAvro a) => ToAvro (Identity a) where+  toAvro e@(Identity a) =+    let sch = options (schemaOf e)+    in+      T.Union sch (schemaOf a) (toAvro a)  instance (ToAvro a, ToAvro b) => ToAvro (Either a b) where   toAvro e =

@@ -0,0 +1,33 @@+{-# LANGUAGE DataKinds                  #-}+{-# LANGUAGE FlexibleContexts           #-}+{-# LANGUAGE GeneralizedNewtypeDeriving #-}+{-# LANGUAGE PolyKinds                  #-}+{-# LANGUAGE ScopedTypeVariables        #-}+module Data.Avro.Types.Decimal where++import qualified Data.BigDecimal as D+import           Data.Proxy+import           GHC.TypeLits++newtype Decimal (p :: Nat) (s :: Nat)+  = Decimal { unDecimal :: D.BigDecimal }+  deriving (Eq, Ord, Show, Read, Num, Fractional, Real)++fromUnderlyingValue+  :: forall p s. KnownNat s+  => Integer -> Decimal p s+fromUnderlyingValue n+  = Decimal $ D.BigDecimal n (natVal (Proxy :: Proxy s))++underlyingValue+  :: forall s p. (KnownNat p, KnownNat s)+  => Decimal p s -> Maybe Int+underlyingValue (Decimal d)+  = let ss = natVal (Proxy :: Proxy s)+        pp = natVal (Proxy :: Proxy p)+        new = if ss > D.getScale d+                 then D.BigDecimal (D.getValue d * 10 ^ (ss - D.getScale d)) ss+                 else D.roundBD d (D.halfUp ss)+    in if D.precision new > pp+          then Nothing+          else Just $ fromInteger $ D.getValue new

@@ -0,0 +1,28 @@+{-# LANGUAGE CPP #-}+module Data.Avro.Types.Time where++-- Utility functions to work with times++import Data.Maybe (fromJust)+import Data.Time+import Data.Time.Clock+#if MIN_VERSION_time(1,9,0)+import Data.Time.Format.Internal+#else+import Data.Time.Format+#endif++epochDate :: Day+epochDate = fromJust $ buildTime defaultTimeLocale []++daysSinceEpoch :: Day -> Integer+daysSinceEpoch d = diffDays d epochDate++fromDaysSinceEpoch :: Integer -> Day+fromDaysSinceEpoch n = addDays n epochDate++diffTimeToMicros :: DiffTime -> Integer+diffTimeToMicros = (`div` 1000000) . diffTimeToPicoseconds++microsToDiffTime :: Integer -> DiffTime+microsToDiffTime = picosecondsToDiffTime . (* 1000000)

@@ -28,4 +28,4 @@       | Union (Vector f) f (Value f) -- ^ Set of union options, schema for selected option, and the actual value.       | Fixed f {-# UNPACK #-} !ByteString       | Enum f {-# UNPACK #-} !Int Text  -- ^ An enum is a set of the possible symbols (the schema) and the selected symbol-  deriving (Eq, Show, Generic, NFData)+  deriving (Eq, Ord, Show, Generic, NFData)

@@ -34,7 +34,7 @@ onlyInt64Schema =   let fld nm = Field nm [] Nothing Nothing    in Record "test.contract.OnlyInt64" [] Nothing Nothing-        [ fld "onlyInt64Value"    Long Nothing+        [ fld "onlyInt64Value"    Long' Nothing         ]  instance HasAvroSchema OnlyInt64 where

@@ -25,15 +25,15 @@ childTypeSchema =   let fld nm = Field nm [] Nothing Nothing   in Record "test.contract.ChildType" [] Nothing Nothing-        [ fld "childValue1" Long Nothing-        , fld "childValue2" Long Nothing+        [ fld "childValue1" Long' Nothing+        , fld "childValue2" Long' Nothing         ]  parentTypeSchema :: Schema parentTypeSchema =   let fld nm = Field nm [] Nothing Nothing   in Record "test.contract.ParentType" [] Nothing Nothing-        [ fld "parentValue1" Long             Nothing+        [ fld "parentValue1" Long'             Nothing         , fld "parentValue2" (Array childTypeSchema)  Nothing]  instance HasAvroSchema ParentType where

@@ -22,7 +22,7 @@ onlyTextSchema =   let fld nm = Field nm [] Nothing Nothing   in Record "test.contract.OnlyText" [] Nothing Nothing-        [ fld "onlyTextValue" String Nothing+        [ fld "onlyTextValue" String' Nothing         ]  instance HasAvroSchema OnlyText where

@@ -35,7 +35,7 @@       msgSchema = schemaOf (undefined :: MaybeTest)       fixedSchema = schemaOf (undefined :: FixedTag)       defaults = fldDefault <$> fields msgSchema-    in defaults `shouldBe` [ Just $ Ty.Union (V.fromList [Null, String]) Null Ty.Null+    in defaults `shouldBe` [ Just $ Ty.Union (V.fromList [Null, String']) Null Ty.Null                            , Just $ Ty.Fixed fixedSchema "\0\42\255"                            , Just $ Ty.Bytes "\0\37\255"                            ]

@@ -6,9 +6,11 @@  import Control.Monad (forM_) -import qualified Data.Aeson           as Aeson-import qualified Data.ByteString.Lazy as LBS-import qualified Data.Map             as Map+import           Control.Monad.Identity (Identity (..))+import qualified Data.Aeson             as Aeson+import qualified Data.ByteString        as BS+import qualified Data.ByteString.Lazy   as LBS+import qualified Data.Map               as Map  import Data.Avro.Deriving import Data.Avro.EitherN@@ -75,9 +77,15 @@         , unionsRecords     = Left $ Foo { fooStuff = "stuff" }         , unionsSameFields  = Left $ Foo { fooStuff = "foo stuff" }         , unionsArrayAndMap = Left ["foo"]+        , unionsOne         = Identity 42         , unionsThree       = E3_1 37         , unionsFour        = E4_2 "foo"         , unionsFive        = E5_4 $ Foo { fooStuff = "foo stuff" }+        , unionsSix        = E6_2 "foo"+        , unionsSeven        = E7_6 6.28+        , unionsEight        = E8_3 37+        , unionsNine        = E9_1 37+        , unionsTen        = E10_9 $ BS.pack [70, 79, 79, 66, 65, 82]         }       unionsExampleB = Unions         { unionsScalars     = Right 37@@ -87,9 +95,17 @@                                           }         , unionsSameFields  = Right $ NotFoo { notFooStuff = "not foo stuff" }         , unionsArrayAndMap = Right $ Map.fromList [("a", 5)]+        , unionsOne         = Identity 42         , unionsThree       = E3_3 37         , unionsFour        = E4_4 $ Foo { fooStuff = "foo stuff" }         , unionsFive        = E5_5 $ NotFoo { notFooStuff = "not foo stuff" }+        , unionsSix        = E6_6 6.28+        , unionsSeven        = E7_7 False+        , unionsEight        = E8_8 2.718+        , unionsNine        = E9_9 $ BS.pack [70, 79, 79, 66, 65, 82]+        , unionsTen        = E10_10 $ Bar { barStuff = "bar stuff",+                                            barThings = Foo { fooStuff = "things" }+                                          }         }   it "should roundtrip (unions)" $ do     forM_ [unionsExampleA, unionsExampleB] $ \ msg ->

@@ -7,15 +7,18 @@  import qualified Data.List.NonEmpty as NE -import qualified Data.Aeson           as Aeson++import           Control.Monad.Identity (Identity (..))+import qualified Data.Aeson             as Aeson import           Data.Avro import           Data.Avro.Deriving import           Data.Avro.EitherN-import qualified Data.Avro.Schema     as Schema-import qualified Data.Avro.Types      as Avro-import qualified Data.ByteString.Lazy as LBS-import qualified Data.Map             as Map-import qualified Data.Vector          as V+import qualified Data.Avro.Schema       as Schema+import qualified Data.Avro.Types        as Avro+import qualified Data.ByteString        as BS+import qualified Data.ByteString.Lazy   as LBS+import qualified Data.Map               as Map+import qualified Data.Vector            as V  import System.Directory (doesFileExist) @@ -33,9 +36,15 @@         , unionsRecords     = Left $ Foo { fooStuff = "stuff" }         , unionsSameFields  = Left $ Foo { fooStuff = "more stuff" }         , unionsArrayAndMap = Left ["foo"]+        , unionsOne         = Identity 42         , unionsThree       = E3_1 37         , unionsFour        = E4_2 "foo"         , unionsFive        = E5_4 $ Foo { fooStuff = "foo stuff" }+        , unionsSix        = E6_2 "foo"+        , unionsSeven        = E7_6 6.28+        , unionsEight        = E8_3 37+        , unionsNine        = E9_1 37+        , unionsTen        = E10_9 $ BS.pack [70, 79, 79, 66, 65, 82]         }       objB = Unions         { unionsScalars     = Right 42@@ -45,9 +54,17 @@                                           }         , unionsSameFields  = Right $ NotFoo { notFooStuff = "different from Foo" }         , unionsArrayAndMap = Right $ Map.fromList [("a", 5)]+        , unionsOne         = Identity 42         , unionsThree       = E3_3 37         , unionsFour        = E4_4 $ Foo { fooStuff = "foo stuff" }         , unionsFive        = E5_5 $ NotFoo { notFooStuff = "not foo stuff" }+        , unionsSix        = E6_6 6.28+        , unionsSeven        = E7_7 False+        , unionsEight        = E8_8 2.718+        , unionsNine        = E9_9 $ BS.pack [70, 79, 79, 66, 65, 82]+        , unionsTen        = E10_10 $ Bar { barStuff = "bar stuff",+                                            barThings = Foo { fooStuff = "things" }+                                          }         }        field name schema def = Schema.Field name [] Nothing (Just Schema.Ascending) schema def@@ -57,29 +74,36 @@        foo    = named "haskell.avro.example.Foo"       notFoo = named "haskell.avro.example.NotFoo"+      bar = named "haskell.avro.example.Bar"       expectedSchema = record "haskell.avro.example.Unions"-        [ field "scalars"     (Schema.mkUnion (NE.fromList [Schema.String, Schema.Long])) scalarsDefault-        , field "nullable"    (Schema.mkUnion (NE.fromList [Schema.Null, Schema.Int]))    nullableDefault+        [ field "scalars"     (Schema.mkUnion (NE.fromList [Schema.String', Schema.Long'])) scalarsDefault+        , field "nullable"    (Schema.mkUnion (NE.fromList [Schema.Null, Schema.Int']))    nullableDefault         , field "records"     (Schema.mkUnion (NE.fromList [fooSchema, barSchema]))       Nothing         , field "sameFields"  (Schema.mkUnion (NE.fromList [foo, notFooSchema]))          Nothing         , field "arrayAndMap" (Schema.mkUnion (NE.fromList [array, map]))                 Nothing -        , field "three" (Schema.mkUnion (NE.fromList [Schema.Int, Schema.String, Schema.Long]))              Nothing-        , field "four"  (Schema.mkUnion (NE.fromList [Schema.Int, Schema.String, Schema.Long, foo]))         Nothing-        , field "five"  (Schema.mkUnion (NE.fromList [Schema.Int, Schema.String, Schema.Long, foo, notFoo])) Nothing+        , field "one"   (Schema.mkUnion (NE.fromList [Schema.Int']))                                          Nothing+        , field "three" (Schema.mkUnion (NE.fromList [Schema.Int', Schema.String', Schema.Long']))              Nothing+        , field "four"  (Schema.mkUnion (NE.fromList [Schema.Int', Schema.String', Schema.Long', foo]))         Nothing+        , field "five"  (Schema.mkUnion (NE.fromList [Schema.Int', Schema.String', Schema.Long', foo, notFoo])) Nothing+        , field "six"  (Schema.mkUnion (NE.fromList [Schema.Int', Schema.String', Schema.Long', foo, notFoo, Schema.Float])) Nothing+        , field "seven"  (Schema.mkUnion (NE.fromList [Schema.Int', Schema.String', Schema.Long', foo, notFoo, Schema.Float, Schema.Boolean])) Nothing+        , field "eight"  (Schema.mkUnion (NE.fromList [Schema.Int', Schema.String', Schema.Long', foo, notFoo, Schema.Float, Schema.Boolean, Schema.Double])) Nothing+        , field "nine"  (Schema.mkUnion (NE.fromList [Schema.Int', Schema.String', Schema.Long', foo, notFoo, Schema.Float, Schema.Boolean, Schema.Double, Schema.Bytes'])) Nothing+        , field "ten"  (Schema.mkUnion (NE.fromList [Schema.Int', Schema.String', Schema.Long', foo, notFoo, Schema.Float, Schema.Boolean, Schema.Double, Schema.Bytes', bar])) Nothing         ]-      scalarsDefault  = Just $ Avro.Union (V.fromList [Schema.String, Schema.Long]) Schema.String (Avro.String "foo")-      nullableDefault = Just $ Avro.Union (V.fromList [Schema.Null, Schema.Int])    Schema.Null   Avro.Null+      scalarsDefault  = Just $ Avro.Union (V.fromList [Schema.String', Schema.Long']) Schema.String' (Avro.String "foo")+      nullableDefault = Just $ Avro.Union (V.fromList [Schema.Null, Schema.Int'])    Schema.Null   Avro.Null -      fooSchema = record "haskell.avro.example.Foo" [field "stuff" Schema.String Nothing]+      fooSchema = record "haskell.avro.example.Foo" [field "stuff" Schema.String' Nothing]       barSchema = record "haskell.avro.example.Bar"-        [ field "stuff"  Schema.String Nothing+        [ field "stuff"  Schema.String' Nothing         , field "things" (named "haskell.avro.example.Foo") Nothing         ]-      notFooSchema = record "haskell.avro.example.NotFoo" [field "stuff" Schema.String Nothing]+      notFooSchema = record "haskell.avro.example.NotFoo" [field "stuff" Schema.String' Nothing] -      array = Schema.Array { Schema.item = Schema.String }-      map   = Schema.Map { Schema.values = Schema.Long }+      array = Schema.Array { Schema.item = Schema.String' }+      map   = Schema.Map { Schema.values = Schema.Long' }    unionsSchemaFile <- runIO $ getFileName "test/data/unions.avsc" >>= LBS.readFile   let Just unionsSchemaFromJSON = Aeson.decode unionsSchemaFile

@@ -33,10 +33,10 @@ tmSchema =   let fld nm = Field nm [] Nothing Nothing    in Record "avro.haskell.test.TypesTestMessage" [] Nothing Nothing-        [ fld "id" Long Nothing-        , fld "name" String Nothing-        , fld "timestamp" (mkUnion (Null :| [Long])) Nothing-        , fld "foreignId" (mkUnion (Null :| [Long])) Nothing+        [ fld "id" Long' Nothing+        , fld "name" String' Nothing+        , fld "timestamp" (mkUnion (Null :| [Long'])) Nothing+        , fld "foreignId" (mkUnion (Null :| [Long'])) Nothing         , fld "competence" (mkUnion (Null :| [Double])) Nothing         , fld "relevance" (mkUnion (Null :| [Float])) Nothing         , fld "severity" Float Nothing

@@ -23,11 +23,11 @@ msSchema =   Record "MyStruct" [] Nothing Nothing       [ fld "enumOrString" eOrS (Just $ Ty.String "The Default")-      , fld "intvalue" Long Nothing+      , fld "intvalue" Long' Nothing       ]      where      fld nm ty def = Field nm [] Nothing Nothing ty def-     eOrS = mkUnion (meSchema :| [String])+     eOrS = mkUnion (meSchema :| [String'])  -- Encoding data, via the ToAvro class, requires both the routine that encodes -- data as well as the schema under which it is encoded.  The encoding and

@@ -16,9 +16,15 @@   "arrayAndMap" : {     "array" : ["foo"]   },+  "one": { "int": 42 },   "three": { "int": 37 },   "four": { "string": "foo" },   "five": {     "haskell.avro.example.Foo": { "stuff": "foo stuff" }-  }+  },+  "six": { "string": "foo" },+  "seven": { "float": 6.28 },+  "eight": { "long": 37 },+  "nine": { "int": 37 },+  "ten": { "bytes": "FOOBAR" } }

@@ -21,11 +21,22 @@   "arrayAndMap" : {     "map" : { "a" : 5 }   },+  "one": { "int": 42 },   "three": { "long": 37 },   "four": {     "haskell.avro.example.Foo": { "stuff" : "foo stuff" }   },   "five": {     "haskell.avro.example.NotFoo": { "stuff": "not foo stuff" }+  },+  "six": { "float": 6.28 },+  "seven": { "boolean": false },+  "eight": { "double": 2.718 },+  "nine": { "bytes": "FOOBAR" },+  "ten": {+    "haskell.avro.example.Bar": {+      "stuff": "bar stuff",+      "things": { "stuff": "things" }+    }   } }

@@ -54,8 +54,14 @@         }       ]     },+    { "name" : "one", "type" : ["int"] },     { "name" : "three", "type" : ["int", "string", "long"] },     { "name" : "four", "type" : ["int", "string", "long", "Foo"] },-    { "name" : "five", "type" : ["int", "string", "long", "Foo", "NotFoo"] }+    { "name" : "five", "type" : ["int", "string", "long", "Foo", "NotFoo"] },+    { "name" : "six", "type" : ["int", "string", "long", "Foo", "NotFoo", "float"] },+    { "name" : "seven", "type" : ["int", "string", "long", "Foo", "NotFoo", "float", "boolean"] },+    { "name" : "eight", "type" : ["int", "string", "long", "Foo", "NotFoo", "float", "boolean", "double"] },+    { "name" : "nine", "type" : ["int", "string", "long", "Foo", "NotFoo", "float", "boolean", "double", "bytes"] },+    { "name" : "ten", "type" : ["int", "string", "long", "Foo", "NotFoo", "float", "boolean", "double", "bytes", "Bar"] }   ] }