isomorphism-class 0.2.1.2 → 0.3

raw patch · 57 files changed

+202/−639 lines, 57 filesPVP ok

version bump matches the API change (PVP)

API changes (from Hackage documentation)

Files

• CHANGELOG.md +5/−0
• isomorphism-class.cabal +4/−13
• library/IsomorphismClass.hs +20/−43
• library/IsomorphismClass/Classes.hs +1/−2
• library/IsomorphismClass/Classes/Is.hs +0/−52
• library/IsomorphismClass/Classes/IsSome.hs +0/−52
• library/IsomorphismClass/Classes/IsomorphicTo.hs +54/−0
• library/IsomorphismClass/Laws.hs +0/−81
• library/IsomorphismClass/Optics.hs +2/−10
• library/IsomorphismClass/Properties.hs +38/−0
• library/IsomorphismClass/Proxies.hs +0/−3
• library/IsomorphismClass/Proxies/ViaIsSome.hs +0/−68
• library/IsomorphismClass/Relations.hs +0/−6
• library/IsomorphismClass/Relations/BoxedVectorAndList.hs +2/−6
• library/IsomorphismClass/Relations/BoxedVectorAndSeq.hs +2/−6
• library/IsomorphismClass/Relations/ByteArrayAndByteString.hs +2/−6
• library/IsomorphismClass/Relations/ByteArrayAndLazyByteString.hs +2/−6
• library/IsomorphismClass/Relations/ByteArrayAndLazyByteStringBuilder.hs +2/−6
• library/IsomorphismClass/Relations/ByteArrayAndShortByteString.hs +2/−6
• library/IsomorphismClass/Relations/ByteArrayAndTextArray.hs +2/−6
• library/IsomorphismClass/Relations/ByteArrayAndWord8List.hs +2/−6
• library/IsomorphismClass/Relations/ByteStringAndLazyByteString.hs +2/−6
• library/IsomorphismClass/Relations/ByteStringAndLazyByteStringBuilder.hs +2/−6
• library/IsomorphismClass/Relations/ByteStringAndShortByteString.hs +2/−6
• library/IsomorphismClass/Relations/ByteStringAndText.hs +0/−11
• library/IsomorphismClass/Relations/ByteStringAndTextArray.hs +2/−6
• library/IsomorphismClass/Relations/ByteStringAndWord8List.hs +2/−6
• library/IsomorphismClass/Relations/Int16AndWord16.hs +2/−6
• library/IsomorphismClass/Relations/Int32AndWord32.hs +2/−6
• library/IsomorphismClass/Relations/Int64AndWord64.hs +2/−6
• library/IsomorphismClass/Relations/Int8AndWord8.hs +2/−6
• library/IsomorphismClass/Relations/IntAndWord.hs +2/−6
• library/IsomorphismClass/Relations/IntMapAndMapOfInt.hs +2/−6
• library/IsomorphismClass/Relations/IntSetAndSetOfInt.hs +2/−6
• library/IsomorphismClass/Relations/LazyByteStringAndLazyByteStringBuilder.hs +2/−6
• library/IsomorphismClass/Relations/LazyByteStringAndLazyText.hs +0/−13
• library/IsomorphismClass/Relations/LazyByteStringAndShortByteString.hs +2/−6
• library/IsomorphismClass/Relations/LazyByteStringAndTextArray.hs +2/−6
• library/IsomorphismClass/Relations/LazyByteStringAndWord8List.hs +2/−6
• library/IsomorphismClass/Relations/LazyByteStringBuilderAndShortByteString.hs +2/−7
• library/IsomorphismClass/Relations/LazyByteStringBuilderAndTextArray.hs +2/−6
• library/IsomorphismClass/Relations/LazyByteStringBuilderAndWord8List.hs +2/−6
• library/IsomorphismClass/Relations/LazyTextAndLazyTextBuilder.hs +2/−8
• library/IsomorphismClass/Relations/LazyTextAndStrictTextBuilder.hs +2/−6
• library/IsomorphismClass/Relations/LazyTextAndString.hs +0/−12
• library/IsomorphismClass/Relations/LazyTextAndText.hs +2/−6
• library/IsomorphismClass/Relations/LazyTextBuilderAndStrictTextBuilder.hs +2/−6
• library/IsomorphismClass/Relations/LazyTextBuilderAndString.hs +0/−13
• library/IsomorphismClass/Relations/LazyTextBuilderAndText.hs +2/−8
• library/IsomorphismClass/Relations/ListAndSeq.hs +2/−6
• library/IsomorphismClass/Relations/ShortByteStringAndTextArray.hs +2/−6
• library/IsomorphismClass/Relations/ShortByteStringAndWord8List.hs +2/−6
• library/IsomorphismClass/Relations/StrictTextBuilderAndString.hs +0/−17
• library/IsomorphismClass/Relations/StrictTextBuilderAndText.hs +4/−4
• library/IsomorphismClass/Relations/StringAndText.hs +0/−16
• library/IsomorphismClass/Relations/TextArrayAndWord8List.hs +2/−6
• test/Main.hs +2/−2

@@ -1,4 +1,9 @@ +# 0.3++- Extracted the `Is` and `IsSome` typeclasses into a separate library ["lawful-conversions"](https://github.com/nikita-volkov/lawful-conversions)+- Restored the `IsomorphicTo` typeclass from the `0.1` design without restoring the `String` instance and the `showAs` utility+ # 0.2  - `IsomorphicTo` renamed to `Is`

@@ -1,7 +1,7 @@ cabal-version: 3.0 name: isomorphism-class-version: 0.2.1.2-synopsis: Lawful typeclasses for conversion between types+version: 0.3+synopsis: Isomorphism typeclass solving the conversion problem category: Conversion homepage: https://github.com/nikita-volkov/isomorphism-class bug-reports: https://github.com/nikita-volkov/isomorphism-class/issues@@ -37,13 +37,10 @@   exposed-modules: IsomorphismClass   other-modules:     IsomorphismClass.Classes-    IsomorphismClass.Classes.Is-    IsomorphismClass.Classes.IsSome-    IsomorphismClass.Laws+    IsomorphismClass.Classes.IsomorphicTo     IsomorphismClass.Optics     IsomorphismClass.Prelude-    IsomorphismClass.Proxies-    IsomorphismClass.Proxies.ViaIsSome+    IsomorphismClass.Properties     IsomorphismClass.Relations     IsomorphismClass.Relations.BoxedVectorAndList     IsomorphismClass.Relations.BoxedVectorAndSeq@@ -56,7 +53,6 @@     IsomorphismClass.Relations.ByteStringAndLazyByteString     IsomorphismClass.Relations.ByteStringAndLazyByteStringBuilder     IsomorphismClass.Relations.ByteStringAndShortByteString-    IsomorphismClass.Relations.ByteStringAndText     IsomorphismClass.Relations.ByteStringAndTextArray     IsomorphismClass.Relations.ByteStringAndWord8List     IsomorphismClass.Relations.Int16AndWord16@@ -67,7 +63,6 @@     IsomorphismClass.Relations.IntMapAndMapOfInt     IsomorphismClass.Relations.IntSetAndSetOfInt     IsomorphismClass.Relations.LazyByteStringAndLazyByteStringBuilder-    IsomorphismClass.Relations.LazyByteStringAndLazyText     IsomorphismClass.Relations.LazyByteStringAndShortByteString     IsomorphismClass.Relations.LazyByteStringAndTextArray     IsomorphismClass.Relations.LazyByteStringAndWord8List@@ -76,17 +71,13 @@     IsomorphismClass.Relations.LazyByteStringBuilderAndWord8List     IsomorphismClass.Relations.LazyTextAndLazyTextBuilder     IsomorphismClass.Relations.LazyTextAndStrictTextBuilder-    IsomorphismClass.Relations.LazyTextAndString     IsomorphismClass.Relations.LazyTextAndText     IsomorphismClass.Relations.LazyTextBuilderAndStrictTextBuilder-    IsomorphismClass.Relations.LazyTextBuilderAndString     IsomorphismClass.Relations.LazyTextBuilderAndText     IsomorphismClass.Relations.ListAndSeq     IsomorphismClass.Relations.ShortByteStringAndTextArray     IsomorphismClass.Relations.ShortByteStringAndWord8List-    IsomorphismClass.Relations.StrictTextBuilderAndString     IsomorphismClass.Relations.StrictTextBuilderAndText-    IsomorphismClass.Relations.StringAndText     IsomorphismClass.Relations.TextArrayAndWord8List     IsomorphismClass.TextCompat.Array 

