diff --git a/Control/RichConditional.hs b/Control/RichConditional.hs
new file mode 100644
--- /dev/null
+++ b/Control/RichConditional.hs
@@ -0,0 +1,93 @@
+{-# LANGUAGE MultiParamTypeClasses #-}
+{-# LANGUAGE ScopedTypeVariables #-}
+{-# LANGUAGE FlexibleInstances #-}
+
+module Control.RichConditional (
+
+    TotalIf
+  , decide
+
+  , PartialIf
+  , indicate
+
+  , ifElse
+  , inCase
+  , ensure
+  , ensurePositive
+  , ensureNegative
+
+  ) where
+
+import Data.Maybe
+import Data.Either
+import Control.Monad
+
+type Indication = Maybe
+
+type Decision = Either
+
+-- | Instances of this class provide a test on some type a. If it passes, it
+--   gives a value of type b; otherwise, it gives Nothing.
+class PartialIf a b where
+  indicate :: a -> Indication b
+
+instance PartialIf (Maybe a) a where
+  indicate = id
+
+-- | Instances of this class provide a test on some type a with an
+--   alternative case for when it fails. If it passes, it gives a value of
+--   type b; otherwise, it gives a value of type c.
+class TotalIf a b c where
+  decide :: a -> Decision b c
+
+instance TotalIf (Either a b) a b where
+  decide = id
+
+-- | A conditional using a PartialIf instance. This is just like the
+--   function 'maybe' which decomposes a Maybe, except that the Maybe
+--   is produced through an PartialIf instance determined by the type of
+--   the positive case.
+inCase :: PartialIf a b => a -> (b -> c) -> c -> c
+inCase x ifYes ifNo = maybe ifNo ifYes (indicate x)
+
+-- | A conditional using a TotalIf instance. This is just like the
+--   function 'either' which decomposes an Either, except that the Either
+--   is produced through a TotalIf instance determined by the types of
+--   the cases.
+ifElse :: TotalIf a b c => a -> (b -> d) -> (c -> d) -> d
+ifElse x ifYes ifNo = either ifYes ifNo (decide x)
+
+-- | Like 'guard' but with a bonus: if the condition passes, you actually get
+--   a hold of some new information.
+ensure :: (Monad m, MonadPlus m, PartialIf a b) => a -> m b
+ensure x = inCase x return mzero
+
+-- | Like 'ensure' but for the positive case (Left) of a TotalIf.
+--   Requires a proxy on the negative type in order to disambiguate.
+ensurePositive
+  :: forall m a b c u .
+     ( Monad m
+     , MonadPlus m
+     , TotalIf a b c
+     )
+   => a
+   -> u c
+   -> m b
+ensurePositive x _ =
+    let typedConstMzero = const mzero :: c -> m b
+    in  ifElse x return typedConstMzero
+
+-- | Like 'ensure' but for the negative case (Right) of a TotalIf.
+--   Requires a proxy on the positive type in order to disambiguate.
+ensureNegative
+  :: forall m a b c u .
+     ( Monad m
+     , MonadPlus m
+     , TotalIf a b c
+     )
+  => a
+  -> u b
+  -> m c
+ensureNegative x _ =
+    let typedConstMzero = const mzero :: b -> m c
+    in  ifElse x typedConstMzero return
diff --git a/LICENSE b/LICENSE
new file mode 100644
--- /dev/null
+++ b/LICENSE
@@ -0,0 +1,20 @@
+Copyright (c) 2015 Alexander Vieth
+
+Permission is hereby granted, free of charge, to any person obtaining
+a copy of this software and associated documentation files (the
+"Software"), to deal in the Software without restriction, including
+without limitation the rights to use, copy, modify, merge, publish,
+distribute, sublicense, and/or sell copies of the Software, and to
+permit persons to whom the Software is furnished to do so, subject to
+the following conditions:
+
+The above copyright notice and this permission notice shall be included
+in all copies or substantial portions of the Software.
+
+THE SOFTWARE IS PROVIDED "AS IS", WITHOUT WARRANTY OF ANY KIND,
+EXPRESS OR IMPLIED, INCLUDING BUT NOT LIMITED TO THE WARRANTIES OF
+MERCHANTABILITY, FITNESS FOR A PARTICULAR PURPOSE AND NONINFRINGEMENT.
+IN NO EVENT SHALL THE AUTHORS OR COPYRIGHT HOLDERS BE LIABLE FOR ANY
+CLAIM, DAMAGES OR OTHER LIABILITY, WHETHER IN AN ACTION OF CONTRACT,
+TORT OR OTHERWISE, ARISING FROM, OUT OF OR IN CONNECTION WITH THE
+SOFTWARE OR THE USE OR OTHER DEALINGS IN THE SOFTWARE.
diff --git a/README.md b/README.md
new file mode 100644
--- /dev/null
+++ b/README.md
@@ -0,0 +1,129 @@
+Control.RichConditional
+=======================
+
+Typeclasses for describing "rich conditionals" which accomplish exactly what
+a classic if/else would but without the use of `Bool`.
+
+The inspiration is found in dependently typed languages, in which a `Bool` is
+seen to be a comparatively pathetic datatype: it carries very little
+information. A useful test for some condition always introduces new
+information, but with a classical if/else, this information not known to the
+compiler because it's lossfully compressed into a `Bool`.
+
+There is no new technology here, only typeclasses and functions which might
+make it more convenient to avoid using if/else.
+
+#A motivating example
+
+To demonstrate the point, suppose we defined the following module, in which
+the constructors of `Visitor` are not exposed:
+
+```Haskell
+module Visitor (
+    Visitor
+  , isLoggedIn
+  , isGuest
+  ) where
+
+data Visitor = LoggedIn User | Guest
+
+isLoggedIn :: Visitor -> Bool
+isLoggedIn v = case v of
+  LoggedIn _ -> True
+  Guest -> False
+
+isGuest :: Visitor -> Bool
+isGuest v = case v of
+  LoggedIn _ -> False
+  Guest -> True
+```
+
+We have indicator functions on `Visitor`, but they don't allow for a 
+useful interface. In the example below, we can't build a user's landing
+page because we can't get a hold of a `User` value.
+
+```Haskell
+userLandingPage :: User -> LandingPage
+
+guestLandingPage :: LandingPage
+
+blindLandingPage :: Visitor -> LandingPage
+blindLandingPage v =
+  if isLoggedIn v
+  -- We know there's a user, but GHC does not!
+  then userLandingPage ?
+  else guestLandingPage
+```
+
+Evidently the `Visitor` library must provide some way to get a hold of
+a `User` from a `Visitor`, but if it does provide this, then why even bother
+giving the indicators `isLoggedIn` and `isGuest`?
+
+Contrast the above definitions with a `Bool`-free approach:
+
+```Haskell
+module Visitor (
+    Visitor
+  , ifVisitor
+  ) where
+
+data Visitor = LoggedIn User | Guest
+
+ifVisitor :: Visitor -> (User -> a) -> a -> a
+ifVisitor v ifUser ifGuest = case v of
+  LoggedIn user -> ifUser user
+  Guest -> ifGuest
+```
+
+`Visitor` is just `Maybe User` with a new name, and `ifVisitor` is just the
+function `maybe` with its parameter order shuffled. It provides users of
+`Visitor` a way to get a hold of a `User` for `LoggedIn` cases without
+pattern matching on `Visitor` directly. It can be used to implement a well
+factored version of the landing page example:
+
+```Haskell
+userLandingPage :: User -> LandingPage
+
+guestLandingPage :: LandingPage
+
+landingPage :: Visitor -> LandingPage
+landingPage v = ifVisitor v userLandingPage guestLandingPage
+```
+
+#Use of RichConditional
+
+This modification of the above examples shows how RichConditional could be
+used:
+
+```Haskell
+{-# LANGUAGE MultiParamTypeClasses #-}
+
+data User = User
+
+data Guest = Human | Robot
+
+data Visitor = LoggedIn User | NotLoggedIn Guest
+
+instance PartialIf Visitor User where
+  indicate v = case v of
+    LoggedIn user -> Just user
+    NotLoggedIn _ -> Nothing
+
+instance PartialIf Visitor Guest where
+  indicate v = case v of
+    LoggedIn _ -> Nothing
+    NotLoggedIn guest -> Just guest
+
+instance TotalIf Visitor User Guest where
+  decide v = case v of
+    LoggedIn user -> Left user
+    NotLoggedIn guest -> Right guest
+
+allGuests :: [Visitor] -> [Guest]
+allGuests vs = do
+  v <- vs
+  -- This is like guard, except that useful data comes
+  -- out of it, so that it fulfills the type signature
+  -- of allGuests.
+  ensure v
+```
diff --git a/RichConditional.cabal b/RichConditional.cabal
new file mode 100644
--- /dev/null
+++ b/RichConditional.cabal
@@ -0,0 +1,70 @@
+-- Initial RichConditional.cabal generated by cabal init.  For further 
+-- documentation, see http://haskell.org/cabal/users-guide/
+
+-- The name of the package.
+name:                RichConditional
+
+-- The package version.  See the Haskell package versioning policy (PVP) 
+-- for standards guiding when and how versions should be incremented.
+-- http://www.haskell.org/haskellwiki/Package_versioning_policy
+-- PVP summary:      +-+------- breaking API changes
+--                   | | +----- non-breaking API additions
+--                   | | | +--- code changes with no API change
+version:             0.1.0.0
+
+-- A short (one-line) description of the package.
+synopsis:            Tiny library to replace classic if/else
+
+-- A longer description of the package.
+-- description:         
+
+-- URL for the project homepage or repository.
+homepage:            https://github.com/avieth/RichConditional
+
+-- The license under which the package is released.
+license:             MIT
+
+-- The file containing the license text.
+license-file:        LICENSE
+
+-- The package author(s).
+author:              Alexander Vieth
+
+-- An email address to which users can send suggestions, bug reports, and 
+-- patches.
+maintainer:          aovieth@gmail.com
+
+-- A copyright notice.
+-- copyright:           
+
+category:            Control
+
+build-type:          Simple
+
+-- Extra files to be distributed with the package, such as examples or a 
+-- README.
+extra-source-files:  README.md
+
+-- Constraint on the version of Cabal needed to build this package.
+cabal-version:       >=1.10
+
+
+library
+  -- Modules exported by the library.
+  exposed-modules:     Control.RichConditional
+  
+  -- Modules included in this library but not exported.
+  -- other-modules:       
+  
+  -- LANGUAGE extensions used by modules in this package.
+  other-extensions:    MultiParamTypeClasses, ScopedTypeVariables, FlexibleInstances
+  
+  -- Other library packages from which modules are imported.
+  build-depends:       base >=4.7 && <4.8
+  
+  -- Directories containing source files.
+  -- hs-source-dirs:      
+  
+  -- Base language which the package is written in.
+  default-language:    Haskell2010
+  
diff --git a/Setup.hs b/Setup.hs
new file mode 100644
--- /dev/null
+++ b/Setup.hs
@@ -0,0 +1,2 @@
+import Distribution.Simple
+main = defaultMain