Replace SProxy with Proxy

Author: JordanMartinez

src/Data/Symbol.purs

@@ -5,20 +5,21 @@ module Data.Symbol
   , SProxy(..)
   ) where
 
+import Type.Proxy (Proxy(..))
+
 -- | A value-level proxy for a type-level symbol.
 data SProxy (sym :: Symbol) = SProxy
 
 -- | A class for known symbols
 class IsSymbol (sym :: Symbol) where
-  reflectSymbol :: SProxy sym -> String
+  reflectSymbol :: Proxy sym -> String
 
 -- local definition for use in `reifySymbol`
 foreign import unsafeCoerce :: forall a b. a -> b
 
-reifySymbol :: forall r. String -> (forall sym. IsSymbol sym => SProxy sym -> r) -> r
-reifySymbol s f = coerce f { reflectSymbol: \_ -> s } SProxy where
+reifySymbol :: forall r. String -> (forall sym. IsSymbol sym => Proxy sym -> r) -> r
+reifySymbol s f = coerce f { reflectSymbol: \_ -> s } Proxy where
   coerce
-    :: (forall sym1. IsSymbol sym1              => SProxy sym1 -> r)
-    -> { reflectSymbol :: SProxy "" -> String } -> SProxy ""   -> r
+    :: (forall sym1. IsSymbol sym1              => Proxy sym1 -> r)
+    -> { reflectSymbol :: Proxy "" -> String } -> Proxy ""   -> r
   coerce = unsafeCoerce
-

src/Type/Proxy.purs

@@ -48,7 +48,21 @@
 -- | ```
 module Type.Proxy where
 
-import Prelude
+import Control.Applicative (class Applicative)
+import Control.Apply (class Apply)
+import Control.Bind (class Bind, class Discard)
+import Control.Monad (class Monad)
+
+import Data.BooleanAlgebra (class BooleanAlgebra)
+import Data.Bounded (class Bounded)
+import Data.CommutativeRing (class CommutativeRing)
+import Data.Eq (class Eq)
+import Data.Functor (class Functor)
+import Data.HeytingAlgebra (class HeytingAlgebra)
+import Data.Ord (class Ord)
+import Data.Ring (class Ring)
+import Data.Semiring (class Semiring)
+import Data.Show (class Show, show)
 
 -- | Proxy type for all `kind`s.
 data Proxy :: forall k. k -> Type