Annotate all exposed functions with "since"

Author: adithyaov

lib/Unicode/Char/Case.hs

@@ -19,6 +19,7 @@ import qualified Unicode.Internal.Char.DerivedCoreProperties as P
 --
 -- prop> isLower c == Data.Char.isLower c
 --
+-- @since 0.1.0
 {-# INLINE isLower #-}
 isLower :: Char -> Bool
 isLower = P.isLowercase
@@ -28,6 +29,7 @@ isLower = P.isLowercase
 --
 -- prop> isUpper c == Data.Char.isUpper c
 --
+-- @since 0.1.0
 {-# INLINE isUpper #-}
 isUpper :: Char -> Bool
 isUpper = P.isUppercase

lib/Unicode/Char/General.hs

@@ -436,24 +436,34 @@ isSymbol c = case generalCategory c of
 jamoLFirst, jamoLCount, jamoLLast :: Int
 
 -- | First leading consonant jamo.
+--
+-- @since 0.1.0
 jamoLFirst  = 0x1100
 
 -- | Total count of leading consonant jamo.
 jamoLCount = 19
 
 -- | Last leading consonant jamo.
+--
+-- @since 0.1.0
 jamoLLast = jamoLFirst + jamoLCount - 1
 
 -- jamo vowel
 jamoVFirst, jamoVCount, jamoVLast :: Int
 
 -- | First vowel jamo.
+--
+-- @since 0.1.0
 jamoVFirst  = 0x1161
 
 -- | Total count of vowel jamo.
+--
+-- @since 0.1.0
 jamoVCount = 21
 
 -- | Last vowel jamo.
+--
+-- @since 0.1.0
 jamoVLast = jamoVFirst + jamoVCount - 1
 
 -- jamo trailing
@@ -463,47 +473,67 @@ jamoTFirst, jamoTCount :: Int
 --
 -- Note that 'jamoTFirst' does not represent a valid T, it represents a missing
 -- T i.e. LV without a T. See comments under 'jamoTIndex' .
+--
+-- @since 0.1.0
 jamoTFirst  = 0x11a7
 
 -- | Total count of trailing consonant jamo.
+--
+-- @since 0.1.0
 jamoTCount = 28
 
 -- | Last trailing consonant jamo.
+--
+-- @since 0.1.0
 jamoTLast :: Int
 jamoTLast = jamoTFirst + jamoTCount - 1
 
 -- | Total count of all jamo characters.
 --
 -- @jamoNCount = jamoVCount * jamoTCount@
+--
+-- @since 0.1.0
 jamoNCount :: Int
 jamoNCount = 588
 
 -- hangul
 hangulFirst, hangulLast :: Int
 
 -- | Codepoint of the first pre-composed Hangul character.
+--
+-- @since 0.1.0
 hangulFirst = 0xac00
 
 -- | Codepoint of the last Hangul character.
+--
+-- @since 0.1.0
 hangulLast = hangulFirst + jamoLCount * jamoVCount * jamoTCount - 1
 
 -- | Determine if the given character is a precomposed Hangul syllable.
+--
+-- @since 0.1.0
 isHangul :: Char -> Bool
 isHangul c = n >= hangulFirst && n <= hangulLast
     where n = ord c
 
 -- | Determine if the given character is a Hangul LV syllable.
+--
+-- @since 0.1.0
 isHangulLV :: Char -> Bool
 isHangulLV c = assert (jamoTCount == 28)
     snd (quotRem28 (ord c - hangulFirst)) == 0
 
 -- | Determine whether a character is a jamo L, V or T character.
+--
+-- @since 0.1.0
 isJamo :: Char -> Bool
 isJamo c = n >= jamoLFirst && n <= jamoTLast
     where n = ord c
 
 -- | Given a Unicode character, if it is a leading jamo, return its index in
 -- the list of leading jamo consonants, otherwise return 'Nothing'.
+--
+-- @since 0.1.0
 jamoLIndex :: Char -> Maybe Int
 jamoLIndex c
   | index >= 0 && index < jamoLCount = Just index
@@ -512,6 +542,8 @@ jamoLIndex c
 
 -- | Given a Unicode character, if it is a vowel jamo, return its index in the
 -- list of vowel jamo, otherwise return 'Nothing'.
+--
+-- @since 0.1.0
 jamoVIndex :: Char -> Maybe Int
 jamoVIndex c
   | index >= 0 && index < jamoVCount = Just index
@@ -526,6 +558,7 @@ jamoVIndex c
 -- Decomposition" in the Conformance chapter of the Unicode standard for more
 -- details.
 --
+-- @since 0.1.0
 jamoTIndex :: Char -> Maybe Int
 jamoTIndex c
   | index > 0 && index < jamoTCount = Just index

lib/Unicode/Char/Identifiers.hs

@@ -22,18 +22,24 @@ import qualified Unicode.Internal.Char.DerivedCoreProperties as P
 import qualified Unicode.Internal.Char.PropList as P
 
 -- | Returns 'True' if a character is an identifier continue character.
+--
+-- @since 0.2.0
 {-# INLINE isIDContinue #-}
 isIDContinue :: Char -> Bool
 isIDContinue = P.isID_Continue
 
 -- | Returns 'True' if a character is an identifier start character.
+--
+-- @since 0.2.0
 {-# INLINE isIDStart #-}
 isIDStart :: Char -> Bool
 isIDStart = P.isID_Start
 
 -- | Returns 'True' if a character is an identifier continue character,
 -- using the NFKC modifications detailed in
 -- [UAX #31, 5.1](https://www.unicode.org/reports/tr31/#NFKC_Modifications).
+--
+-- @since 0.2.0
 {-# INLINE isXIDContinue #-}
 isXIDContinue :: Char -> Bool
 isXIDContinue = P.isXID_Continue
@@ -42,16 +48,22 @@ isXIDContinue = P.isXID_Continue
 -- | Returns 'True' if a character is an identifier start character,
 -- using the NFKC modifications detailed in
 -- [UAX #31, 5.1](https://www.unicode.org/reports/tr31/#NFKC_Modifications).
+--
+-- @since 0.2.0
 {-# INLINE isXIDStart #-}
 isXIDStart :: Char -> Bool
 isXIDStart = P.isXID_Start
 
 -- | Returns 'True' if a character is a pattern syntax character.
+--
+-- @since 0.2.0
 {-# INLINE isPatternSyntax #-}
 isPatternSyntax :: Char -> Bool
 isPatternSyntax = P.isPattern_Syntax
 
 -- | Returns 'True' if a character is a pattern whitespace character.
+--
+-- @since 0.2.0
 {-# INLINE isPatternWhitespace #-}
 isPatternWhitespace :: Char -> Bool
 isPatternWhitespace = P.isPattern_White_Space

lib/Unicode/Char/Normalization.hs

@@ -73,18 +73,24 @@ import qualified Unicode.Internal.Char.UnicodeData.DecompositionsK as K
 -- | Compose a starter character (combining class 0) with a combining character
 -- (non-zero combining class). Returns the composed character if the starter
 -- combines with the combining character, returns 'Nothing' otherwise.
+--
+-- @since 0.1.0
 {-# INLINE compose #-}
 compose :: Char -> Char -> Maybe Char
 compose = C.compose
 
 -- | Compose a starter character with another starter character.  Returns the
 -- composed character if the two starters combine, returns 'Nothing' otherwise.
+--
+-- @since 0.1.0
 {-# INLINE composeStarters #-}
 composeStarters :: Char -> Char -> Maybe Char
 composeStarters = C.composeStarters
 
 -- | Return 'True' if a starter character may combine with some preceding
 -- starter character.
+--
+-- @since 0.1.0
 {-# INLINE isCombiningStarter #-}
 isCombiningStarter :: Char -> Bool
 isCombiningStarter = C.isSecondStarter
@@ -98,10 +104,14 @@ isCombiningStarter = C.isSecondStarter
 -------------------------------------------------------------------------------
 
 -- | Whether we are decomposing in canonical or compatibility mode.
+--
+-- @since 0.1.0
 data DecomposeMode = Canonical | Kompat
 
 -- | Decompose a non-Hangul character into its canonical or compatibility
 -- decompositions.  Note that the resulting characters may further decompose.
+--
+-- @since 0.1.0
 {-# INLINE decompose #-}
 decompose :: DecomposeMode -> Char -> [Char]
 decompose Canonical  = D.decompose
@@ -110,6 +120,8 @@ decompose Kompat = K.decompose
 -- | Given a non-Hangul character determine if the character is decomposable.
 -- Note that in case compatibility decompositions a character may decompose
 -- into a single compatibility character.
+--
+-- @since 0.1.0
 {-# INLINE isDecomposable #-}
 isDecomposable :: DecomposeMode -> Char -> Bool
 isDecomposable Canonical  = D.isDecomposable
@@ -120,6 +132,8 @@ isDecomposable Kompat = K.isDecomposable
 -------------------------------------------------------------------------------
 
 -- | Decompose a Hangul syllable into its corresponding Jamo characters.
+--
+-- @since 0.1.0
 {-# INLINE decomposeHangul #-}
 decomposeHangul :: Char -> (Char, Char, Char)
 decomposeHangul c = (l, v, t)
@@ -140,11 +154,15 @@ decomposeHangul c = (l, v, t)
 -- Determine the combining properties of characters.
 
 -- | Returns the combining class of a character.
+--
+-- @since 0.1.0
 {-# INLINE combiningClass #-}
 combiningClass :: Char -> Int
 combiningClass = CC.combiningClass
 
 -- | Returns 'True' if a character is a combining character.
+--
+-- @since 0.1.0
 {-# INLINE isCombining #-}
 isCombining :: Char -> Bool
 isCombining = CC.isCombining