@@ -1,5 +1,3 @@-{-# LANGUAGE CPP #-}- -- | -- Lawful solution to the conversion problem. --@@ -26,10 +24,10 @@ -- the user and no way to check whether an instance is correct. -- -- This library tackles this problem with a lawful typeclass, making it--- evident what any of its instances do and it provides property-tests for you+-- evident what any of its instances do and it provides a property-test for you -- to validate your instances. ----- = The insight+-- = The laws -- -- The key insight of this library is that if you add a requirement for the -- conversion to be lossless and to have a mirror conversion in the opposite@@ -57,30 +55,23 @@ -- perform a conversion between two types. The only difference between them -- is in what the first type application parameter specifies. E.g.: ----- > toString = to @String+-- > toText = to @Text ----- > fromText = from @Text+-- > fromBuilder = from @Builder -- -- The types are self-evident: ----- > > :t to @String--- > to @String :: Is String b => b -> String+-- > > :t to @Text+-- > to @Text :: IsomorphicTo Text b => b -> Text ----- > > :t from @Text--- > from @Text :: Is Text b => Text -> b+-- > > :t from @Builder+-- > from @Builder :: IsomorphicTo Builder b => Builder -> b -- -- In other words 'to' and 'from' let you explicitly specify either the source -- or the target type of a conversion when you need to help the type--- inferencer.------ Here are more practical examples:+-- inferencer or the reader. ----- @--- renderNameAndHeight :: 'Text' -> 'Int' -> 'Text'--- renderNameAndHeight name height =---   'from' @'Data.Text.Encoding.StrictTextBuilder' $---     "Height of " <> 'to' name <> " is " <> 'to' (show height)--- @+-- = Examples -- -- @ -- combineEncodings :: 'Data.ByteString.Short.ShortByteString' -> 'Data.Primitive.ByteArray' -> 'Data.ByteString.Lazy.ByteString' -> [Word8]@@ -89,40 +80,26 @@ --     'to' a <> 'to' b <> 'to' c -- @ ----- = Partial conversions------ Atop of all said this library also captures the notion of smart constructors via the 'IsSome' class, which associates a total 'to' conversion with partial 'maybeFrom'.------ This captures the codec relationship between types.--- E.g.,------ - Every 'Int16' can be losslessly converted into 'Int32', but not every 'Int32' can be losslessly converted into 'Int16'.------ - Every 'Text' can be converted into 'ByteString' via UTF-8 encoding, but not every 'ByteString' forms a valid UTF-8 sequence.------ - Every URL can be uniquely represented as 'Text', but most 'Text's are not URLs unfortunately.+-- @+-- renderNameAndHeight :: 'Text' -> 'Int' -> 'Text'+-- renderNameAndHeight name height =+--   'from' @'Data.Text.Encoding.StrictTextBuilder' $+--     "Height of " <> 'to' name <> " is " <> 'fromString' (show height)+-- @ module IsomorphismClass   ( -- * Typeclasses-    Is,-    IsSome (..),+    IsomorphicTo (..),     from,      -- * Optics-    isSomePrism,-    isIso,--    -- * Instance derivation--    -- | Proxy data-types useful for deriving various standard instances using the @DerivingVia@ extension.-    module IsomorphismClass.Proxies,+    isomorphicToIso,      -- * Testing-    module IsomorphismClass.Laws,+    module IsomorphismClass.Properties,   ) where  import IsomorphismClass.Classes-import IsomorphismClass.Laws import IsomorphismClass.Optics-import IsomorphismClass.Proxies+import IsomorphismClass.Properties import IsomorphismClass.Relations ()

@@ -1,4 +1,3 @@ module IsomorphismClass.Classes (module Exports) where -import IsomorphismClass.Classes.Is as Exports-import IsomorphismClass.Classes.IsSome as Exports+import IsomorphismClass.Classes.IsomorphicTo as Exports

@@ -1,52 +0,0 @@-module IsomorphismClass.Classes.Is where--import IsomorphismClass.Classes.IsSome---- | Bidirectional conversion between two types with no loss of information.------ The bidirectionality is encoded via a recursive dependency with arguments--- flipped.------ You can read the signature @Is a b@ as \"/B/ is /A/\".------ === Laws------ /B/ is isomorphic to /A/ if and only if there exists a conversion from /B/--- to /A/ ('to') and a conversion from /A/ to /B/ ('from') such that:------ - @'from' . 'to' = 'id'@ - For all values of /B/ converting from /B/ to /A/---     and then converting from /A/ to /B/ produces a value that is identical---     to the original.------ - @'to' . 'from' = 'id'@ - For all values of /A/ converting from /A/ to /B/---     and then converting from /B/ to /A/ produces a value that is identical---     to the original.------ For testing whether your instances conform to these laws use 'IsomorphismClass.isLawsProperties'.------ === Instance Definition------ For each pair of isomorphic types (/A/ and /B/) the compiler will require--- you to define four instances, namely: @Is A B@ and @Is B A@ as well as @IsSome A B@ and @IsSome B A@.------ === Testing------ For testing whether your instances conform to these laws use 'IsomorphismClass.isLawsProperties'.-class (IsSome a b, Is b a) => Is a b---- | Any type is isomorphic to itself.-instance Is a a---- |--- 'to' in reverse direction.------ Particularly useful in combination with the @TypeApplications@ extension,--- where it allows to specify the input type, e.g.:------ > fromText :: Is Text b => Text -> b--- > fromText = from @Text------ The first type application of the 'to' function on the other hand specifies--- the output data type.-from :: (Is a b) => a -> b-from = to

@@ -1,52 +0,0 @@-module IsomorphismClass.Classes.IsSome where--import IsomorphismClass.Prelude---- |--- Evidence that all values of type @sub@ form a subset of all values of type @sup@.------ [From Wikipedia](https://en.wikipedia.org/wiki/Subset):------ In mathematics, a set A is a subset of a set B if all elements of A are also elements of B; B is then a superset of A. It is possible for A and B to be equal; if they are unequal, then A is a proper subset of B. The relationship of one set being a subset of another is called inclusion (or sometimes containment). A is a subset of B may also be expressed as B includes (or contains) A or A is included (or contained) in B. A k-subset is a subset with k elements.------ === Laws------ ==== 'to' is injective------ For every two values of type @sub@ that are not equal converting with 'to' will always produce values that are not equal.------ > \(a, b) -> a == b || to a /= to b------ ==== 'maybeFrom' is an inverse of 'to'------ For all values of @sub@ converting to @sup@ and then attempting to convert back to @sub@ always succeeds and produces a value that is equal to the original.------ > \a -> maybeFrom (to a) == Just a------ === Testing------ For testing whether your instances conform to these laws use 'IsomorphismClass.isSomeLawsProperties'.-class IsSome sup sub where-  -- |-  -- Convert a value of a subset type to a superset type.-  ---  -- This function is injective non-surjective.-  to :: sub -> sup--  -- |-  -- [Partial inverse](https://en.wikipedia.org/wiki/Inverse_function#Partial_inverses) of 'to'.-  ---  -- This function is a [partial bijection](https://en.wikipedia.org/wiki/Bijection#Generalization_to_partial_functions).-  maybeFrom :: sup -> Maybe sub-  default maybeFrom :: (IsSome sub sup) => sup -> Maybe sub-  maybeFrom = Just . to---- | Every type is isomorphic to itself.-instance IsSome a a where-  to = id-  maybeFrom = Just . id---- | The empty set has no elements, and therefore is vacuously a subset of any set.-instance IsSome sup Void where-  to = absurd-  maybeFrom = const Nothing

@@ -0,0 +1,54 @@+module IsomorphismClass.Classes.IsomorphicTo where++import IsomorphismClass.Prelude++-- | Bidirectional conversion between two types with no loss of information.+--+-- The bidirectionality is encoded via a recursive dependency with arguments+-- flipped.+--+-- You can read the signature @IsomorphicTo a b@ as \"/B/ is isomorphic to /A/\".+--+-- === Laws+--+-- /B/ is isomorphic to /A/ if and only if there exists a conversion from /B/+-- to /A/ ('to') and a conversion from /A/ to /B/ ('from') such that:+--+-- - @'from' . 'to' = 'id'@ - For all values of /B/ converting from /B/ to /A/+--     and then converting from /A/ to /B/ produces a value that is identical+--     to the original.+--+-- - @'to' . 'from' = 'id'@ - For all values of /A/ converting from /A/ to /B/+--     and then converting from /B/ to /A/ produces a value that is identical+--     to the original.+--+-- === Testing+--+-- For testing whether your instances conform to these laws use 'IsomorphismClass.isomorphicToProperties'.+--+-- === Instance Definition+--+-- For each pair of isomorphic types (/A/ and /B/) the compiler will require+-- you to define two instances, namely: @IsomorphicTo A B@ and @IsomorphicTo B A@.+class (IsomorphicTo b a) => IsomorphicTo a b where+  -- |+  -- Convert a value into an isomophic type.+  to :: b -> a++-- | Every type is isomorphic to itself.+instance IsomorphicTo a a where+  to = id++-- |+-- 'to' in reverse direction.+--+-- Particularly useful in combination with the @TypeApplications@ extension,+-- where it allows to specify the input type, e.g.:+--+-- > fromText :: IsomorphicTo Text b => Text -> b+-- > fromText = from @Text+--+-- The first type application of the 'to' function on the other hand specifies+-- the output data type.+from :: (IsomorphicTo a b) => a -> b+from = to

@@ -1,81 +0,0 @@-module IsomorphismClass.Laws-  ( isSomeLawsProperties,-    isLawsProperties,-  )-where--import IsomorphismClass.Classes-import IsomorphismClass.Prelude-import Test.QuickCheck---- |--- Properties testing whether an instance satisfies the laws of 'IsSome'.------ The instance is identified via the proxy types that you provide.------ E.g., here's how you can integrate it into an Hspec test-suite:------ > spec = do--- >   describe "IsSome laws" do--- >     traverse_--- >       (uncurry prop)--- >       (isSomeLawsProperties @Int32 @Int16 Proxy Proxy)-isSomeLawsProperties ::-  (IsSome a b, Eq a, Eq b, Show a, Arbitrary b, Show b) =>-  Proxy a ->-  Proxy b ->-  [(String, Property)]-isSomeLawsProperties superp subp =-  [ ( "'to' is injective",-      property \a b ->-        a /= b ==>-          to' a =/= to' b-    ),-    ( "'maybeFrom' is an inverse of 'to'",-      property \a ->-        maybeFrom' (to' a) === Just a-    )-  ]-  where-    to' = as superp . to . as subp-    maybeFrom' = fmap (as subp) . maybeFrom . as superp-    as = flip asProxyTypeOf---- |--- Properties testing whether an instance satisfies the laws of 'Is'.------ The instance is identified via the proxy types that you provide.------ E.g., here's how you can integrate it into an Hspec test-suite:------ > spec = do--- >   describe "Is laws" do--- >     traverse_--- >       (uncurry prop)--- >       (isLawsProperties @Int32 @Word32 Proxy Proxy)-isLawsProperties ::-  (Is a b, Eq a, Eq b, Arbitrary a, Show a, Arbitrary b, Show b) =>-  Proxy a ->-  Proxy b ->-  [(String, Property)]-isLawsProperties superp subp =-  [ directedLaws "↻" superp subp,-    directedLaws "↺" subp superp-  ]-    & mconcat-  where-    directedLaws prefix ap bp =-      ( ( "Isomorphic: Law 1",-          property \b ->-            b === to (asProxyTypeOf (to (asProxyTypeOf b bp)) ap)-        )-          : prefixEachName "Partially isomorphic: " (isSomeLawsProperties ap bp)-      )-        & prefixEachName (prefix <> ": ")--prefixEachName ::-  String ->-  [(String, Property)] ->-  [(String, Property)]-prefixEachName prefix =-  (fmap . first) (mappend prefix)

@@ -4,14 +4,6 @@ import IsomorphismClass.Classes import IsomorphismClass.Prelude --- | Van-Laarhoven-style Prism, compatible with the \"lens\" library.-isSomePrism :: (IsSome a b, Choice p, Applicative f) => p b (f b) -> p a (f a)-isSomePrism =-  dimap-    (\s -> maybe (Left s) Right (maybeFrom s))-    (either pure (fmap to))-    . right'- -- | Van-Laarhoven-style Isomorphism, compatible with the \"lens\" library.-isIso :: (Is a b, Profunctor p, Functor f) => p b (f b) -> p a (f a)-isIso = dimap from (fmap to)+isomorphicToIso :: (IsomorphicTo a b, Profunctor p, Functor f) => p b (f b) -> p a (f a)+isomorphicToIso = dimap from (fmap to)

@@ -0,0 +1,38 @@+module IsomorphismClass.Properties+  ( isomorphicToProperties,+  )+where++import IsomorphismClass.Classes+import IsomorphismClass.Prelude+import Test.QuickCheck++-- |+-- Properties testing whether an instance satisfies the laws of 'IsomorphicTo'.+--+-- The instance is identified via the proxy types that you provide.+--+-- E.g., here's how you can integrate it into an Hspec test-suite:+--+-- > spec = do+-- >   describe "IsomorphicTo laws" do+-- >     traverse_+-- >       (uncurry prop)+-- >       (isomorphicToProperties @Int32 @Word32 Proxy Proxy)+isomorphicToProperties ::+  (IsomorphicTo a b, Eq a, Eq b, Arbitrary a, Show a, Arbitrary b, Show b) =>+  Proxy a ->+  Proxy b ->+  [(String, Property)]+isomorphicToProperties aProxy bProxy =+  [ ( "from . to = id",+      property \b -> b === from' (to' b)+    ),+    ( "to . from = id",+      property \b -> b === to' (from' b)+    )+  ]+  where+    to' = as aProxy . to . as bProxy+    from' = as bProxy . from . as aProxy+    as = flip asProxyTypeOf

@@ -1,3 +0,0 @@-module IsomorphismClass.Proxies (module Exports) where--import IsomorphismClass.Proxies.ViaIsSome as Exports

@@ -1,68 +0,0 @@-module IsomorphismClass.Proxies.ViaIsSome where--import IsomorphismClass.Classes-import IsomorphismClass.Prelude-import qualified Test.QuickCheck as QuickCheck---- |--- Helper for deriving common instances on types which have an instance of @'IsSome' sup@ using the @DerivingVia@ extension.------ E.g.,------ > newtype Percent = Percent Double--- >   deriving newtype (Show, Eq, Ord)--- >   deriving (Read, Arbitrary) via (ViaIsSome Double Percent)--- >--- > instance IsSome Double Percent where--- >   to (Percent double) = double--- >   maybeFrom double =--- >     if double < 0 || double > 1--- >       then Nothing--- >       else Just (Percent double)------ In the code above all the instances that are able to construct the values of 'Percent' are automatically derived based on the @IsSome Double Percent@ instance.--- This guarantees that they only construct values that pass thru the checks defined in 'maybeFrom'.-newtype ViaIsSome sup sub = ViaIsSome sub--instance (IsSome sup sub) => IsSome sup (ViaIsSome sup sub) where-  to (ViaIsSome a) = to a-  maybeFrom = fmap ViaIsSome . maybeFrom--instance IsSome sub (ViaIsSome sup sub) where-  to = coerce--instance IsSome (ViaIsSome sup sub) sub where-  to = coerce--instance Is sub (ViaIsSome sup sub)--instance Is (ViaIsSome sup sub) sub--instance (IsSome sup sub, Show sup) => Show (ViaIsSome sup sub) where-  show (ViaIsSome a) = show (to @sup a)--instance (IsSome sup sub, Read sup) => Read (ViaIsSome sup sub) where-  readPrec = do-    sup <- readPrec-    case maybeFrom @sup sup of-      Just a -> pure (ViaIsSome a)-      Nothing -> fail "Value is not from the subset"--instance (IsSome sup sub, IsString sup) => IsString (ViaIsSome sup sub) where-  fromString =-    maybe (error "Value is not from the subset") ViaIsSome . maybeFrom @sup . fromString--instance (IsSome sup sub, Eq sup) => Eq (ViaIsSome sup sub) where-  (==) = on (==) (to @sup)--instance (IsSome sup sub, Ord sup) => Ord (ViaIsSome sup sub) where-  compare = on compare (to @sup)--instance (IsSome sup sub, QuickCheck.Arbitrary sup) => QuickCheck.Arbitrary (ViaIsSome sup sub) where-  arbitrary =-    QuickCheck.suchThatMap QuickCheck.arbitrary (maybeFrom @sup)-  shrink value = do-    shrunkValue <- QuickCheck.shrink (to @sup value)-    shrunkValue-      & maybeFrom-      & maybeToList

@@ -11,7 +11,6 @@ import IsomorphismClass.Relations.ByteStringAndLazyByteString as Exports import IsomorphismClass.Relations.ByteStringAndLazyByteStringBuilder as Exports import IsomorphismClass.Relations.ByteStringAndShortByteString as Exports-import IsomorphismClass.Relations.ByteStringAndText as Exports import IsomorphismClass.Relations.ByteStringAndTextArray as Exports import IsomorphismClass.Relations.ByteStringAndWord8List as Exports import IsomorphismClass.Relations.Int16AndWord16 as Exports@@ -22,7 +21,6 @@ import IsomorphismClass.Relations.IntMapAndMapOfInt as Exports import IsomorphismClass.Relations.IntSetAndSetOfInt as Exports import IsomorphismClass.Relations.LazyByteStringAndLazyByteStringBuilder as Exports-import IsomorphismClass.Relations.LazyByteStringAndLazyText as Exports import IsomorphismClass.Relations.LazyByteStringAndShortByteString as Exports import IsomorphismClass.Relations.LazyByteStringAndTextArray as Exports import IsomorphismClass.Relations.LazyByteStringAndWord8List as Exports@@ -31,15 +29,11 @@ import IsomorphismClass.Relations.LazyByteStringBuilderAndWord8List as Exports import IsomorphismClass.Relations.LazyTextAndLazyTextBuilder as Exports import IsomorphismClass.Relations.LazyTextAndStrictTextBuilder as Exports-import IsomorphismClass.Relations.LazyTextAndString as Exports import IsomorphismClass.Relations.LazyTextAndText as Exports import IsomorphismClass.Relations.LazyTextBuilderAndStrictTextBuilder as Exports-import IsomorphismClass.Relations.LazyTextBuilderAndString as Exports import IsomorphismClass.Relations.LazyTextBuilderAndText as Exports import IsomorphismClass.Relations.ListAndSeq as Exports import IsomorphismClass.Relations.ShortByteStringAndTextArray as Exports import IsomorphismClass.Relations.ShortByteStringAndWord8List as Exports-import IsomorphismClass.Relations.StrictTextBuilderAndString as Exports import IsomorphismClass.Relations.StrictTextBuilderAndText as Exports-import IsomorphismClass.Relations.StringAndText as Exports import IsomorphismClass.Relations.TextArrayAndWord8List as Exports

@@ -6,12 +6,8 @@ import IsomorphismClass.Classes import IsomorphismClass.Prelude -instance IsSome (Vector a) [a] where+instance IsomorphicTo (Vector a) [a] where   to = Data.Vector.fromList -instance IsSome [a] (Vector a) where+instance IsomorphicTo [a] (Vector a) where   to = Data.Vector.toList--instance Is (Vector a) [a]--instance Is [a] (Vector a)

@@ -7,12 +7,8 @@ import IsomorphismClass.Classes import IsomorphismClass.Prelude -instance IsSome (Vector a) (Seq a) where+instance IsomorphicTo (Vector a) (Seq a) where   to = Data.Vector.fromList . toList -instance IsSome (Seq a) (Vector a) where+instance IsomorphicTo (Seq a) (Vector a) where   to = Data.Sequence.fromList . Data.Vector.toList--instance Is (Vector a) (Seq a)--instance Is (Seq a) (Vector a)

@@ -9,12 +9,8 @@ import IsomorphismClass.Relations.ByteArrayAndShortByteString () import IsomorphismClass.Relations.ByteStringAndShortByteString () -instance IsSome Data.Primitive.ByteArray.ByteArray ByteString where+instance IsomorphicTo Data.Primitive.ByteArray.ByteArray ByteString where   to = to . to @Data.ByteString.Short.ShortByteString -instance IsSome ByteString Data.Primitive.ByteArray.ByteArray where+instance IsomorphicTo ByteString Data.Primitive.ByteArray.ByteArray where   to = to . to @Data.ByteString.Short.ShortByteString--instance Is Data.Primitive.ByteArray.ByteArray ByteString--instance Is ByteString Data.Primitive.ByteArray.ByteArray

@@ -10,12 +10,8 @@ import IsomorphismClass.Relations.ByteArrayAndShortByteString () import IsomorphismClass.Relations.LazyByteStringAndShortByteString () -instance IsSome Data.ByteString.Lazy.ByteString Data.Primitive.ByteArray.ByteArray where+instance IsomorphicTo Data.ByteString.Lazy.ByteString Data.Primitive.ByteArray.ByteArray where   to = to . to @Data.ByteString.Short.ShortByteString -instance IsSome Data.Primitive.ByteArray.ByteArray Data.ByteString.Lazy.ByteString where+instance IsomorphicTo Data.Primitive.ByteArray.ByteArray Data.ByteString.Lazy.ByteString where   to = to . to @Data.ByteString.Short.ShortByteString--instance Is Data.Primitive.ByteArray.ByteArray Data.ByteString.Lazy.ByteString--instance Is Data.ByteString.Lazy.ByteString Data.Primitive.ByteArray.ByteArray

@@ -10,12 +10,8 @@ import IsomorphismClass.Relations.ByteArrayAndShortByteString () import IsomorphismClass.Relations.LazyByteStringBuilderAndShortByteString () -instance IsSome Data.Primitive.ByteArray.ByteArray Data.ByteString.Builder.Builder where+instance IsomorphicTo Data.Primitive.ByteArray.ByteArray Data.ByteString.Builder.Builder where   to = to . to @Data.ByteString.Short.ShortByteString -instance IsSome Data.ByteString.Builder.Builder Data.Primitive.ByteArray.ByteArray where+instance IsomorphicTo Data.ByteString.Builder.Builder Data.Primitive.ByteArray.ByteArray where   to = to . to @Data.ByteString.Short.ShortByteString--instance Is Data.Primitive.ByteArray.ByteArray Data.ByteString.Builder.Builder--instance Is Data.ByteString.Builder.Builder Data.Primitive.ByteArray.ByteArray

@@ -7,14 +7,10 @@ import qualified Data.Primitive.ByteArray import IsomorphismClass.Classes -instance IsSome Data.ByteString.Short.ShortByteString Data.Primitive.ByteArray.ByteArray where+instance IsomorphicTo Data.ByteString.Short.ShortByteString Data.Primitive.ByteArray.ByteArray where   to (Data.Primitive.ByteArray.ByteArray array) =     Data.ByteString.Short.Internal.SBS array -instance IsSome Data.Primitive.ByteArray.ByteArray Data.ByteString.Short.ShortByteString where+instance IsomorphicTo Data.Primitive.ByteArray.ByteArray Data.ByteString.Short.ShortByteString where   to (Data.ByteString.Short.Internal.SBS array) =     Data.Primitive.ByteArray.ByteArray array--instance Is Data.Primitive.ByteArray.ByteArray Data.ByteString.Short.ShortByteString--instance Is Data.ByteString.Short.ShortByteString Data.Primitive.ByteArray.ByteArray

@@ -11,14 +11,10 @@ import IsomorphismClass.Prelude import qualified IsomorphismClass.TextCompat.Array -instance IsSome Data.Primitive.ByteArray.ByteArray Data.Text.Array.Array where+instance IsomorphicTo Data.Primitive.ByteArray.ByteArray Data.Text.Array.Array where   to = IsomorphismClass.TextCompat.Array.toByteArray -instance IsSome Data.Text.Array.Array Data.Primitive.ByteArray.ByteArray where+instance IsomorphicTo Data.Text.Array.Array Data.Primitive.ByteArray.ByteArray where   to = IsomorphismClass.TextCompat.Array.fromByteArray--instance Is Data.Primitive.ByteArray.ByteArray Data.Text.Array.Array--instance Is Data.Text.Array.Array Data.Primitive.ByteArray.ByteArray  #endif

@@ -7,12 +7,8 @@ import IsomorphismClass.Prelude import IsomorphismClass.Relations.ByteArrayAndShortByteString () -instance IsSome Data.Primitive.ByteArray.ByteArray [Word8] where+instance IsomorphicTo Data.Primitive.ByteArray.ByteArray [Word8] where   to = fromList -instance IsSome [Word8] Data.Primitive.ByteArray.ByteArray where+instance IsomorphicTo [Word8] Data.Primitive.ByteArray.ByteArray where   to = toList--instance Is Data.Primitive.ByteArray.ByteArray [Word8]--instance Is [Word8] Data.Primitive.ByteArray.ByteArray

@@ -6,12 +6,8 @@ import IsomorphismClass.Classes import IsomorphismClass.Prelude -instance IsSome ByteString Data.ByteString.Lazy.ByteString where+instance IsomorphicTo ByteString Data.ByteString.Lazy.ByteString where   to = Data.ByteString.Lazy.toStrict -instance IsSome Data.ByteString.Lazy.ByteString ByteString where+instance IsomorphicTo Data.ByteString.Lazy.ByteString ByteString where   to = Data.ByteString.Lazy.fromStrict--instance Is ByteString Data.ByteString.Lazy.ByteString--instance Is Data.ByteString.Lazy.ByteString ByteString

@@ -7,12 +7,8 @@ import IsomorphismClass.Classes import IsomorphismClass.Prelude -instance IsSome ByteString Data.ByteString.Builder.Builder where+instance IsomorphicTo ByteString Data.ByteString.Builder.Builder where   to = Data.ByteString.Lazy.toStrict . Data.ByteString.Builder.toLazyByteString -instance IsSome Data.ByteString.Builder.Builder ByteString where+instance IsomorphicTo Data.ByteString.Builder.Builder ByteString where   to = Data.ByteString.Builder.byteString--instance Is Data.ByteString.Builder.Builder ByteString--instance Is ByteString Data.ByteString.Builder.Builder

@@ -6,12 +6,8 @@ import IsomorphismClass.Classes import IsomorphismClass.Prelude -instance IsSome ByteString Data.ByteString.Short.ShortByteString where+instance IsomorphicTo ByteString Data.ByteString.Short.ShortByteString where   to = Data.ByteString.Short.fromShort -instance IsSome Data.ByteString.Short.ShortByteString ByteString where+instance IsomorphicTo Data.ByteString.Short.ShortByteString ByteString where   to = Data.ByteString.Short.toShort--instance Is ByteString Data.ByteString.Short.ShortByteString--instance Is Data.ByteString.Short.ShortByteString ByteString

@@ -1,11 +0,0 @@-{-# OPTIONS_GHC -Wno-orphans #-}--module IsomorphismClass.Relations.ByteStringAndText where--import qualified Data.Text.Encoding-import IsomorphismClass.Classes-import IsomorphismClass.Prelude--instance IsSome ByteString Text where-  to = Data.Text.Encoding.encodeUtf8-  maybeFrom = either (const Nothing) Just . Data.Text.Encoding.decodeUtf8'

@@ -11,14 +11,10 @@ import IsomorphismClass.Prelude import qualified IsomorphismClass.TextCompat.Array -instance IsSome ByteString Data.Text.Array.Array where+instance IsomorphicTo ByteString Data.Text.Array.Array where   to = Data.ByteString.Short.fromShort . IsomorphismClass.TextCompat.Array.toShortByteString -instance IsSome Data.Text.Array.Array ByteString where+instance IsomorphicTo Data.Text.Array.Array ByteString where   to = IsomorphismClass.TextCompat.Array.fromShortByteString . Data.ByteString.Short.toShort--instance Is ByteString Data.Text.Array.Array--instance Is Data.Text.Array.Array ByteString  #endif

@@ -6,12 +6,8 @@ import IsomorphismClass.Classes import IsomorphismClass.Prelude -instance IsSome ByteString [Word8] where+instance IsomorphicTo ByteString [Word8] where   to = Data.ByteString.pack -instance IsSome [Word8] ByteString where+instance IsomorphicTo [Word8] ByteString where   to = Data.ByteString.unpack--instance Is ByteString [Word8]--instance Is [Word8] ByteString

@@ -5,12 +5,8 @@ import IsomorphismClass.Classes import IsomorphismClass.Prelude -instance IsSome Int16 Word16 where+instance IsomorphicTo Int16 Word16 where   to = fromIntegral -instance IsSome Word16 Int16 where+instance IsomorphicTo Word16 Int16 where   to = fromIntegral--instance Is Int16 Word16--instance Is Word16 Int16

@@ -5,12 +5,8 @@ import IsomorphismClass.Classes import IsomorphismClass.Prelude -instance IsSome Int32 Word32 where+instance IsomorphicTo Int32 Word32 where   to = fromIntegral -instance IsSome Word32 Int32 where+instance IsomorphicTo Word32 Int32 where   to = fromIntegral--instance Is Int32 Word32--instance Is Word32 Int32

@@ -5,12 +5,8 @@ import IsomorphismClass.Classes import IsomorphismClass.Prelude -instance IsSome Int64 Word64 where+instance IsomorphicTo Int64 Word64 where   to = fromIntegral -instance IsSome Word64 Int64 where+instance IsomorphicTo Word64 Int64 where   to = fromIntegral--instance Is Int64 Word64--instance Is Word64 Int64

@@ -5,12 +5,8 @@ import IsomorphismClass.Classes import IsomorphismClass.Prelude -instance IsSome Int8 Word8 where+instance IsomorphicTo Int8 Word8 where   to = fromIntegral -instance IsSome Word8 Int8 where+instance IsomorphicTo Word8 Int8 where   to = fromIntegral--instance Is Int8 Word8--instance Is Word8 Int8

@@ -5,12 +5,8 @@ import IsomorphismClass.Classes import IsomorphismClass.Prelude -instance IsSome Int Word where+instance IsomorphicTo Int Word where   to = fromIntegral -instance IsSome Word Int where+instance IsomorphicTo Word Int where   to = fromIntegral--instance Is Int Word--instance Is Word Int

@@ -7,12 +7,8 @@ import IsomorphismClass.Classes import IsomorphismClass.Prelude -instance IsSome (Map Int v) (IntMap v) where+instance IsomorphicTo (Map Int v) (IntMap v) where   to = Data.Map.Strict.fromList . Data.IntMap.Strict.toList -instance IsSome (IntMap v) (Map Int v) where+instance IsomorphicTo (IntMap v) (Map Int v) where   to = Data.IntMap.Strict.fromList . Data.Map.Strict.toList--instance Is (Map Int v) (IntMap v)--instance Is (IntMap v) (Map Int v)

@@ -5,12 +5,8 @@ import IsomorphismClass.Classes import IsomorphismClass.Prelude -instance IsSome (Set Int) IntSet where+instance IsomorphicTo (Set Int) IntSet where   to = fromList . toList -instance IsSome IntSet (Set Int) where+instance IsomorphicTo IntSet (Set Int) where   to = fromList . toList--instance Is (Set Int) IntSet--instance Is IntSet (Set Int)

@@ -6,12 +6,8 @@ import qualified Data.ByteString.Lazy import IsomorphismClass.Classes -instance IsSome Data.ByteString.Lazy.ByteString Data.ByteString.Builder.Builder where+instance IsomorphicTo Data.ByteString.Lazy.ByteString Data.ByteString.Builder.Builder where   to = Data.ByteString.Builder.toLazyByteString -instance IsSome Data.ByteString.Builder.Builder Data.ByteString.Lazy.ByteString where+instance IsomorphicTo Data.ByteString.Builder.Builder Data.ByteString.Lazy.ByteString where   to = Data.ByteString.Builder.lazyByteString--instance Is Data.ByteString.Lazy.ByteString Data.ByteString.Builder.Builder--instance Is Data.ByteString.Builder.Builder Data.ByteString.Lazy.ByteString

@@ -1,13 +0,0 @@-{-# OPTIONS_GHC -Wno-orphans #-}--module IsomorphismClass.Relations.LazyByteStringAndLazyText where--import qualified Data.ByteString.Lazy-import qualified Data.Text.Lazy-import qualified Data.Text.Lazy.Encoding-import IsomorphismClass.Classes-import IsomorphismClass.Prelude--instance IsSome Data.ByteString.Lazy.ByteString Data.Text.Lazy.Text where-  to = Data.Text.Lazy.Encoding.encodeUtf8-  maybeFrom = either (const Nothing) Just . Data.Text.Lazy.Encoding.decodeUtf8'

@@ -7,12 +7,8 @@ import IsomorphismClass.Classes import IsomorphismClass.Prelude -instance IsSome Data.ByteString.Lazy.ByteString Data.ByteString.Short.ShortByteString where+instance IsomorphicTo Data.ByteString.Lazy.ByteString Data.ByteString.Short.ShortByteString where   to = Data.ByteString.Lazy.fromStrict . Data.ByteString.Short.fromShort -instance IsSome Data.ByteString.Short.ShortByteString Data.ByteString.Lazy.ByteString where+instance IsomorphicTo Data.ByteString.Short.ShortByteString Data.ByteString.Lazy.ByteString where   to = Data.ByteString.Short.toShort . Data.ByteString.Lazy.toStrict--instance Is Data.ByteString.Lazy.ByteString Data.ByteString.Short.ShortByteString--instance Is Data.ByteString.Short.ShortByteString Data.ByteString.Lazy.ByteString

@@ -12,20 +12,16 @@ import IsomorphismClass.Prelude import qualified IsomorphismClass.TextCompat.Array -instance IsSome Data.ByteString.Lazy.ByteString Data.Text.Array.Array where+instance IsomorphicTo Data.ByteString.Lazy.ByteString Data.Text.Array.Array where   to =     Data.ByteString.Lazy.fromStrict       . Data.ByteString.Short.fromShort       . IsomorphismClass.TextCompat.Array.toShortByteString -instance IsSome Data.Text.Array.Array Data.ByteString.Lazy.ByteString where+instance IsomorphicTo Data.Text.Array.Array Data.ByteString.Lazy.ByteString where   to =     IsomorphismClass.TextCompat.Array.fromShortByteString       . Data.ByteString.Short.toShort       . Data.ByteString.Lazy.toStrict--instance Is Data.Text.Array.Array Data.ByteString.Lazy.ByteString--instance Is Data.ByteString.Lazy.ByteString Data.Text.Array.Array  #endif

@@ -6,12 +6,8 @@ import IsomorphismClass.Classes import IsomorphismClass.Prelude -instance IsSome Data.ByteString.Lazy.ByteString [Word8] where+instance IsomorphicTo Data.ByteString.Lazy.ByteString [Word8] where   to = Data.ByteString.Lazy.pack -instance IsSome [Word8] Data.ByteString.Lazy.ByteString where+instance IsomorphicTo [Word8] Data.ByteString.Lazy.ByteString where   to = Data.ByteString.Lazy.unpack--instance Is Data.ByteString.Lazy.ByteString [Word8]--instance Is [Word8] Data.ByteString.Lazy.ByteString

@@ -8,13 +8,8 @@ import IsomorphismClass.Classes import IsomorphismClass.Prelude -instance IsSome Data.ByteString.Builder.Builder Data.ByteString.Short.ShortByteString where+instance IsomorphicTo Data.ByteString.Builder.Builder Data.ByteString.Short.ShortByteString where   to = Data.ByteString.Builder.shortByteString -instance IsSome Data.ByteString.Short.ShortByteString Data.ByteString.Builder.Builder where+instance IsomorphicTo Data.ByteString.Short.ShortByteString Data.ByteString.Builder.Builder where   to = Data.ByteString.Short.toShort . Data.ByteString.Lazy.toStrict . Data.ByteString.Builder.toLazyByteString-  maybeFrom = Just . Data.ByteString.Builder.shortByteString--instance Is Data.ByteString.Builder.Builder Data.ByteString.Short.ShortByteString--instance Is Data.ByteString.Short.ShortByteString Data.ByteString.Builder.Builder

@@ -13,18 +13,14 @@ import IsomorphismClass.Prelude import qualified IsomorphismClass.TextCompat.Array -instance IsSome Data.ByteString.Builder.Builder Data.Text.Array.Array where+instance IsomorphicTo Data.ByteString.Builder.Builder Data.Text.Array.Array where   to = Data.ByteString.Builder.shortByteString . IsomorphismClass.TextCompat.Array.toShortByteString -instance IsSome Data.Text.Array.Array Data.ByteString.Builder.Builder where+instance IsomorphicTo Data.Text.Array.Array Data.ByteString.Builder.Builder where   to =     IsomorphismClass.TextCompat.Array.fromShortByteString       . Data.ByteString.Short.toShort       . Data.ByteString.Lazy.toStrict       . Data.ByteString.Builder.toLazyByteString--instance Is Data.Text.Array.Array Data.ByteString.Builder.Builder--instance Is Data.ByteString.Builder.Builder Data.Text.Array.Array  #endif

@@ -7,12 +7,8 @@ import IsomorphismClass.Classes import IsomorphismClass.Prelude -instance IsSome Data.ByteString.Builder.Builder [Word8] where+instance IsomorphicTo Data.ByteString.Builder.Builder [Word8] where   to = Data.ByteString.Builder.lazyByteString . Data.ByteString.Lazy.pack -instance IsSome [Word8] Data.ByteString.Builder.Builder where+instance IsomorphicTo [Word8] Data.ByteString.Builder.Builder where   to = Data.ByteString.Lazy.unpack . Data.ByteString.Builder.toLazyByteString--instance Is Data.ByteString.Builder.Builder [Word8]--instance Is [Word8] Data.ByteString.Builder.Builder

@@ -7,14 +7,8 @@ import IsomorphismClass.Classes import IsomorphismClass.Prelude -instance IsSome Data.Text.Lazy.Text Data.Text.Lazy.Builder.Builder where+instance IsomorphicTo Data.Text.Lazy.Text Data.Text.Lazy.Builder.Builder where   to = Data.Text.Lazy.Builder.toLazyText-  maybeFrom = Just . Data.Text.Lazy.Builder.fromLazyText -instance IsSome Data.Text.Lazy.Builder.Builder Data.Text.Lazy.Text where+instance IsomorphicTo Data.Text.Lazy.Builder.Builder Data.Text.Lazy.Text where   to = Data.Text.Lazy.Builder.fromLazyText-  maybeFrom = Just . Data.Text.Lazy.Builder.toLazyText--instance Is Data.Text.Lazy.Text Data.Text.Lazy.Builder.Builder--instance Is Data.Text.Lazy.Builder.Builder Data.Text.Lazy.Text

@@ -10,14 +10,10 @@ import IsomorphismClass.Classes import IsomorphismClass.Prelude -instance IsSome Data.Text.Lazy.Text Data.Text.Encoding.StrictBuilder where+instance IsomorphicTo Data.Text.Lazy.Text Data.Text.Encoding.StrictBuilder where   to = Data.Text.Lazy.fromStrict . Data.Text.Encoding.strictBuilderToText -instance IsSome Data.Text.Encoding.StrictBuilder Data.Text.Lazy.Text where+instance IsomorphicTo Data.Text.Encoding.StrictBuilder Data.Text.Lazy.Text where   to = Data.Text.Encoding.textToStrictBuilder . Data.Text.Lazy.toStrict--instance Is Data.Text.Lazy.Text Data.Text.Encoding.StrictBuilder--instance Is Data.Text.Encoding.StrictBuilder Data.Text.Lazy.Text  #endif

@@ -1,12 +0,0 @@-{-# OPTIONS_GHC -Wno-orphans #-}--module IsomorphismClass.Relations.LazyTextAndString where--import qualified Data.Text.Lazy-import IsomorphismClass.Classes-import IsomorphismClass.Prelude-import IsomorphismClass.Relations.StringAndText ()--instance IsSome String Data.Text.Lazy.Text where-  to = Data.Text.Lazy.unpack-  maybeFrom = fmap Data.Text.Lazy.fromStrict . maybeFrom

@@ -6,12 +6,8 @@ import IsomorphismClass.Classes import IsomorphismClass.Prelude -instance IsSome Data.Text.Lazy.Text Text where+instance IsomorphicTo Data.Text.Lazy.Text Text where   to = Data.Text.Lazy.fromStrict -instance IsSome Text Data.Text.Lazy.Text where+instance IsomorphicTo Text Data.Text.Lazy.Text where   to = Data.Text.Lazy.toStrict--instance Is Data.Text.Lazy.Text Text--instance Is Text Data.Text.Lazy.Text

@@ -11,14 +11,10 @@ import IsomorphismClass.Classes import IsomorphismClass.Prelude -instance IsSome Data.Text.Lazy.Builder.Builder Data.Text.Encoding.StrictBuilder where+instance IsomorphicTo Data.Text.Lazy.Builder.Builder Data.Text.Encoding.StrictBuilder where   to = Data.Text.Lazy.Builder.fromText . Data.Text.Encoding.strictBuilderToText -instance IsSome Data.Text.Encoding.StrictBuilder Data.Text.Lazy.Builder.Builder where+instance IsomorphicTo Data.Text.Encoding.StrictBuilder Data.Text.Lazy.Builder.Builder where   to = Data.Text.Encoding.textToStrictBuilder . Data.Text.Lazy.toStrict . Data.Text.Lazy.Builder.toLazyText--instance Is Data.Text.Lazy.Builder.Builder Data.Text.Encoding.StrictBuilder--instance Is Data.Text.Encoding.StrictBuilder Data.Text.Lazy.Builder.Builder  #endif

@@ -1,13 +0,0 @@-{-# OPTIONS_GHC -Wno-orphans #-}--module IsomorphismClass.Relations.LazyTextBuilderAndString where--import qualified Data.Text.Lazy-import qualified Data.Text.Lazy.Builder-import IsomorphismClass.Classes-import IsomorphismClass.Prelude-import IsomorphismClass.Relations.StringAndText ()--instance IsSome String Data.Text.Lazy.Builder.Builder where-  to = Data.Text.Lazy.unpack . Data.Text.Lazy.Builder.toLazyText-  maybeFrom = fmap Data.Text.Lazy.Builder.fromText . maybeFrom

@@ -7,14 +7,8 @@ import IsomorphismClass.Classes import IsomorphismClass.Prelude -instance IsSome Data.Text.Lazy.Builder.Builder Text where+instance IsomorphicTo Data.Text.Lazy.Builder.Builder Text where   to = Data.Text.Lazy.Builder.fromText-  maybeFrom = Just . Data.Text.Lazy.toStrict . Data.Text.Lazy.Builder.toLazyText -instance IsSome Text Data.Text.Lazy.Builder.Builder where+instance IsomorphicTo Text Data.Text.Lazy.Builder.Builder where   to = Data.Text.Lazy.toStrict . Data.Text.Lazy.Builder.toLazyText-  maybeFrom = Just . Data.Text.Lazy.Builder.fromText--instance Is Data.Text.Lazy.Builder.Builder Text--instance Is Text Data.Text.Lazy.Builder.Builder

@@ -6,12 +6,8 @@ import IsomorphismClass.Classes import IsomorphismClass.Prelude -instance IsSome [a] (Seq a) where+instance IsomorphicTo [a] (Seq a) where   to = toList -instance IsSome (Seq a) [a] where+instance IsomorphicTo (Seq a) [a] where   to = Data.Sequence.fromList--instance Is [a] (Seq a)--instance Is (Seq a) [a]

@@ -11,14 +11,10 @@ import IsomorphismClass.Prelude import qualified IsomorphismClass.TextCompat.Array -instance IsSome Data.ByteString.Short.ShortByteString Data.Text.Array.Array where+instance IsomorphicTo Data.ByteString.Short.ShortByteString Data.Text.Array.Array where   to = IsomorphismClass.TextCompat.Array.toShortByteString -instance IsSome Data.Text.Array.Array Data.ByteString.Short.ShortByteString where+instance IsomorphicTo Data.Text.Array.Array Data.ByteString.Short.ShortByteString where   to = IsomorphismClass.TextCompat.Array.fromShortByteString--instance Is Data.ByteString.Short.ShortByteString Data.Text.Array.Array--instance Is Data.Text.Array.Array Data.ByteString.Short.ShortByteString  #endif

@@ -7,12 +7,8 @@ import IsomorphismClass.Prelude import IsomorphismClass.Relations.ByteArrayAndShortByteString () -instance IsSome [Word8] Data.ByteString.Short.ShortByteString where+instance IsomorphicTo [Word8] Data.ByteString.Short.ShortByteString where   to = Data.ByteString.Short.unpack -instance IsSome Data.ByteString.Short.ShortByteString [Word8] where+instance IsomorphicTo Data.ByteString.Short.ShortByteString [Word8] where   to = Data.ByteString.Short.pack--instance Is [Word8] Data.ByteString.Short.ShortByteString--instance Is Data.ByteString.Short.ShortByteString [Word8]

@@ -1,17 +0,0 @@-{-# LANGUAGE CPP #-}-{-# OPTIONS_GHC -Wno-orphans #-}--module IsomorphismClass.Relations.StrictTextBuilderAndString where--#if MIN_VERSION_text(2,0,2)--import qualified Data.Text.Encoding-import IsomorphismClass.Classes-import IsomorphismClass.Relations.StringAndText ()-import IsomorphismClass.Prelude--instance IsSome String Data.Text.Encoding.StrictBuilder where-  to = to . Data.Text.Encoding.strictBuilderToText-  maybeFrom = fmap Data.Text.Encoding.textToStrictBuilder . maybeFrom--#endif

@@ -9,14 +9,14 @@ import IsomorphismClass.Classes import IsomorphismClass.Prelude -instance IsSome Text Data.Text.Encoding.StrictBuilder where+instance IsomorphicTo Text Data.Text.Encoding.StrictBuilder where   to = Data.Text.Encoding.strictBuilderToText -instance IsSome Data.Text.Encoding.StrictBuilder Text where+instance IsomorphicTo Data.Text.Encoding.StrictBuilder Text where   to = Data.Text.Encoding.textToStrictBuilder -instance Is Text Data.Text.Encoding.StrictBuilder -instance Is Data.Text.Encoding.StrictBuilder Text++  #endif

@@ -1,16 +0,0 @@-{-# OPTIONS_GHC -Wno-orphans #-}--module IsomorphismClass.Relations.StringAndText where--import qualified Data.Text as Text-import IsomorphismClass.Classes-import IsomorphismClass.Prelude--instance IsSome String Text where-  to = Text.unpack-  maybeFrom string =-    -- FIXME: Optimize.-    let text = Text.pack string-     in if string == Text.unpack text-          then Just text-          else Nothing

@@ -11,14 +11,10 @@ import IsomorphismClass.Prelude import qualified IsomorphismClass.TextCompat.Array -instance IsSome Data.Text.Array.Array [Word8] where+instance IsomorphicTo Data.Text.Array.Array [Word8] where   to = IsomorphismClass.TextCompat.Array.fromShortByteString . Data.ByteString.Short.pack -instance IsSome [Word8] Data.Text.Array.Array where+instance IsomorphicTo [Word8] Data.Text.Array.Array where   to = Data.ByteString.Short.unpack . IsomorphismClass.TextCompat.Array.toShortByteString--instance Is Data.Text.Array.Array [Word8]--instance Is [Word8] Data.Text.Array.Array  #endif

@@ -113,9 +113,9 @@       testPair @Word8 @Word8 Proxy Proxy     ] -testPair :: (Is a b, Eq a, Eq b, Arbitrary a, Show a, Arbitrary b, Show b, Typeable a, Typeable b) => Proxy a -> Proxy b -> TestTree+testPair :: (IsomorphicTo a b, Eq a, Eq b, Arbitrary a, Show a, Arbitrary b, Show b, Typeable a, Typeable b) => Proxy a -> Proxy b -> TestTree testPair superp subp =-  isLawsProperties superp subp+  isomorphicToProperties superp subp     & fmap (uncurry testProperty)     & testGroup groupName   where