diff --git a/CHANGES.txt b/CHANGES.txt
--- a/CHANGES.txt
+++ b/CHANGES.txt
@@ -1,5 +1,8 @@
 Changelog for Safe
 
+0.3.12
+    #19, add Safe.Partial exposing a Partial typeclass
+    #19, add support for GHC call stacks
 0.3.11
     #16, add Safe succ and pred
     #16, add readEitherSafe for better errors than readEither
diff --git a/Safe.hs b/Safe.hs
--- a/Safe.hs
+++ b/Safe.hs
@@ -1,3 +1,5 @@
+{-# LANGUAGE FlexibleContexts #-}
+{-# LANGUAGE ConstraintKinds  #-}
 {- |
 A module wrapping @Prelude@/@Data.List@ functions that can throw exceptions, such as @head@ and @!!@.
 Each unsafe function has up to four variants, e.g. with @tail@:
@@ -8,10 +10,13 @@
 
 * @'tailDef' :: /[a]/ -> [a] -> [a]@, takes a default to return on errors.
 
-* @'tailNote' :: /String/ -> [a] -> [a]@, takes an extra argument which supplements the error message.
+* @'tailNote' :: 'Partial' => /String/ -> [a] -> [a]@, takes an extra argument which supplements the error message.
 
 * @'tailSafe' :: [a] -> [a]@, returns some sensible default if possible, @[]@ in the case of @tail@.
 
+All functions marked with the @'Partial'@ constraint are not total, and will produce stack traces on error, on GHC
+versions which support them (see "GHC.Stack").
+
 This module also introduces some new functions, documented at the top of the module.
 -}
 
@@ -49,14 +54,15 @@
 import Safe.Util
 import Data.List
 import Data.Maybe
+import Safe.Partial
 
 ---------------------------------------------------------------------
 -- UTILITIES
 
-fromNote :: String -> String -> Maybe a -> a
+fromNote :: Partial => String -> String -> Maybe a -> a
 fromNote = fromNoteModule "Safe"
 
-fromNoteEither :: String -> String -> Either String a -> a
+fromNoteEither :: Partial => String -> String -> Either String a -> a
 fromNoteEither = fromNoteEitherModule "Safe"
 
 
@@ -66,7 +72,7 @@
 -- | Synonym for 'error'. Used for instances where the program
 --   has decided to exit because of invalid user input, or the user pressed
 --   quit etc. This function allows 'error' to be reserved for programmer errors.
-abort :: String -> a
+abort :: Partial => String -> a
 abort = error
 
 
@@ -96,7 +102,7 @@
 -- |
 -- > tailNote "help me" [] = error "Safe.tailNote [], help me"
 -- > tailNote "help me" [1,3,4] = [3,4]
-tailNote :: String -> [a] -> [a]
+tailNote :: Partial => String -> [a] -> [a]
 tailNote note = fromNote note "tailNote []" . tailMay
 
 -- |
@@ -112,7 +118,7 @@
 initDef :: [a] -> [a] -> [a]
 initDef def = fromMaybe def . initMay
 
-initNote :: String -> [a] -> [a]
+initNote :: Partial => String -> [a] -> [a]
 initNote note = fromNote note "initNote []" . initMay
 
 initSafe :: [a] -> [a]
@@ -140,7 +146,7 @@
 minimumDef def = fromMaybe def . minimumMay
 maximumDef def = fromMaybe def . maximumMay
 
-minimumNote, maximumNote :: Ord a => String -> [a] -> a
+minimumNote, maximumNote :: (Partial, Ord a) => String -> [a] -> a
 minimumNote note = fromNote note "minumumNote []" . minimumMay
 maximumNote note = fromNote note "maximumNote []" . maximumMay
 
@@ -152,7 +158,7 @@
 minimumByDef def = fromMaybe def .^ minimumByMay
 maximumByDef def = fromMaybe def .^ maximumByMay
 
-minimumByNote, maximumByNote :: String -> (a -> a -> Ordering) -> [a] -> a
+minimumByNote, maximumByNote :: Partial => String -> (a -> a -> Ordering) -> [a] -> a
 minimumByNote note = fromNote note "minumumByNote []" .^ minimumByMay
 maximumByNote note = fromNote note "maximumByNote []" .^ maximumByMay
 
@@ -167,7 +173,7 @@
 foldl1Def def = fromMaybe def .^ foldl1May
 foldl1Def' def = fromMaybe def .^ foldl1May'
 
-foldr1Note, foldl1Note, foldl1Note' :: String -> (a -> a -> a) -> [a] -> a
+foldr1Note, foldl1Note, foldl1Note' :: Partial => String -> (a -> a -> a) -> [a] -> a
 foldr1Note note = fromNote note "foldr1Note []" .^ foldr1May
 foldl1Note note = fromNote note "foldl1Note []" .^ foldl1May
 foldl1Note' note = fromNote note "foldl1Note []" .^ foldl1May'
@@ -180,7 +186,7 @@
 scanr1Def def = fromMaybe def .^ scanr1May
 scanl1Def def = fromMaybe def .^ scanl1May
 
-scanr1Note, scanl1Note :: String -> (a -> a -> a) -> [a] -> [a]
+scanr1Note, scanl1Note :: Partial => String -> (a -> a -> a) -> [a] -> [a]
 scanr1Note note = fromNote note "scanr1Note []" .^ scanr1May
 scanl1Note note = fromNote note "scanl1Note []" .^ scanl1May
 
@@ -190,7 +196,7 @@
 cycleDef :: [a] -> [a] -> [a]
 cycleDef def = fromMaybe def . cycleMay
 
-cycleNote :: String -> [a] -> [a]
+cycleNote :: Partial => String -> [a] -> [a]
 cycleNote note = fromNote note "cycleNote []" . cycleMay
 
 -- | An alternative name for 'fromMaybe', to fit the naming scheme of this package.
@@ -198,16 +204,16 @@
 fromJustDef :: a -> Maybe a -> a
 fromJustDef  = fromMaybe
 
-fromJustNote :: String -> Maybe a -> a
+fromJustNote :: Partial => String -> Maybe a -> a
 fromJustNote note = fromNote note "fromJustNote Nothing"
 
-assertNote :: String -> Bool -> a -> a
+assertNote :: Partial => String -> Bool -> a -> a
 assertNote note True val = val
 assertNote note False val = fromNote note "assertNote False" Nothing
 
 
 -- | Synonym for '!!', but includes more information in the error message.
-at :: [a] -> Int -> a
+at :: Partial => [a] -> Int -> a
 at = fromNoteEither "" "at" .^ at_
 
 atMay :: [a] -> Int -> Maybe a
@@ -216,7 +222,7 @@
 atDef :: a -> [a] -> Int -> a
 atDef def = fromMaybe def .^ atMay
 
-atNote :: String -> [a] -> Int -> a
+atNote :: Partial => String -> [a] -> Int -> a
 atNote note = fromNoteEither note "atNote" .^ at_
 
 -- | This function provides a more precise error message than 'readEither' from 'base'.
@@ -237,7 +243,7 @@
 readDef def = fromMaybe def . readMay
 
 -- | 'readNote' uses 'readEitherSafe' for the error message.
-readNote :: Read a => String -> String -> a
+readNote :: (Partial, Read a) => String -> String -> a
 readNote note = fromNoteEither note "readNote" . readEitherSafe
 
 -- |
@@ -248,7 +254,7 @@
 lookupJustDef :: Eq a => b -> a -> [(a,b)] -> b
 lookupJustDef def = fromMaybe def .^ lookup
 
-lookupJustNote :: Eq a => String -> a -> [(a,b)] -> b
+lookupJustNote :: (Partial, Eq a) => String -> a -> [(a,b)] -> b
 lookupJustNote note = fromNote note "lookupJustNote, no matching value" .^ lookup
 
 -- |
@@ -259,7 +265,7 @@
 findJustDef :: a -> (a -> Bool) -> [a] -> a
 findJustDef def = fromMaybe def .^ find
 
-findJustNote :: String -> (a -> Bool) -> [a] -> a
+findJustNote :: Partial => String -> (a -> Bool) -> [a] -> a
 findJustNote note = fromNote note "findJustNote, no matching value" .^ find
 
 -- |
@@ -270,7 +276,7 @@
 elemIndexJustDef :: Eq a => Int -> a -> [a] -> Int
 elemIndexJustDef def = fromMaybe def .^ elemIndex
 
-elemIndexJustNote :: Eq a => String -> a -> [a] -> Int
+elemIndexJustNote :: (Partial, Eq a) => String -> a -> [a] -> Int
 elemIndexJustNote note = fromNote note "elemIndexJustNote, no matching value" .^ elemIndex
 
 -- |
@@ -281,7 +287,7 @@
 findIndexJustDef :: Int -> (a -> Bool) -> [a] -> Int
 findIndexJustDef def = fromMaybe def .^ findIndex
 
-findIndexJustNote :: String -> (a -> Bool) -> [a] -> Int
+findIndexJustNote :: Partial => String -> (a -> Bool) -> [a] -> Int
 findIndexJustNote note = fromNote note "findIndexJustNote, no matching value" .^ findIndex
 
 -- From http://stackoverflow.com/questions/2743858/safe-and-polymorphic-toenum
@@ -298,7 +304,7 @@
 toEnumDef :: (Enum a, Bounded a) => a -> Int -> a
 toEnumDef def = fromMaybe def . toEnumMay
 
-toEnumNote :: (Enum a, Bounded a) => String -> Int -> a
+toEnumNote :: (Partial, Enum a, Bounded a) => String -> Int -> a
 toEnumNote note = fromNote note "toEnumNote, out of range" . toEnumMay
 
 toEnumSafe :: (Enum a, Bounded a) => Int -> a
@@ -310,7 +316,7 @@
 succDef :: (Enum a, Eq a, Bounded a) => a -> a -> a
 succDef def = fromMaybe def . succMay
 
-succNote :: (Enum a, Eq a, Bounded a) => String -> a -> a
+succNote :: (Partial, Enum a, Eq a, Bounded a) => String -> a -> a
 succNote note = fromNote note "succNote, out of range" . succMay
 
 succSafe :: (Enum a, Eq a, Bounded a) => a -> a
@@ -322,7 +328,7 @@
 predDef :: (Enum a, Eq a, Bounded a) => a -> a -> a
 predDef def = fromMaybe def . predMay
 
-predNote :: (Enum a, Eq a, Bounded a) => String -> a -> a
+predNote :: (Partial, Enum a, Eq a, Bounded a) => String -> a -> a
 predNote note = fromNote note "predNote, out of range" . predMay
 
 predSafe :: (Enum a, Eq a, Bounded a) => a -> a
diff --git a/Safe/Exact.hs b/Safe/Exact.hs
--- a/Safe/Exact.hs
+++ b/Safe/Exact.hs
@@ -1,3 +1,5 @@
+{-# LANGUAGE FlexibleContexts #-}
+{-# LANGUAGE ConstraintKinds  #-}
 {- |
 Provides functions that raise errors in corner cases instead of returning \"best effort\"
 results, then provides wrappers like the "Safe" module. For example:
@@ -33,11 +35,12 @@
 import Control.Arrow
 import Data.Maybe
 import Safe.Util
+import Safe.Partial
 
 ---------------------------------------------------------------------
 -- HELPERS
 
-addNote :: String -> String -> String -> a
+addNote :: Partial => String -> String -> String -> a
 addNote note fun msg = error $
     "Safe.Exact." ++ fun ++ ", " ++ msg ++ (if null note then "" else ", " ++ note)
 
@@ -46,7 +49,7 @@
 -- IMPLEMENTATIONS
 
 {-# INLINE splitAtExact_ #-}
-splitAtExact_ :: (String -> r) -> ([a] -> r) -> (a -> r -> r) -> Int -> [a] -> r
+splitAtExact_ :: Partial => (String -> r) -> ([a] -> r) -> (a -> r -> r) -> Int -> [a] -> r
 splitAtExact_ err nil cons o xs
     | o < 0 = err $ "index must not be negative, index=" ++ show o
     | otherwise = f o xs
@@ -57,7 +60,7 @@
 
 
 {-# INLINE zipWithExact_ #-}
-zipWithExact_ :: (String -> r) -> r -> (a -> b -> r -> r) -> [a] -> [b] -> r
+zipWithExact_ :: Partial => (String -> r) -> r -> (a -> b -> r -> r) -> [a] -> [b] -> r
 zipWithExact_ err nil cons = f
     where
         f (x:xs) (y:ys) = cons x y $ f xs ys
@@ -67,7 +70,7 @@
 
 
 {-# INLINE zipWith3Exact_ #-}
-zipWith3Exact_ :: (String -> r) -> r -> (a -> b -> c -> r -> r) -> [a] -> [b] -> [c] -> r
+zipWith3Exact_ :: Partial => (String -> r) -> r -> (a -> b -> c -> r -> r) -> [a] -> [b] -> [c] -> r
 zipWith3Exact_ err nil cons = f
     where
         f (x:xs) (y:ys) (z:zs) = cons x y z $ f xs ys zs
@@ -84,25 +87,25 @@
 -- > takeExact n xs =
 -- >   | n >= 0 && n <= length xs = take n xs
 -- >   | otherwise                = error "some message"
-takeExact :: Int -> [a] -> [a]
+takeExact :: Partial => Int -> [a] -> [a]
 takeExact = splitAtExact_ (addNote "" "takeExact") (const []) (:)
 
 -- |
 -- > dropExact n xs =
 -- >   | n >= 0 && n <= length xs = drop n xs
 -- >   | otherwise                = error "some message"
-dropExact :: Int -> [a] -> [a]
+dropExact :: Partial => Int -> [a] -> [a]
 dropExact = splitAtExact_ (addNote "" "dropExact") id (flip const)
 
 -- |
 -- > splitAtExact n xs =
 -- >   | n >= 0 && n <= length xs = splitAt n xs
 -- >   | otherwise                = error "some message"
-splitAtExact :: Int -> [a] -> ([a], [a])
+splitAtExact :: Partial => Int -> [a] -> ([a], [a])
 splitAtExact = splitAtExact_ (addNote "" "splitAtExact")
     (\x -> ([], x)) (\a b -> first (a:) b)
 
-takeExactNote :: String -> Int -> [a] -> [a]
+takeExactNote :: Partial => String -> Int -> [a] -> [a]
 takeExactNote note = splitAtExact_ (addNote note "takeExactNote") (const []) (:)
 
 takeExactMay :: Int -> [a] -> Maybe [a]
@@ -111,7 +114,7 @@
 takeExactDef :: [a] -> Int -> [a] -> [a]
 takeExactDef def = fromMaybe def .^ takeExactMay
 
-dropExactNote :: String -> Int -> [a] -> [a]
+dropExactNote :: Partial => String -> Int -> [a] -> [a]
 dropExactNote note = splitAtExact_ (addNote note "dropExactNote") id (flip const)
 
 dropExactMay :: Int -> [a] -> Maybe [a]
@@ -120,7 +123,7 @@
 dropExactDef :: [a] -> Int -> [a] -> [a]
 dropExactDef def = fromMaybe def .^ dropExactMay
 
-splitAtExactNote :: String -> Int -> [a] -> ([a], [a])
+splitAtExactNote :: Partial => String -> Int -> [a] -> ([a], [a])
 splitAtExactNote note = splitAtExact_ (addNote note "splitAtExactNote")
     (\x -> ([], x)) (\a b -> first (a:) b)
 
@@ -138,18 +141,18 @@
 -- > zipExact xs ys =
 -- >   | length xs == length ys = zip xs ys
 -- >   | otherwise              = error "some message"
-zipExact :: [a] -> [b] -> [(a,b)]
+zipExact :: Partial => [a] -> [b] -> [(a,b)]
 zipExact = zipWithExact_ (addNote "" "zipExact") []  (\a b xs -> (a,b) : xs)
 
 -- |
 -- > zipWithExact f xs ys =
 -- >   | length xs == length ys = zipWith f xs ys
 -- >   | otherwise              = error "some message"
-zipWithExact :: (a -> b -> c) -> [a] -> [b] -> [c]
+zipWithExact :: Partial => (a -> b -> c) -> [a] -> [b] -> [c]
 zipWithExact f = zipWithExact_ (addNote "" "zipWithExact") [] (\a b xs -> f a b : xs)
 
 
-zipExactNote :: String -> [a] -> [b] -> [(a,b)]
+zipExactNote :: Partial => String -> [a] -> [b] -> [(a,b)]
 zipExactNote note = zipWithExact_ (addNote note "zipExactNote") []  (\a b xs -> (a,b) : xs)
 
 zipExactMay :: [a] -> [b] -> Maybe [(a,b)]
@@ -158,7 +161,7 @@
 zipExactDef :: [(a,b)] -> [a] -> [b] -> [(a,b)]
 zipExactDef def = fromMaybe def .^ zipExactMay
 
-zipWithExactNote :: String -> (a -> b -> c) -> [a] -> [b] -> [c]
+zipWithExactNote :: Partial => String -> (a -> b -> c) -> [a] -> [b] -> [c]
 zipWithExactNote note f = zipWithExact_ (addNote note "zipWithExactNote") []  (\a b xs -> f a b : xs)
 
 zipWithExactMay :: (a -> b -> c) -> [a] -> [b] -> Maybe [c]
@@ -172,18 +175,18 @@
 -- > zip3Exact xs ys zs =
 -- >   | length xs == length ys && length xs == length zs = zip3 xs ys zs
 -- >   | otherwise                                        = error "some message"
-zip3Exact :: [a] -> [b] -> [c] -> [(a,b,c)]
+zip3Exact :: Partial => [a] -> [b] -> [c] -> [(a,b,c)]
 zip3Exact = zipWith3Exact_ (addNote "" "zip3Exact") [] (\a b c xs -> (a, b, c) : xs)
 
 -- |
 -- > zipWith3Exact f xs ys zs =
 -- >   | length xs == length ys && length xs == length zs = zipWith3 f xs ys zs
 -- >   | otherwise                                        = error "some message"
-zipWith3Exact :: (a -> b -> c -> d) -> [a] -> [b] -> [c] -> [d]
+zipWith3Exact :: Partial => (a -> b -> c -> d) -> [a] -> [b] -> [c] -> [d]
 zipWith3Exact f = zipWith3Exact_ (addNote "" "zipWith3Exact") [] (\a b c xs -> f a b c : xs)
 
 
-zip3ExactNote :: String -> [a] -> [b] -> [c]-> [(a,b,c)]
+zip3ExactNote :: Partial => String -> [a] -> [b] -> [c]-> [(a,b,c)]
 zip3ExactNote note = zipWith3Exact_ (addNote note "zip3ExactNote") [] (\a b c xs -> (a,b,c) : xs)
 
 zip3ExactMay :: [a] -> [b] -> [c] -> Maybe [(a,b,c)]
@@ -192,7 +195,7 @@
 zip3ExactDef :: [(a,b,c)] -> [a] -> [b] -> [c] -> [(a,b,c)]
 zip3ExactDef def = fromMaybe def .^^ zip3ExactMay
 
-zipWith3ExactNote :: String -> (a -> b -> c -> d) -> [a] -> [b] -> [c] -> [d]
+zipWith3ExactNote :: Partial => String -> (a -> b -> c -> d) -> [a] -> [b] -> [c] -> [d]
 zipWith3ExactNote note f = zipWith3Exact_ (addNote note "zipWith3ExactNote") []  (\a b c xs -> f a b c : xs)
 
 zipWith3ExactMay :: (a -> b -> c -> d) -> [a] -> [b] -> [c] -> Maybe [d]
diff --git a/Safe/Foldable.hs b/Safe/Foldable.hs
--- a/Safe/Foldable.hs
+++ b/Safe/Foldable.hs
@@ -1,4 +1,6 @@
-{-# LANGUAGE CPP #-}
+{-# LANGUAGE FlexibleContexts #-}
+{-# LANGUAGE CPP              #-}
+{-# LANGUAGE ConstraintKinds  #-}
 {- |
 'Foldable' functions, with wrappers like the "Safe" module.
 -}
@@ -22,12 +24,13 @@
 import Data.Maybe
 import Data.Monoid
 import Prelude
+import Safe.Partial
 
 
 ---------------------------------------------------------------------
 -- UTILITIES
 
-fromNote :: String -> String -> Maybe a -> a
+fromNote :: Partial => String -> String -> Maybe a -> a
 fromNote = fromNoteModule "Safe.Foldable"
 
 isNull :: Foldable t => t a -> Bool
@@ -44,7 +47,7 @@
 foldl1May = liftMay isNull . F.foldl1
 foldr1May = liftMay isNull . F.foldr1
 
-foldl1Note, foldr1Note :: Foldable t => String -> (a -> a -> a) -> t a -> a
+foldl1Note, foldr1Note :: (Partial, Foldable t) => String -> (a -> a -> a) -> t a -> a
 foldl1Note note = fromNote note "foldl1Note on empty" .^ foldl1May
 foldr1Note note = fromNote note "foldr1Note on empty" .^ foldr1May
 
@@ -60,7 +63,7 @@
 minimumDef def = fromMaybe def . minimumMay
 maximumDef def = fromMaybe def . maximumMay
 
-minimumNote, maximumNote :: (Foldable t, Ord a) => String -> t a -> a
+minimumNote, maximumNote :: (Partial, Foldable t, Ord a) => String -> t a -> a
 minimumNote note = fromNote note "minimumNote on empty" . minimumMay
 maximumNote note = fromNote note "maximumNote on empty" . maximumMay
 
@@ -72,19 +75,19 @@
 minimumByDef def = fromMaybe def .^ minimumByMay
 maximumByDef def = fromMaybe def .^ maximumByMay
 
-minimumByNote, maximumByNote :: Foldable t => String -> (a -> a -> Ordering) -> t a -> a
+minimumByNote, maximumByNote :: (Partial, Foldable t) => String -> (a -> a -> Ordering) -> t a -> a
 minimumByNote note = fromNote note "minimumByNote on empty" .^ minimumByMay
 maximumByNote note = fromNote note "maximumByNote on empty" .^ maximumByMay
 
 -- |
 -- > findJust op = fromJust . find op
-findJust :: Foldable t => (a -> Bool) -> t a -> a
+findJust :: (Partial, Foldable t) => (a -> Bool) -> t a -> a
 findJust = fromNote "" "findJust, no matching value" .^ F.find
 
 findJustDef :: Foldable t => a -> (a -> Bool) -> t a -> a
 findJustDef def = fromMaybe def .^ F.find
 
-findJustNote :: Foldable t => String -> (a -> Bool) -> t a -> a
+findJustNote :: (Partial, Foldable t) => String -> (a -> Bool) -> t a -> a
 findJustNote note = fromNote note "findJustNote, no matching value" .^ F.find
 
 
diff --git a/Safe/Partial.hs b/Safe/Partial.hs
new file mode 100644
--- /dev/null
+++ b/Safe/Partial.hs
@@ -0,0 +1,28 @@
+{-# LANGUAGE ConstraintKinds #-}
+{-# LANGUAGE KindSignatures  #-}
+{-# LANGUAGE CPP             #-}
+{-# LANGUAGE ImplicitParams  #-}
+-- | ConstraintKind synonym for marking partial functions
+module Safe.Partial(
+  Partial
+  ) where
+
+#if __GLASGOW_HASKELL__ < 710
+import GHC.Exts (Constraint)
+#elif __GLASGOW_HASKELL__ < 800
+import GHC.Stack (CallStack)
+#else
+import GHC.Stack (HasCallStack)
+#endif
+
+-- | A constraint synonym which denotes that the function is partial, and will
+--   (on GHC 8.* and up) produce a stack trace on failure.
+--   You may mark your own non-total functions as Partial, if necessary, and this
+--   will ensure that they produce useful stack traces.
+#if __GLASGOW_HASKELL__ < 710
+type Partial = (() :: Constraint)
+#elif __GLASGOW_HASKELL__ < 800
+type Partial = (?loc :: CallStack)
+#else
+type Partial = HasCallStack
+#endif
diff --git a/Safe/Util.hs b/Safe/Util.hs
--- a/Safe/Util.hs
+++ b/Safe/Util.hs
@@ -1,27 +1,29 @@
-
+{-# LANGUAGE FlexibleContexts #-}
+{-# LANGUAGE ConstraintKinds  #-}
 -- | Internal utilities.
 module Safe.Util where
 
 import Data.Maybe
+import Safe.Partial
 
 
-(.^) :: (b -> c) -> (a1 -> a2 -> b) -> a1 -> a2 -> c
+(.^) :: Partial => (b -> c) -> (a1 -> a2 -> b) -> a1 -> a2 -> c
 (.^) f g x1 x2 = f (g x1 x2)
 
-(.^^) :: (b -> c) -> (a1 -> a2 -> a3 -> b) -> a1 -> a2 -> a3 -> c
+(.^^) :: Partial => (b -> c) -> (a1 -> a2 -> a3 -> b) -> a1 -> a2 -> a3 -> c
 (.^^) f g x1 x2 x3 = f (g x1 x2 x3)
 
-(.^^^) :: (b -> c) -> (a1 -> a2 -> a3 -> a4 -> b) -> a1 -> a2 -> a3 -> a4 -> c
+(.^^^) :: Partial => (b -> c) -> (a1 -> a2 -> a3 -> a4 -> b) -> a1 -> a2 -> a3 -> a4 -> c
 (.^^^) f g x1 x2 x3 x4 = f (g x1 x2 x3 x4)
 
 liftMay :: (a -> Bool) -> (a -> b) -> (a -> Maybe b)
 liftMay test func val = if test val then Nothing else Just $ func val
 
-fromNoteModule :: String -> String -> String -> Maybe a -> a
+fromNoteModule :: Partial => String -> String -> String -> Maybe a -> a
 fromNoteModule modu note func = fromMaybe (error msg)
     where msg = modu ++ "." ++ func ++ (if null note then "" else ", " ++ note)
 
-fromNoteEitherModule :: String -> String -> String -> Either String a -> a
+fromNoteEitherModule :: Partial => String -> String -> String -> Either String a -> a
 fromNoteEitherModule modu note func = either (error . msg) id
     where msg ex = modu ++ "." ++ func ++ " " ++ ex ++ (if null note then "" else ", " ++ note)
 
diff --git a/safe.cabal b/safe.cabal
--- a/safe.cabal
+++ b/safe.cabal
@@ -1,7 +1,7 @@
 cabal-version:  >= 1.18
 build-type:     Simple
 name:           safe
-version:        0.3.11
+version:        0.3.12
 license:        BSD3
 license-file:   LICENSE
 category:       Unclassified
@@ -11,7 +11,7 @@
 homepage:       https://github.com/ndmitchell/safe#readme
 synopsis:       Library of safe (exception free) functions
 bug-reports:    https://github.com/ndmitchell/safe/issues
-tested-with:    GHC==8.0.1, GHC==7.10.3, GHC==7.8.4, GHC==7.6.3, GHC==7.4.2
+tested-with:    GHC==8.0.2, GHC==7.10.3, GHC==7.8.4, GHC==7.6.3, GHC==7.4.2
 description:
     A library wrapping @Prelude@/@Data.List@ functions that can throw exceptions, such as @head@ and @!!@.
     Each unsafe function has up to four variants, e.g. with @tail@:
@@ -50,6 +50,7 @@
         Safe
         Safe.Exact
         Safe.Foldable
+        Safe.Partial
 
     other-modules:
         Safe.Util