Switch initialism style to follow the rest of the Haskell world

6 files changed, 60 insertions, 60 deletions

diff --git a/src/Data/Digest.hs b/src/Data/Digest.hs
index 3bd042c..34279e5 100644
--- a/src/Data/Digest.hs
+++ b/src/Data/Digest.hs
@@ -35,23 +35,23 @@ import Internal.Digest
 type LazyByteString = ByteString.Lazy.ByteString
 
 md5, sha1, sha224, sha256, sha384, sha512 :: Algorithm
-md5    = Algorithm evpMd5
-sha1   = Algorithm evpSha1
-sha224 = Algorithm evpSha224
-sha256 = Algorithm evpSha256
-sha384 = Algorithm evpSha384
-sha512 = Algorithm evpSha512
+md5    = Algorithm evpMD5
+sha1   = Algorithm evpSHA1
+sha224 = Algorithm evpSHA224
+sha256 = Algorithm evpSHA256
+sha384 = Algorithm evpSHA384
+sha512 = Algorithm evpSHA512
 
 -- | Hashes according to the given 'Algorithm'.
 hash :: Algorithm -> LazyByteString -> Digest
 hash (Algorithm md) bytes =
   unsafeLocalState $ do
-    ctxFP <- mallocEvpMdCtx
+    ctxFP <- mallocEVPMDCtx
     withForeignPtr ctxFP $ \ctx -> do
       evpDigestInitEx ctx md noEngine
       mapM_ (updateBytes ctx) (ByteString.Lazy.toChunks bytes)
       d <-
-        allocaArray evpMaxMdSize $ \mdOut ->
+        allocaArray evpMaxMDSize $ \mdOut ->
           alloca $ \pOutSize -> do
             evpDigestFinalEx ctx mdOut pOutSize
             outSize <- fromIntegral <$> peek pOutSize
diff --git a/src/Data/Digest/Internal.hs b/src/Data/Digest/Internal.hs
index be88e68..859f765 100644
--- a/src/Data/Digest/Internal.hs
+++ b/src/Data/Digest/Internal.hs
@@ -21,10 +21,10 @@ import Data.Char (intToDigit)
 import Data.Word (Word8)
 import Foreign (Ptr)
 
-import Internal.Base (EvpMd)
+import Internal.Base (EVPMD)
 
 -- | A cryptographic hash function.
-newtype Algorithm = Algorithm (Ptr EvpMd)
+newtype Algorithm = Algorithm (Ptr EVPMD)
 
 -- | The result of a hash operation.
 newtype Digest = Digest ByteString
diff --git a/src/Data/Hmac.hs b/src/Data/HMAC.hs
index 2211248..1ad1bfb 100644
--- a/src/Data/Hmac.hs
+++ b/src/Data/HMAC.hs
@@ -12,9 +12,9 @@
 -- License for the specific language governing permissions and limitations under
 -- the License.
 
-module Data.Hmac
+module Data.HMAC
   ( SecretKey(SecretKey)
-  , Hmac
+  , HMAC
   , hmac
   ) where
 
@@ -30,7 +30,7 @@ import Data.Digest.Internal (Algorithm(Algorithm), Digest(Digest))
 import Foreign.Ptr.ConstantTimeEquals (constantTimeEquals)
 import Internal.Base
 import Internal.Digest
-import Internal.Hmac
+import Internal.HMAC
 
 type LazyByteString = ByteString.Lazy.ByteString
 
@@ -41,29 +41,29 @@ newtype SecretKey = SecretKey ByteString
 
 -- | A hash-based message authentication code. Equality comparisons on this type
 -- are constant-time.
-newtype Hmac = Hmac ByteString
+newtype HMAC = HMAC ByteString
 
