Add Type.Data.Ordering; Reexport Data.Symbols, Type.Equality (#1)

* Add Type.Data.Ordering; Reexport Data.Symbols, Type.Equality

* Don't alias modules for export

* Remove unnecessary coersion in reifyOrdering

Author: LiamGoodacre

bower.json

@@ -16,6 +16,11 @@
     "package.json"
   ],
   "dependencies": {
-    "purescript-proxy": "^1.0.0"
+    "purescript-proxy": "^1.0.0",
+    "purescript-symbols": "^2.0.0",
+    "purescript-type-equality": "^1.0.0"
+  },
+  "devDependencies": {
+    "purescript-psci-support": "^2.0.0"
   }
 }

src/Type/Data/Ordering.purs

@@ -0,0 +1,62 @@
+module Type.Data.Ordering
+  ( kind Ordering
+  , LT
+  , EQ
+  , GT
+  , OProxy(..)
+  , class IsOrdering
+  , reflectOrdering
+  , reifyOrdering
+  , class AppendOrdering
+  , appendOrdering
+  , class InvertOrdering
+  , invertOrdering
+  ) where
+
+import Data.Ordering (Ordering(..))
+
+foreign import kind Ordering
+foreign import data LT :: Ordering
+foreign import data EQ :: Ordering
+foreign import data GT :: Ordering
+
+-- | Value proxy for `Ordering` types
+data OProxy (ordering :: Ordering) = OProxy
+
+-- | Class for reflecting a type level `Ordering` at the value level
+class IsOrdering (ordering :: Ordering) where
+  reflectOrdering :: OProxy ordering -> Ordering
+
+instance isOrderingLT :: IsOrdering LT where reflectOrdering _ = LT
+instance isOrderingEQ :: IsOrdering EQ where reflectOrdering _ = EQ
+instance isOrderingGT :: IsOrdering GT where reflectOrdering _ = GT
+
+-- | Use a value level `Ordering` as a type-level `Ordering`
+reifyOrdering :: forall r. Ordering -> (forall o. IsOrdering o => OProxy o -> r) -> r
+reifyOrdering LT f = f (OProxy :: OProxy LT)
+reifyOrdering EQ f = f (OProxy :: OProxy EQ)
+reifyOrdering GT f = f (OProxy :: OProxy GT)
+
+-- | Append two `Ordering` types together
+-- | Reflective of the semigroup for value level `Ordering`
+class AppendOrdering (lhs :: Ordering)
+                     (rhs :: Ordering)
+                     (output :: Ordering) |
+                     lhs -> rhs output
+instance appendOrderingLT :: AppendOrdering LT rhs LT
+instance appendOrderingEQ :: AppendOrdering EQ rhs rhs
+instance appendOrderingGT :: AppendOrdering GT rhs GT
+
+appendOrdering :: forall l r o. AppendOrdering l r o => OProxy l -> OProxy r -> OProxy o
+appendOrdering _ _ = OProxy
+
+-- | Invert an `Ordering`
+class InvertOrdering (ordering :: Ordering)
+                     (result :: Ordering) |
+                     ordering -> result
+instance invertOrderingLT :: InvertOrdering LT GT
+instance invertOrderingEQ :: InvertOrdering EQ EQ
+instance invertOrderingGT :: InvertOrdering GT LT
+
+invertOrdering :: forall i o. InvertOrdering i o => OProxy i -> OProxy o
+invertOrdering _ = OProxy

src/Type/Prelude.purs

@@ -1,5 +1,11 @@
 module Type.Prelude
-  ( module Proxy
+  ( module Type.Equality
+  , module Type.Data.Ordering
+  , module Type.Proxy
+  , module Data.Symbol
   ) where
 
-import Type.Proxy (Proxy(..)) as Proxy
+import Type.Equality (class TypeEquals, from, to)
+import Type.Data.Ordering (kind Ordering, LT, EQ, GT, OProxy(..), class IsOrdering, reflectOrdering, reifyOrdering)
+import Type.Proxy (Proxy(..))
+import Data.Symbol (SProxy(..), class IsSymbol, reflectSymbol, reifySymbol)