Port Proxy's type class instances into respective type class modules

Author: JordanMartinez

src/Control/Applicative.purs

@@ -10,6 +10,7 @@ import Control.Apply (class Apply, apply, (*>), (<*), (<*>))
 
 import Data.Functor (class Functor, map, void, ($>), (<#>), (<$), (<$>))
 import Data.Unit (Unit, unit)
+import Type.Proxy (Proxy(..))
 
 -- | The `Applicative` type class extends the [`Apply`](#apply) type class
 -- | with a `pure` function, which can be used to create values of type `f a`
@@ -38,6 +39,9 @@ instance applicativeFn :: Applicative ((->) r) where
 instance applicativeArray :: Applicative Array where
   pure x = [x]
 
+instance applicativeProxy :: Applicative Proxy where
+  pure _ = Proxy
+
 -- | `liftA1` provides a default implementation of `(<$>)` for any
 -- | [`Applicative`](#applicative) functor, without using `(<$>)` as provided
 -- | by the [`Functor`](#functor)-[`Applicative`](#applicative) superclass

src/Control/Apply.purs

@@ -9,6 +9,7 @@ module Control.Apply
 import Data.Functor (class Functor, map, void, ($>), (<#>), (<$), (<$>))
 import Data.Function (const)
 import Control.Category (identity)
+import Type.Proxy (Proxy(..))
 
 -- | The `Apply` class provides the `(<*>)` which is used to apply a function
 -- | to an argument under a type constructor.
@@ -54,6 +55,9 @@ instance applyArray :: Apply Array where
 
 foreign import arrayApply :: forall a b. Array (a -> b) -> Array a -> Array b
 
+instance applyProxy :: Apply Proxy where
+  apply _ _ = Proxy
+
 -- | Combine two effectful actions, keeping only the result of the first.
 applyFirst :: forall a b f. Apply f => f a -> f b -> f a
 applyFirst a b = const <$> a <*> b

src/Control/Bind.purs

@@ -19,6 +19,7 @@ import Control.Category (identity)
 import Data.Function (flip)
 import Data.Functor (class Functor, map, void, ($>), (<#>), (<$), (<$>))
 import Data.Unit (Unit)
+import Type.Proxy (Proxy(..), Proxy2, Proxy3)
 
 -- | The `Bind` type class extends the [`Apply`](#apply) type class with a
 -- | "bind" operation `(>>=)` which composes computations in sequence, using
@@ -90,6 +91,9 @@ instance bindArray :: Bind Array where
 
 foreign import arrayBind :: forall a b. Array a -> (a -> Array b) -> Array b
 
+instance bindProxy :: Bind Proxy where
+  bind _ _ = Proxy
+
 -- | A class for types whose values can safely be discarded
 -- | in a `do` notation block.
 -- |
@@ -101,6 +105,15 @@ class Discard a where
 instance discardUnit :: Discard Unit where
   discard = bind
 
+instance discardProxy :: Discard (Proxy a) where
+  discard = bind
+
+instance discardProxy2 :: Discard (Proxy2 a) where
+  discard = bind
+
+instance discardProxy3 :: Discard (Proxy3 a) where
+  discard = bind
+
 -- | Collapse two applications of a monadic type constructor into one.
 join :: forall a m. Bind m => m (m a) -> m a
 join m = m >>= identity

src/Control/Monad.purs

@@ -15,6 +15,7 @@ import Control.Bind (class Bind, bind, ap, ifM, join, (<=<), (=<<), (>=>), (>>=)
 
 import Data.Functor (class Functor, map, void, ($>), (<#>), (<$), (<$>))
 import Data.Unit (Unit)
+import Type.Proxy (Proxy)
 
 -- | The `Monad` type class combines the operations of the `Bind` and
 -- | `Applicative` type classes. Therefore, `Monad` instances represent type
@@ -32,6 +33,8 @@ instance monadFn :: Monad ((->) r)
 
 instance monadArray :: Monad Array
 
+instance monadProxy :: Monad Proxy
+
 -- | `liftM1` provides a default implementation of `(<$>)` for any
 -- | [`Monad`](#monad), without using `(<$>)` as provided by the
 -- | [`Functor`](#functor)-[`Monad`](#monad) superclass relationship.

src/Data/BooleanAlgebra.purs

@@ -9,6 +9,7 @@ import Data.Symbol (class IsSymbol)
 import Data.Unit (Unit)
 import Prim.Row as Row
 import Prim.RowList as RL
+import Type.Proxy (Proxy, Proxy2, Proxy3)
 
 -- | The `BooleanAlgebra` type class represents types that behave like boolean
 -- | values.
@@ -24,6 +25,9 @@ instance booleanAlgebraBoolean :: BooleanAlgebra Boolean
 instance booleanAlgebraUnit :: BooleanAlgebra Unit
 instance booleanAlgebraFn :: BooleanAlgebra b => BooleanAlgebra (a -> b)
 instance booleanAlgebraRecord :: (RL.RowToList row list, BooleanAlgebraRecord list row row) => BooleanAlgebra (Record row)
+instance booleanAlgebraProxy :: BooleanAlgebra (Proxy a)
+instance booleanAlgebraProxy2 :: BooleanAlgebra (Proxy2 a)
+instance booleanAlgebraProxy3 :: BooleanAlgebra (Proxy3 a)
 
 -- | A class for records where all fields have `BooleanAlgebra` instances, used
 -- | to implement the `BooleanAlgebra` instance for records.

src/Data/Bounded.purs

@@ -14,6 +14,7 @@ import Prim.RowList as RL
 import Record.Unsafe (unsafeSet)
 import Type.Data.Row (RProxy(..))
 import Type.Data.RowList (RLProxy(..))
+import Type.Proxy (Proxy(..), Proxy2(..), Proxy3(..))
 
 -- | The `Bounded` type class represents totally ordered types that have an
 -- | upper and lower boundary.
@@ -62,6 +63,18 @@ instance boundedNumber :: Bounded Number where
   top = topNumber
   bottom = bottomNumber
 
+instance boundedProxy :: Bounded (Proxy a) where
+  bottom = Proxy
+  top = Proxy
+
+instance boundedProxy2 :: Bounded (Proxy2 a) where
+  bottom = Proxy2
+  top = Proxy2
+
+instance boundedProxy3 :: Bounded (Proxy3 a) where
+  bottom = Proxy3
+  top = Proxy3
+
 class OrdRecord rowlist row <= BoundedRecord rowlist row subrow | rowlist -> subrow where
   topRecord :: RLProxy rowlist -> RProxy row -> Record subrow
   bottomRecord :: RLProxy rowlist -> RProxy row -> Record subrow

src/Data/CommutativeRing.purs

@@ -11,6 +11,7 @@ import Data.Symbol (class IsSymbol)
 import Data.Unit (Unit)
 import Prim.Row as Row
 import Prim.RowList as RL
+import Type.Proxy (Proxy, Proxy2, Proxy3)
 
 -- | The `CommutativeRing` class is for rings where multiplication is
 -- | commutative.
@@ -26,6 +27,9 @@ instance commutativeRingNumber :: CommutativeRing Number
 instance commutativeRingUnit :: CommutativeRing Unit
 instance commutativeRingFn :: CommutativeRing b => CommutativeRing (a -> b)
 instance commutativeRingRecord :: (RL.RowToList row list, CommutativeRingRecord list row row) => CommutativeRing (Record row)
+instance commutativeRingProxy :: CommutativeRing (Proxy a)
+instance commutativeRingProxy2 :: CommutativeRing (Proxy2 a)
+instance commutativeRingProxy3 :: CommutativeRing (Proxy3 a)
 
 -- | A class for records where all fields have `CommutativeRing` instances, used
 -- | to implement the `CommutativeRing` instance for records.

src/Data/Eq.purs

@@ -12,6 +12,7 @@ import Prim.Row as Row
 import Prim.RowList as RL
 import Record.Unsafe (unsafeGet)
 import Type.Data.RowList (RLProxy(..))
+import Type.Proxy (Proxy, Proxy2, Proxy3)
 
 -- | The `Eq` type class represents types which support decidable equality.
 -- |
@@ -64,6 +65,15 @@ instance eqArray :: Eq a => Eq (Array a) where
 instance eqRec :: (RL.RowToList row list, EqRecord list row) => Eq (Record row) where
   eq = eqRecord (RLProxy :: RLProxy list)
 
+instance eqProxy :: Eq (Proxy a) where
+  eq _ _ = true
+
+instance eqProxy2 :: Eq (Proxy2 a) where
+  eq _ _ = true
+
+instance eqProxy3 :: Eq (Proxy3 a) where
+  eq _ _ = true
+
 foreign import eqBooleanImpl :: Boolean -> Boolean -> Boolean
 foreign import eqIntImpl :: Int -> Int -> Boolean
 foreign import eqNumberImpl :: Number -> Number -> Boolean

src/Data/Functor.purs

@@ -9,6 +9,7 @@ module Data.Functor
 
 import Data.Function (const, compose)
 import Data.Unit (Unit, unit)
+import Type.Proxy (Proxy(..))
 
 -- | A `Functor` is a type constructor which supports a mapping operation
 -- | `map`.
@@ -42,6 +43,9 @@ instance functorFn :: Functor ((->) r) where
 instance functorArray :: Functor Array where
   map = arrayMap
 
+instance functorProxy :: Functor Proxy where
+  map _ _ = Proxy
+
 foreign import arrayMap :: forall a b. (a -> b) -> Array a -> Array b
 
 -- | The `void` function is used to ignore the type wrapped by a

src/Data/HeytingAlgebra.purs

@@ -10,6 +10,7 @@ import Prim.RowList as RL
 import Record.Unsafe (unsafeGet, unsafeSet)
 import Type.Data.Row (RProxy(..))
 import Type.Data.RowList (RLProxy(..))
+import Type.Proxy (Proxy(..), Proxy2(..), Proxy3(..))
 
 -- | The `HeytingAlgebra` type class represents types that are bounded lattices with
 -- | an implication operator such that the following laws hold:
@@ -71,6 +72,30 @@ instance heytingAlgebraFunction :: HeytingAlgebra b => HeytingAlgebra (a -> b) w
   disj f g a = f a || g a
   not f a = not (f a)
 
+instance heytingAlgebraProxy :: HeytingAlgebra (Proxy a) where
+  conj _ _ = Proxy
+  disj _ _ = Proxy
+  implies _ _ = Proxy
+  ff = Proxy
+  not _ = Proxy
+  tt = Proxy
+
+instance heytingAlgebraProxy2 :: HeytingAlgebra (Proxy2 a) where
+  conj _ _ = Proxy2
+  disj _ _ = Proxy2
+  implies _ _ = Proxy2
+  ff = Proxy2
+  not _ = Proxy2
+  tt = Proxy2
+
+instance heytingAlgebraProxy3 :: HeytingAlgebra (Proxy3 a) where
+  conj _ _ = Proxy3
+  disj _ _ = Proxy3
+  implies _ _ = Proxy3
+  ff = Proxy3
+  not _ = Proxy3
+  tt = Proxy3
+
 instance heytingAlgebraRecord :: (RL.RowToList row list, HeytingAlgebraRecord list row row) => HeytingAlgebra (Record row) where
   ff = ffRecord  (RLProxy :: RLProxy list) (RProxy :: RProxy row)
   tt = ttRecord  (RLProxy :: RLProxy list) (RProxy :: RProxy row)