-instance Eq Hmac where
-  (Hmac a) == (Hmac b) =
+instance Eq HMAC where
+  (HMAC a) == (HMAC b) =
     unsafeLocalState $
       ByteString.unsafeUseAsCStringLen a $ \(a', size) ->
         ByteString.unsafeUseAsCStringLen b $ \(b', _) ->
           constantTimeEquals a' b' size
 
-instance Show Hmac where
-  show (Hmac m) = show (Digest m)
+instance Show HMAC where
+  show (HMAC m) = show (Digest m)
 
 -- | Creates an HMAC according to the given 'Algorithm'.
-hmac :: Algorithm -> SecretKey -> LazyByteString -> Hmac
+hmac :: Algorithm -> SecretKey -> LazyByteString -> HMAC
 hmac (Algorithm md) (SecretKey key) bytes =
   unsafeLocalState $ do
-    ctxFP <- mallocHmacCtx
+    ctxFP <- mallocHMACCtx
     withForeignPtr ctxFP $ \ctx -> do
       ByteString.unsafeUseAsCStringLen key $ \(keyBytes, keySize) ->
         hmacInitEx ctx keyBytes (fromIntegral keySize) md noEngine
       mapM_ (updateBytes ctx) (ByteString.Lazy.toChunks bytes)
       m <-
-        allocaArray evpMaxMdSize $ \hmacOut ->
+        allocaArray evpMaxMDSize $ \hmacOut ->
           alloca $ \pOutSize -> do
             hmacFinal ctx hmacOut pOutSize
             outSize <- fromIntegral <$> peek pOutSize
@@ -71,7 +71,7 @@ hmac (Algorithm md) (SecretKey key) bytes =
             -- GHC reinterpret it as a 'Ptr CChar' so that it can be ingested
             -- into a 'ByteString'.
             ByteString.packCStringLen (unsafeCoerce hmacOut, outSize)
-      return (Hmac m)
+      return (HMAC m)
   where
     updateBytes ctx chunk =
       -- 'hmacUpdate' treats its @bytes@ argument as @const@, so the sharing
diff --git a/src/Internal/Base.chs b/src/Internal/Base.chs
index 427cf6b..c2e615a 100644
--- a/src/Internal/Base.chs
+++ b/src/Internal/Base.chs
@@ -30,14 +30,14 @@ noEngine = nullPtr
 
 -- | The BoringSSL @EVP_MD_CTX@ type, representing the state of a pending
 -- hashing operation.
-data EvpMdCtx
-{#pointer *EVP_MD_CTX as 'Ptr EvpMdCtx' -> EvpMdCtx nocode#}
+data EVPMDCtx
+{#pointer *EVP_MD_CTX as 'Ptr EVPMDCtx' -> EVPMDCtx nocode#}
 
 -- | The BoringSSL @EVP_MD@ type, representing a hash algorithm.
-data EvpMd
-{#pointer *EVP_MD as 'Ptr EvpMd' -> EvpMd nocode#}
+data EVPMD
+{#pointer *EVP_MD as 'Ptr EVPMD' -> EVPMD nocode#}
 
 -- | The BoringSSL @HMAC_CTX@ type, representing the state of a pending HMAC
 -- operation.
-data HmacCtx
-{#pointer *HMAC_CTX as 'Ptr HmacCtx' -> HmacCtx nocode#}
+data HMACCtx
+{#pointer *HMAC_CTX as 'Ptr HMACCtx' -> HMACCtx nocode#}
diff --git a/src/Internal/Digest.chs b/src/Internal/Digest.chs
index 021de22..d451f1c 100644
--- a/src/Internal/Digest.chs
+++ b/src/Internal/Digest.chs
@@ -16,10 +16,10 @@
 {-# OPTIONS_GHC -Wno-orphans #-}
 
 module Internal.Digest
-  ( evpMd5, evpSha1, evpSha224, evpSha256, evpSha384, evpSha512
-  , mallocEvpMdCtx
+  ( evpMD5, evpSHA1, evpSHA224, evpSHA256, evpSHA384, evpSHA512
+  , mallocEVPMDCtx
   , evpDigestInitEx, evpDigestUpdate, evpDigestFinalEx
-  , evpMaxMdSize
+  , evpMaxMDSize
   ) where
 
 import Foreign
@@ -33,40 +33,40 @@ import Result
 
 #include <openssl/digest.h>
 
-evpMd5, evpSha1, evpSha224, evpSha256, evpSha384, evpSha512 :: Ptr EvpMd
-evpMd5    = {#call pure EVP_md5 as ^#}
-evpSha1   = {#call pure EVP_sha1 as ^#}
-evpSha224 = {#call pure EVP_sha224 as ^#}
-evpSha256 = {#call pure EVP_sha256 as ^#}
-evpSha384 = {#call pure EVP_sha384 as ^#}
-evpSha512 = {#call pure EVP_sha512 as ^#}
+evpMD5, evpSHA1, evpSHA224, evpSHA256, evpSHA384, evpSHA512 :: Ptr EVPMD
+evpMD5    = {#call pure EVP_md5 as ^#}
+evpSHA1   = {#call pure EVP_sha1 as ^#}
+evpSHA224 = {#call pure EVP_sha224 as ^#}
+evpSHA256 = {#call pure EVP_sha256 as ^#}
+evpSHA384 = {#call pure EVP_sha384 as ^#}
+evpSHA512 = {#call pure EVP_sha512 as ^#}
 
--- | Memory-safe allocator for 'EvpMdCtx'.
-mallocEvpMdCtx :: IO (ForeignPtr EvpMdCtx)
-mallocEvpMdCtx = do
+-- | Memory-safe allocator for 'EVPMDCtx'.
+mallocEVPMDCtx :: IO (ForeignPtr EVPMDCtx)
+mallocEVPMDCtx = do
   fp <- mallocForeignPtr
   withForeignPtr fp {#call EVP_MD_CTX_init as ^#}
-  addForeignPtrFinalizer btlsFinalizeEvpMdCtxPtr fp
+  addForeignPtrFinalizer btlsFinalizeEVPMDCtxPtr fp
   return fp
 
-foreign import ccall "&btlsFinalizeEvpMdCtx"
-  btlsFinalizeEvpMdCtxPtr :: FinalizerPtr EvpMdCtx
+foreign import ccall "&btlsFinalizeEVPMDCtx"
+  btlsFinalizeEVPMDCtxPtr :: FinalizerPtr EVPMDCtx
 
-evpDigestInitEx :: Ptr EvpMdCtx -> Ptr EvpMd -> Ptr Engine -> IO ()
+evpDigestInitEx :: Ptr EVPMDCtx -> Ptr EVPMD -> Ptr Engine -> IO ()
 evpDigestInitEx ctx md engine =
   requireSuccess $ {#call EVP_DigestInit_ex as ^#} ctx md engine
 
-evpDigestUpdate :: Ptr EvpMdCtx -> Ptr a -> CULong -> IO ()
+evpDigestUpdate :: Ptr EVPMDCtx -> Ptr a -> CULong -> IO ()
 evpDigestUpdate ctx md bytes =
   alwaysSucceeds $ {#call EVP_DigestUpdate as ^#} ctx (asVoidPtr md) bytes
 
-evpDigestFinalEx :: Ptr EvpMdCtx -> Ptr CUChar -> Ptr CUInt -> IO ()
+evpDigestFinalEx :: Ptr EVPMDCtx -> Ptr CUChar -> Ptr CUInt -> IO ()
 evpDigestFinalEx ctx mdOut outSize =
   alwaysSucceeds $ {#call EVP_DigestFinal_ex as ^#} ctx mdOut outSize
 
-evpMaxMdSize :: Int
-evpMaxMdSize = {#const EVP_MAX_MD_SIZE#}
+evpMaxMDSize :: Int
+evpMaxMDSize = {#const EVP_MAX_MD_SIZE#}
 
-instance Storable EvpMdCtx where
+instance Storable EVPMDCtx where
   sizeOf _ = {#sizeof EVP_MD_CTX#}
   alignment _ = {#alignof EVP_MD_CTX#}
diff --git a/src/Internal/Hmac.chs b/src/Internal/HMAC.chs
index 0ef1e2e..7e64edf 100644
--- a/src/Internal/Hmac.chs
+++ b/src/Internal/HMAC.chs
@@ -15,8 +15,8 @@
 {-# OPTIONS_GHC -Wno-missing-methods #-}
 {-# OPTIONS_GHC -Wno-orphans #-}
 
-module Internal.Hmac
-  ( mallocHmacCtx
+module Internal.HMAC
+  ( mallocHMACCtx
   , hmacInitEx, hmacUpdate, hmacFinal
   ) where
 
@@ -31,30 +31,30 @@ import Result
 
 #include <openssl/hmac.h>
 
--- | Memory-safe allocator for 'HmacCtx'.
-mallocHmacCtx :: IO (ForeignPtr HmacCtx)
-mallocHmacCtx = do
+-- | Memory-safe allocator for 'HMACCtx'.
+mallocHMACCtx :: IO (ForeignPtr HMACCtx)
+mallocHMACCtx = do
   fp <- mallocForeignPtr
   withForeignPtr fp {#call HMAC_CTX_init as ^#}
   addForeignPtrFinalizer hmacCtxCleanup fp
   return fp
 
 foreign import ccall "&HMAC_CTX_cleanup"
-  hmacCtxCleanup :: FinalizerPtr HmacCtx
+  hmacCtxCleanup :: FinalizerPtr HMACCtx
 
-hmacInitEx :: Ptr HmacCtx -> Ptr a -> CULong -> Ptr EvpMd -> Ptr Engine -> IO ()
+hmacInitEx :: Ptr HMACCtx -> Ptr a -> CULong -> Ptr EVPMD -> Ptr Engine -> IO ()
 hmacInitEx ctx bytes size md engine =
   requireSuccess $
     {#call HMAC_Init_ex as ^#} ctx (asVoidPtr bytes) size md engine
 
-hmacUpdate :: Ptr HmacCtx -> Ptr CUChar -> CULong -> IO ()
+hmacUpdate :: Ptr HMACCtx -> Ptr CUChar -> CULong -> IO ()
 hmacUpdate ctx bytes size =
   alwaysSucceeds $ {#call HMAC_Update as ^#} ctx bytes size
 
-hmacFinal :: Ptr HmacCtx -> Ptr CUChar -> Ptr CUInt -> IO ()
+hmacFinal :: Ptr HMACCtx -> Ptr CUChar -> Ptr CUInt -> IO ()
 hmacFinal ctx out outSize =
   requireSuccess $ {#call HMAC_Final as ^#} ctx out outSize
 
-instance Storable HmacCtx where
+instance Storable HMACCtx where
   sizeOf _ = {#sizeof HMAC_CTX#}
   alignment _ = {#alignof HMAC_CTX#}