Run Ormolu

Iso/Deriving.hs

@@ -1,17 +1,28 @@
-{-# LANGUAGE DerivingVia, RankNTypes, InstanceSigs, TypeOperators, TypeApplications, QuantifiedConstraints, StandaloneDeriving, KindSignatures, PolyKinds, MultiParamTypeClasses, FlexibleInstances, DeriveFunctor, GeneralizedNewtypeDeriving, ScopedTypeVariables #-}
-
+{-# LANGUAGE DeriveFunctor #-}
+{-# LANGUAGE DerivingVia #-}
+{-# LANGUAGE FlexibleInstances #-}
+{-# LANGUAGE GeneralizedNewtypeDeriving #-}
+{-# LANGUAGE InstanceSigs #-}
+{-# LANGUAGE KindSignatures #-}
+{-# LANGUAGE MultiParamTypeClasses #-}
+{-# LANGUAGE PolyKinds #-}
+{-# LANGUAGE QuantifiedConstraints #-}
+{-# LANGUAGE RankNTypes #-}
+{-# LANGUAGE ScopedTypeVariables #-}
+{-# LANGUAGE StandaloneDeriving #-}
+{-# LANGUAGE TypeApplications #-}
+{-# LANGUAGE TypeOperators #-}
 
 module Iso.Deriving
-( As(..)
-, As1(..)
-, As2(..)
-, Inject(..)
-, Project(..)
-, Isomorphic(..)
+  ( As (..),
+    As1 (..),
+    As2 (..),
+    Inject (..),
+    Project (..),
+    Isomorphic (..),
   )
 where
 
-import Prelude hiding ((.), id)
 -- import Control.Lens (Iso', iso, to, from, view, coerced, enum) -- TODO loose lens dep!
 -- import Control.Monad.Free
 -- import Data.Monoid hiding (Product)
@@ -20,6 +31,8 @@ import Control.Category
 import Data.Bifunctor ()
 -- import Data.Maybe (catMaybes)
 import Data.Profunctor (Profunctor (..))
+import Prelude hiding ((.), id)
+
 -- import Control.Arrow (Kleisli(..))
 -- import Control.Monad.State
 -- import Data.Functor.Compose
@@ -30,6 +43,7 @@ import Data.Profunctor (Profunctor(..))
 -- import Control.Monad.Writer hiding (Product)
 
 type Iso s t a b = forall p f. (Profunctor p, Functor f) => p a (f b) -> p s (f t)
+
 type Iso' s a = Iso s s a a
 
 iso :: (s -> a) -> (b -> t) -> Iso s t a b
@@ -55,7 +69,6 @@ newtype As1 f g a   = As1 { getAs1 :: g a }
 -- type As2 :: k1 -> (k2 -> k3 -> Type) -> k2 -> k3 -> Type
 newtype As2 f g a b = As2 (g a b)
 
-
 class Inject a b where
   inj :: a -> b
 
@@ -73,16 +86,22 @@ class (Inject a b, Project a b) => Isomorphic a b where
   isom = iso inj prj
 
 instance (Isomorphic a b, Num a) => Num (As a b) where
+
   (As a) + (As b) =
     As $ inj @a @b $ (prj a) + (prj b)
+
   (As a) - (As b) =
     As $ inj @a @b $ (prj a) - (prj b)
+
   (As a) * (As b) =
     As $ inj @a @b $ (prj a) * (prj b)
+
   signum (As a) =
     As $ inj @a @b $ signum (prj a)
+
   abs (As a) =
     As $ inj @a @b $ abs (prj a)
+
   fromInteger x =
     As $ inj @a @b $ fromInteger x
 
@@ -102,6 +121,7 @@ instance (forall x . Isomorphic (f x) (g x), Functor f) => Functor (As1 f g) whe
   fmap h (As1 x) = As1 $ inj $ fmap h $ prj @(f _) @(g _) x
 
 instance (forall x. Isomorphic (f x) (g x), Applicative f) => Applicative (As1 f g) where
+
   pure x = As1 $ inj @(f _) @(g _) $ pure x
 
   (<*>) :: forall a b. As1 f g (a -> b) -> As1 f g a -> As1 f g b
@@ -111,6 +131,7 @@ instance (forall x . Isomorphic (f x) (g x), Applicative f) => Applicative (As1
   liftA2 h (As1 x) (As1 y) = As1 $ inj @(f c) @(g c) $ liftA2 h (prj x) (prj y)
 
 instance (forall x. Isomorphic (f x) (g x), Alternative f) => Alternative (As1 f g) where
+
   empty :: forall a. As1 f g a
   empty = As1 $ inj @(f a) @(g a) $ empty
 
@@ -122,11 +143,13 @@ instance (forall x . Isomorphic (f x) (g x), Monad f) => Monad (As1 f g) where
   As1 k >>= f = As1 $ inj @(f b) @(g b) $ (prj @(f a) @(g a) k) >>= prj . getAs1 . f
 
 instance (forall x y. Isomorphic (f x y) (g x y), Category f) => Category (As2 f g) where
+
   id :: forall a. As2 f g a a
   id = As2 $ inj @(f _ _) @(g _ _) $ Control.Category.id @_ @a
 
   (.) :: forall a b c. As2 f g b c -> As2 f g a b -> As2 f g a c
-  As2 f . As2 g = As2 $ inj @(f a c) @(g a c) $ (Control.Category..)
-    (prj @(f b c) @(g b c) f) (prj @(f a b) @(g a b) g)
-
-
+  As2 f . As2 g =
+    As2 $ inj @(f a c) @(g a c) $
+      (Control.Category..)
+        (prj @(f b c) @(g b c) f)
+        (prj @(f a b) @(g a b) g)

test/Spec.hs

@@ -1,30 +1,29 @@
 {-# LANGUAGE DeriveFunctor #-}
 {-# LANGUAGE DerivingStrategies #-}
 {-# LANGUAGE DerivingVia #-}
-{-# LANGUAGE TypeOperators #-}
-{-# LANGUAGE TypeSynonymInstances #-}
 {-# LANGUAGE FlexibleInstances #-}
 {-# LANGUAGE MultiParamTypeClasses #-}
+{-# LANGUAGE TypeOperators #-}
+{-# LANGUAGE TypeSynonymInstances #-}
 
 module Main where
 
-import Iso.Deriving
-import Data.Monoid (Ap(..), Any(..))
-import Data.Coerce (coerce)
 import Control.Monad.Writer (WriterT (..))
+import Data.Coerce (coerce)
+import Data.Monoid (Any (..), Ap (..))
+import Iso.Deriving
 
 main = pure () -- TODO
 
 data Point a = Point {x :: a, y :: a}
   deriving (Eq, Show, Functor)
-
-  deriving Num
+  deriving
+    (Num)
     via (Squared a `As` Point a)
-
-  deriving (Applicative, Monad)
+  deriving
+    (Applicative, Monad)
     via (Squared `As1` Point)
 
-
 type Squared = Ap ((->) Bool)
 
 instance Inject (Squared a) (Point a) where
@@ -33,15 +32,15 @@ instance Inject (Squared a) (Point a) where
 instance Project (Squared a) (Point a) where
   prj (Point x y) = coerce $ \p -> if not p then x else y
 
-instance Isomorphic (Squared a) (Point a) where
-
+instance Isomorphic (Squared a) (Point a)
 
 data NoneOrMore
-  = None
-    -- ^ No elements
-  | OneOrMore
-    -- ^ At least one element
-  deriving (Semigroup, Monoid)
+  = -- | No elements
+    None
+  | -- | At least one element
+    OneOrMore
+  deriving
+    (Semigroup, Monoid)
     via (Any `As` NoneOrMore)
 
 instance Inject Any NoneOrMore where
@@ -56,7 +55,8 @@ instance Isomorphic Any NoneOrMore
 
 data These a b = This a | That b | These a b
   deriving stock (Functor)
-  deriving (Applicative, Monad)
+  deriving
+    (Applicative, Monad)
     via (TheseMonad a `As1` These a)
 
 type TheseMonad a = WriterT (Maybe a) (Either a)
@@ -71,4 +71,4 @@ instance Inject (TheseMonad a b) (These a b) where
   inj (WriterT (Right (b, Nothing))) = That b
   inj (WriterT (Right (b, Just a))) = These a b
 
-instance Isomorphic (TheseMonad a b) (These a b) where
+instance Isomorphic (TheseMonad a b) (These a b)