diff --git a/CHANGELOG b/CHANGELOG
--- a/CHANGELOG
+++ b/CHANGELOG
@@ -1,5 +1,8 @@
 # Changelog
 
+- 0.1.2 (2025-12-27)
+  * Fixes an API mistake made in the v0.1.1 release.
+
 - 0.1.1 (2025-12-27)
   * Contains miscellaneous hardening and API refinements to v0.1.1.
 
diff --git a/lib/Data/Choice.hs b/lib/Data/Choice.hs
--- a/lib/Data/Choice.hs
+++ b/lib/Data/Choice.hs
@@ -1,3 +1,4 @@
+{-# OPTIONS_HADDOCK prune #-}
 {-# LANGUAGE BangPatterns #-}
 {-# LANGUAGE MagicHash #-}
 {-# LANGUAGE UnliftedNewtypes #-}
@@ -46,12 +47,12 @@
   , from_wide_le#
 
   -- * Manipulation
-  , or#
-  , and#
-  , xor#
-  , not#
-  , ne#
-  , eq#
+  , or
+  , and
+  , xor
+  , not
+  , ne
+  , eq
 
   -- * Constant-time Selection
   , select_word#
@@ -67,6 +68,7 @@
 import qualified Data.Bits as B
 import GHC.Exts (Word#, Int(..), Word(..))
 import qualified GHC.Exts as Exts
+import Prelude hiding (and, not, or)
 
 -- utilities ------------------------------------------------------------------
 
@@ -346,34 +348,34 @@
 -- manipulation ---------------------------------------------------------------
 
 -- | Logically negate a 'Choice'.
-not# :: Choice -> Choice
-not# (Choice w) = Choice (Exts.not# w)
-{-# INLINE not# #-}
+not :: Choice -> Choice
+not (Choice w) = Choice (Exts.not# w)
+{-# INLINE not #-}
 
 -- | Logical disjunction on 'Choice' values.
-or# :: Choice -> Choice -> Choice
-or# (Choice w0) (Choice w1) = Choice (Exts.or# w0 w1)
-{-# INLINE or# #-}
+or :: Choice -> Choice -> Choice
+or (Choice w0) (Choice w1) = Choice (Exts.or# w0 w1)
+{-# INLINE or #-}
 
 -- | Logical conjunction on 'Choice' values.
-and# :: Choice -> Choice -> Choice
-and# (Choice w0) (Choice w1) = Choice (Exts.and# w0 w1)
-{-# INLINE and# #-}
+and :: Choice -> Choice -> Choice
+and (Choice w0) (Choice w1) = Choice (Exts.and# w0 w1)
+{-# INLINE and #-}
 
 -- | Logical inequality on 'Choice' values.
-xor# :: Choice -> Choice -> Choice
-xor# (Choice w0) (Choice w1) = Choice (Exts.xor# w0 w1)
-{-# INLINE xor# #-}
+xor :: Choice -> Choice -> Choice
+xor (Choice w0) (Choice w1) = Choice (Exts.xor# w0 w1)
+{-# INLINE xor #-}
 
 -- | Logical inequality on 'Choice' values.
-ne# :: Choice -> Choice -> Choice
-ne# c0 c1 = xor# c0 c1
-{-# INLINE ne# #-}
+ne :: Choice -> Choice -> Choice
+ne c0 c1 = xor c0 c1
+{-# INLINE ne #-}
 
 -- | Logical equality on 'Choice' values.
-eq# :: Choice -> Choice -> Choice
-eq# c0 c1 = not# (ne# c0 c1)
-{-# INLINE eq# #-}
+eq :: Choice -> Choice -> Choice
+eq c0 c1 = not (ne c0 c1)
+{-# INLINE eq #-}
 
 -- constant-time selection ----------------------------------------------------
 
diff --git a/lib/Data/Word/Limb.hs b/lib/Data/Word/Limb.hs
--- a/lib/Data/Word/Limb.hs
+++ b/lib/Data/Word/Limb.hs
@@ -1,3 +1,4 @@
+{-# OPTIONS_HADDOCK prune #-}
 {-# LANGUAGE BangPatterns #-}
 {-# LANGUAGE MagicHash #-}
 {-# LANGUAGE NumericUnderscores #-}
@@ -98,7 +99,7 @@
   :: Limb
   -> Limb
   -> C.Choice
-ne# a b = C.not# (eq# a b)
+ne# a b = C.not (eq# a b)
 {-# INLINE ne# #-}
 
 ne_vartime#
diff --git a/lib/Data/Word/Wide.hs b/lib/Data/Word/Wide.hs
--- a/lib/Data/Word/Wide.hs
+++ b/lib/Data/Word/Wide.hs
@@ -1,3 +1,4 @@
+{-# OPTIONS_HADDOCK prune #-}
 {-# LANGUAGE BangPatterns #-}
 {-# LANGUAGE MagicHash #-}
 {-# LANGUAGE NumericUnderscores #-}
diff --git a/lib/Data/Word/Wider.hs b/lib/Data/Word/Wider.hs
--- a/lib/Data/Word/Wider.hs
+++ b/lib/Data/Word/Wider.hs
@@ -1,3 +1,4 @@
+{-# OPTIONS_HADDOCK prune #-}
 {-# LANGUAGE BangPatterns #-}
 {-# LANGUAGE MagicHash #-}
 {-# LANGUAGE NumericUnderscores #-}
diff --git a/lib/Numeric/Montgomery/Secp256k1/Curve.hs b/lib/Numeric/Montgomery/Secp256k1/Curve.hs
--- a/lib/Numeric/Montgomery/Secp256k1/Curve.hs
+++ b/lib/Numeric/Montgomery/Secp256k1/Curve.hs
@@ -19,8 +19,8 @@
   -- * Montgomery form, secp256k1 field prime modulus
     Montgomery(..)
   , render
-  , to_vartime
-  , from_vartime
+  , to
+  , from
   , zero
   , one
 
@@ -93,7 +93,7 @@
   <> show (W# c) <> ", " <> show (W# d) <> ")"
 
 instance Show Montgomery where
-  show = show . from_vartime
+  show = show . from
 
 -- | Note that 'fromInteger' necessarily runs in variable time due
 --   to conversion from the variable-size, potentially heap-allocated
@@ -104,7 +104,7 @@
   a * b = mul a b
   negate a = neg a
   abs = id
-  fromInteger = to_vartime . WW.to_vartime
+  fromInteger = to . WW.to_vartime
   signum (Montgomery (# l0, l1, l2, l3 #)) =
     let !(Limb l) = l0 `L.or#` l1 `L.or#` l2 `L.or#` l3
         !n = C.from_word_nonzero# l
@@ -369,14 +369,14 @@
 {-# INLINE to# #-}
 
 -- | Convert a 'Wider' word to the Montgomery domain.
-to_vartime :: Wider -> Montgomery
-to_vartime (Wider x) = Montgomery (to# x)
+to :: Wider -> Montgomery
+to (Wider x) = Montgomery (to# x)
 
 -- | Retrieve a 'Montgomery' word from the Montgomery domain.
 --
 --   This function is a synonym for 'retr'.
-from_vartime :: Montgomery -> Wider
-from_vartime = retr
+from :: Montgomery -> Wider
+from = retr
 
 add#
   :: (# Limb, Limb, Limb, Limb #) -- ^ augend
diff --git a/lib/Numeric/Montgomery/Secp256k1/Scalar.hs b/lib/Numeric/Montgomery/Secp256k1/Scalar.hs
--- a/lib/Numeric/Montgomery/Secp256k1/Scalar.hs
+++ b/lib/Numeric/Montgomery/Secp256k1/Scalar.hs
@@ -19,8 +19,8 @@
   -- * Montgomery form, secp256k1 scalar group order modulus
     Montgomery(..)
   , render
-  , to_vartime
-  , from_vartime
+  , to
+  , from
   , zero
   , one
 
@@ -81,7 +81,7 @@
 data Montgomery = Montgomery !(# Limb, Limb, Limb, Limb #)
 
 instance Show Montgomery where
-  show = show . from_vartime
+  show = show . from
 
 -- | Render a 'Montgomery' value as a 'String', showing its individual
 --   'Limb's.
@@ -102,7 +102,7 @@
   a * b = mul a b
   negate a = neg a
   abs = id
-  fromInteger = to_vartime . WW.to_vartime
+  fromInteger = to . WW.to_vartime
   signum (Montgomery (# l0, l1, l2, l3 #)) =
     let !(Limb l) = l0 `L.or#` l1 `L.or#` l2 `L.or#` l3
         !n = C.from_word_nonzero# l
@@ -367,14 +367,14 @@
 {-# INLINE to# #-}
 
 -- | Convert a 'Wider' word to the Montgomery domain.
-to_vartime :: Wider -> Montgomery
-to_vartime (Wider x) = Montgomery (to# x)
+to :: Wider -> Montgomery
+to (Wider x) = Montgomery (to# x)
 
 -- | Retrieve a 'Montgomery' word from the Montgomery domain.
 --
 --   This function is a synonym for 'retr'.
-from_vartime :: Montgomery -> Wider
-from_vartime = retr
+from :: Montgomery -> Wider
+from = retr
 
 add#
   :: (# Limb, Limb, Limb, Limb #) -- ^ augend
diff --git a/ppad-fixed.cabal b/ppad-fixed.cabal
--- a/ppad-fixed.cabal
+++ b/ppad-fixed.cabal
@@ -1,6 +1,6 @@
 cabal-version:      3.0
 name:               ppad-fixed
-version:            0.1.1
+version:            0.1.2
 synopsis:           Large fixed-width words and constant-time arithmetic.
 license:            MIT
 license-file:       LICENSE
diff --git a/test/Montgomery/Curve.hs b/test/Montgomery/Curve.hs
--- a/test/Montgomery/Curve.hs
+++ b/test/Montgomery/Curve.hs
@@ -41,7 +41,7 @@
 mm = 0xFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFEFFFFFC2F
 
 repr :: H.Assertion
-repr = H.assertBool mempty (W.eq_vartime 0 (C.from_vartime mm))
+repr = H.assertBool mempty (W.eq_vartime 0 (C.from mm))
 
 add_case :: String -> W.Wider -> W.Wider -> W.Wider -> H.Assertion
 add_case t a b s = do
@@ -49,7 +49,7 @@
     ((W.from_vartime a + W.from_vartime b) `mod` W.from_vartime m)
     (W.from_vartime s)
   H.assertBool t
-    (W.eq_vartime s (C.from_vartime (C.to_vartime a + C.to_vartime b)))
+    (W.eq_vartime s (C.from (C.to a + C.to b)))
 
 add :: H.Assertion
 add = do
@@ -73,7 +73,7 @@
     ((W.from_vartime b - W.from_vartime a) `mod` W.from_vartime m)
     (W.from_vartime d)
   H.assertBool t
-    (W.eq_vartime d (C.from_vartime (C.to_vartime b - C.to_vartime a)))
+    (W.eq_vartime d (C.from (C.to b - C.to a)))
 
 sub :: H.Assertion
 sub = do
@@ -96,7 +96,7 @@
     ((W.from_vartime a * W.from_vartime b) `mod` W.from_vartime m)
     (W.from_vartime p)
   H.assertBool t
-    (W.eq_vartime p (C.from_vartime (C.to_vartime a * C.to_vartime b)))
+    (W.eq_vartime p (C.from (C.to a * C.to b)))
 
 mul :: H.Assertion
 mul = do
@@ -122,54 +122,54 @@
   arbitrary = fmap W.to_vartime Q.arbitrary
 
 instance Q.Arbitrary C.Montgomery where
-  arbitrary = fmap C.to_vartime Q.arbitrary
+  arbitrary = fmap C.to Q.arbitrary
 
 add_matches :: W.Wider -> W.Wider -> Bool
 add_matches a b =
-  let ma = C.to_vartime a
-      mb = C.to_vartime b
+  let ma = C.to a
+      mb = C.to b
       ia = W.from_vartime a
       ib = W.from_vartime b
       im = W.from_vartime m
   in  W.eq_vartime
         (W.to_vartime ((ia + ib) `mod` im))
-        (C.from_vartime (ma + mb))
+        (C.from (ma + mb))
 
 mul_matches :: W.Wider -> W.Wider -> Bool
 mul_matches a b =
-  let ma = C.to_vartime a
-      mb = C.to_vartime b
+  let ma = C.to a
+      mb = C.to b
       ia = W.from_vartime a
       ib = W.from_vartime b
       im = W.from_vartime m
   in  W.eq_vartime
         (W.to_vartime ((ia * ib) `mod` im))
-        (C.from_vartime (ma * mb))
+        (C.from (ma * mb))
 
 sqr_matches :: W.Wider -> Bool
 sqr_matches a =
-  let ma = C.to_vartime a
+  let ma = C.to a
       ia = W.from_vartime a
       im = W.from_vartime m
   in  W.eq_vartime
         (W.to_vartime ((ia * ia) `mod` im))
-        (C.from_vartime (C.sqr ma))
+        (C.from (C.sqr ma))
 
 exp_matches :: C.Montgomery -> W.Wider -> Bool
 exp_matches a b =
-  let ia = W.from_vartime (C.from_vartime a)
+  let ia = W.from_vartime (C.from a)
       nb = fromIntegral (W.from_vartime b)
       nm = fromIntegral (W.from_vartime m)
   in  W.eq_vartime
         (W.to_vartime (modexp ia nb nm))
-        (C.from_vartime (C.exp a b))
+        (C.from (C.exp a b))
 
 inv_valid :: Q.NonZero C.Montgomery -> Bool
 inv_valid (Q.NonZero s) = C.eq_vartime (C.inv s * s) 1
 
 odd_correct :: C.Montgomery -> Bool
 odd_correct w =
-  C.odd_vartime w == I.integerTestBit (W.from_vartime (C.from_vartime w)) 0
+  C.odd_vartime w == I.integerTestBit (W.from_vartime (C.from w)) 0
 
 tests :: TestTree
 tests = testGroup "montgomery tests (curve)" [
diff --git a/test/Montgomery/Scalar.hs b/test/Montgomery/Scalar.hs
--- a/test/Montgomery/Scalar.hs
+++ b/test/Montgomery/Scalar.hs
@@ -41,7 +41,7 @@
 mm = 0xFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFEBAAEDCE6AF48A03BBFD25E8CD0364141
 
 repr :: H.Assertion
-repr = H.assertBool mempty (W.eq_vartime 0 (S.from_vartime mm))
+repr = H.assertBool mempty (W.eq_vartime 0 (S.from mm))
 
 add_case :: String -> W.Wider -> W.Wider -> W.Wider -> H.Assertion
 add_case t a b s = do
@@ -49,7 +49,7 @@
     ((W.from_vartime a + W.from_vartime b) `mod` W.from_vartime m)
     (W.from_vartime s)
   H.assertBool t
-    (W.eq_vartime s (S.from_vartime (S.to_vartime a + S.to_vartime b)))
+    (W.eq_vartime s (S.from (S.to a + S.to b)))
 
 add :: H.Assertion
 add = do
@@ -73,7 +73,7 @@
     ((W.from_vartime b - W.from_vartime a) `mod` W.from_vartime m)
     (W.from_vartime d)
   H.assertBool t
-    (W.eq_vartime d (S.from_vartime (S.to_vartime b - S.to_vartime a)))
+    (W.eq_vartime d (S.from (S.to b - S.to a)))
 
 sub :: H.Assertion
 sub = do
@@ -96,7 +96,7 @@
     ((W.from_vartime a * W.from_vartime b) `mod` W.from_vartime m)
     (W.from_vartime p)
   H.assertBool t
-    (W.eq_vartime p (S.from_vartime (S.to_vartime a * S.to_vartime b)))
+    (W.eq_vartime p (S.from (S.to a * S.to b)))
 
 mul :: H.Assertion
 mul = do
@@ -122,47 +122,47 @@
   arbitrary = fmap W.to_vartime Q.arbitrary
 
 instance Q.Arbitrary S.Montgomery where
-  arbitrary = fmap S.to_vartime Q.arbitrary
+  arbitrary = fmap S.to Q.arbitrary
 
 add_matches :: W.Wider -> W.Wider -> Bool
 add_matches a b =
-  let ma = S.to_vartime a
-      mb = S.to_vartime b
+  let ma = S.to a
+      mb = S.to b
       ia = W.from_vartime a
       ib = W.from_vartime b
       im = W.from_vartime m
   in  W.eq_vartime
         (W.to_vartime ((ia + ib) `mod` im))
-        (S.from_vartime (ma + mb))
+        (S.from (ma + mb))
 
 mul_matches :: W.Wider -> W.Wider -> Bool
 mul_matches a b =
-  let ma = S.to_vartime a
-      mb = S.to_vartime b
+  let ma = S.to a
+      mb = S.to b
       ia = W.from_vartime a
       ib = W.from_vartime b
       im = W.from_vartime m
   in  W.eq_vartime
         (W.to_vartime ((ia * ib) `mod` im))
-        (S.from_vartime (ma * mb))
+        (S.from (ma * mb))
 
 sqr_matches :: W.Wider -> Bool
 sqr_matches a =
-  let ma = S.to_vartime a
+  let ma = S.to a
       ia = W.from_vartime a
       im = W.from_vartime m
   in  W.eq_vartime
         (W.to_vartime ((ia * ia) `mod` im))
-        (S.from_vartime (S.sqr ma))
+        (S.from (S.sqr ma))
 
 exp_matches :: S.Montgomery -> W.Wider -> Bool
 exp_matches a b =
-  let ia = W.from_vartime (S.from_vartime a)
+  let ia = W.from_vartime (S.from a)
       nb = fromIntegral (W.from_vartime b)
       nm = fromIntegral (W.from_vartime m)
   in  W.eq_vartime
         (W.to_vartime (modexp ia nb nm))
-        (S.from_vartime (S.exp a b))
+        (S.from (S.exp a b))
 
 inv_valid :: Q.NonZero S.Montgomery -> Bool
 inv_valid (Q.NonZero s) = S.eq_vartime (S.inv s * s) 1