diff --git a/character-cases.cabal b/character-cases.cabal --- a/character-cases.cabal +++ b/character-cases.cabal @@ -4,10 +4,10 @@ -- -- see: https://github.com/sol/hpack -- --- hash: 5614d4d110a1d3c8b6b1d2c616279aedf4fefc18a5bc46717901dc71da1e3306 +-- hash: 8fb42b05c6e98302050fa2939fb2dc2521a5a515271a9a8597dddc2b8a88aa32 name: character-cases -version: 0.1.0.1 +version: 0.1.0.2 synopsis: Exposes subspecies types of Char. And naming cases. description: e.g. meaning of [a-z], [A-Z], [0-9], PascalCase, camelCase, and snake_case. Please see https://github.com/aiya000/hs-character-cases#README.md category: Simple diff --git a/src/Data/Char/Cases.hs b/src/Data/Char/Cases.hs --- a/src/Data/Char/Cases.hs +++ b/src/Data/Char/Cases.hs @@ -290,40 +290,40 @@ -- | -- [a-zA-Z0-9_] -- --- Please see 'Sneak'. -data SneakChar = SneakUnderscore -- ^ _ - | SneakAlphaNum AlphaNumChar -- ^ [a-zA-Z0-9] +-- Please see 'Snake'. +data SnakeChar = SnakeUnderscore -- ^ _ + | SnakeAlphaNum AlphaNumChar -- ^ [a-zA-Z0-9] deriving (Show, Eq) -unSneakChar :: SneakChar -> Char -unSneakChar SneakUnderscore = '_' -unSneakChar (SneakAlphaNum x) = alphaNumToChar x +unSnakeChar :: SnakeChar -> Char +unSnakeChar SnakeUnderscore = '_' +unSnakeChar (SnakeAlphaNum x) = alphaNumToChar x -sneakChar :: CodeParsing m => m SneakChar -sneakChar = - SneakUnderscore <$ P.char '_' <|> - SneakAlphaNum <$> alphaNumChar +snakeChar :: CodeParsing m => m SnakeChar +snakeChar = + SnakeUnderscore <$ P.char '_' <|> + SnakeAlphaNum <$> alphaNumChar -charToSneak :: Char -> Maybe SneakChar -charToSneak x = P.parseMaybe sneakChar [x] +charToSnake :: Char -> Maybe SnakeChar +charToSnake x = P.parseMaybe snakeChar [x] -- | -- Extracts a Char of [a-zA-Z0-9_]. -- Also throws compile error if non [a-zA-Z0-9_] is passed. -- --- >>> [sneakCharQ|x|] --- SneakAlphaNum (AlphaNumAlpha (AlphaLower X_)) +-- >>> [snakeCharQ|x|] +-- SnakeAlphaNum (AlphaNumAlpha (AlphaLower X_)) -- --- >>> [sneakCharQ|X|] --- SneakAlphaNum (AlphaNumAlpha (AlphaUpper X)) +-- >>> [snakeCharQ|X|] +-- SnakeAlphaNum (AlphaNumAlpha (AlphaUpper X)) -- --- >>> [sneakCharQ|_|] --- SneakUnderscore +-- >>> [snakeCharQ|_|] +-- SnakeUnderscore -- --- >>> [sneakCharQ|9|] --- SneakAlphaNum (AlphaNumDigit D9) -sneakCharQ :: QuasiQuoter -sneakCharQ = QuasiQuoter +-- >>> [snakeCharQ|9|] +-- SnakeAlphaNum (AlphaNumDigit D9) +snakeCharQ :: QuasiQuoter +snakeCharQ = QuasiQuoter { quoteExp = expQ , quotePat = error "not supported" , quoteType = error "not supported" @@ -331,52 +331,52 @@ } where expQ :: String -> Q Exp - expQ [] = fail "sneakCharQ required a Char, but nothign is specified." + expQ [] = fail "snakeCharQ required a Char, but nothign is specified." - expQ (x : []) = case charToSneak x of - Nothing -> fail [i|'${x}' is not a SneakChar.|] - Just SneakUnderscore -> - conE $ mkName "SneakUnderscore" - Just (SneakAlphaNum _) -> - (ConE (mkName "SneakAlphaNum") `AppE`) <$> (quoteExp alphaNumCharQ) [x] + expQ (x : []) = case charToSnake x of + Nothing -> fail [i|'${x}' is not a SnakeChar.|] + Just SnakeUnderscore -> + conE $ mkName "SnakeUnderscore" + Just (SnakeAlphaNum _) -> + (ConE (mkName "SnakeAlphaNum") `AppE`) <$> (quoteExp alphaNumCharQ) [x] - expQ xs@(_ : _) = fail [i|sneakCharQ required a Char, but a String is specified: ${xs}|] + expQ xs@(_ : _) = fail [i|snakeCharQ required a Char, but a String is specified: ${xs}|] -- | -- [a-zA-Z_] -- --- Please see 'Sneak'. -data SneakHeadChar = SneakHeadUnderscore - | SneakHeadAlpha AlphaChar +-- Please see 'Snake'. +data SnakeHeadChar = SnakeHeadUnderscore + | SnakeHeadAlpha AlphaChar deriving (Show, Eq) -unSneakHeadChar :: SneakHeadChar -> Char -unSneakHeadChar SneakHeadUnderscore = '_' -unSneakHeadChar (SneakHeadAlpha x) = alphaToChar x +unSnakeHeadChar :: SnakeHeadChar -> Char +unSnakeHeadChar SnakeHeadUnderscore = '_' +unSnakeHeadChar (SnakeHeadAlpha x) = alphaToChar x -sneakHeadChar :: CodeParsing m => m SneakHeadChar -sneakHeadChar = - SneakHeadUnderscore <$ P.char '_' <|> - SneakHeadAlpha <$> alphaChar +snakeHeadChar :: CodeParsing m => m SnakeHeadChar +snakeHeadChar = + SnakeHeadUnderscore <$ P.char '_' <|> + SnakeHeadAlpha <$> alphaChar -charToSneakHead :: Char -> Maybe SneakHeadChar -charToSneakHead x = P.parseMaybe sneakHeadChar [x] +charToSnakeHead :: Char -> Maybe SnakeHeadChar +charToSnakeHead x = P.parseMaybe snakeHeadChar [x] -- | -- Extracts a Char of [a-zA-Z_]. -- Also throws compile error if non [a-zA-Z_] is passed. -- --- >>> [sneakHeadCharQ|x|] --- SneakHeadAlpha (AlphaLower X_) +-- >>> [snakeHeadCharQ|x|] +-- SnakeHeadAlpha (AlphaLower X_) -- --- >>> [sneakHeadCharQ|X|] --- SneakHeadAlpha (AlphaUpper X) +-- >>> [snakeHeadCharQ|X|] +-- SnakeHeadAlpha (AlphaUpper X) -- --- >>> [sneakHeadCharQ|_|] --- SneakHeadUnderscore -sneakHeadCharQ :: QuasiQuoter -sneakHeadCharQ = QuasiQuoter +-- >>> [snakeHeadCharQ|_|] +-- SnakeHeadUnderscore +snakeHeadCharQ :: QuasiQuoter +snakeHeadCharQ = QuasiQuoter { quoteExp = expQ , quotePat = error "not supported" , quoteType = error "not supported" @@ -384,13 +384,13 @@ } where expQ :: String -> Q Exp - expQ [] = fail "sneakHeadCharQ required a Char, but nothign is specified." + expQ [] = fail "snakeHeadCharQ required a Char, but nothign is specified." - expQ (x : []) = case charToSneakHead x of - Nothing -> fail [i|'${x}' is not a SneakHeadChar.|] - Just SneakHeadUnderscore -> - conE $ mkName "SneakHeadUnderscore" - Just (SneakHeadAlpha _) -> - (ConE (mkName "SneakHeadAlpha") `AppE`) <$> (quoteExp alphaCharQ) [x] + expQ (x : []) = case charToSnakeHead x of + Nothing -> fail [i|'${x}' is not a SnakeHeadChar.|] + Just SnakeHeadUnderscore -> + conE $ mkName "SnakeHeadUnderscore" + Just (SnakeHeadAlpha _) -> + (ConE (mkName "SnakeHeadAlpha") `AppE`) <$> (quoteExp alphaCharQ) [x] - expQ xs@(_ : _) = fail [i|sneakHeadCharQ required a Char, but a String is specified: ${xs}|] + expQ xs@(_ : _) = fail [i|snakeHeadCharQ required a Char, but a String is specified: ${xs}|] diff --git a/src/Data/String/Cases.hs b/src/Data/String/Cases.hs --- a/src/Data/String/Cases.hs +++ b/src/Data/String/Cases.hs @@ -144,37 +144,37 @@ pure $ ConE (mkName "Camel") `AppE` z `AppE` ListE zs --- | Non empty sneak_case names "[a-zA-Z_][a-zA-Z0-9_]*" -data Sneak = Sneak SneakHeadChar [SneakChar] +-- | Non empty snake_case names "[a-zA-Z_][a-zA-Z0-9_]*" +data Snake = Snake SnakeHeadChar [SnakeChar] deriving (Show, Eq) -instance Pretty Sneak where - pretty = String.fromString . unSneakCase +instance Pretty Snake where + pretty = String.fromString . unSnakeCase -unSneakCase :: Sneak -> String -unSneakCase (Sneak x xs) = - unSneakHeadChar x : map unSneakChar xs +unSnakeCase :: Snake -> String +unSnakeCase (Snake x xs) = + unSnakeHeadChar x : map unSnakeChar xs -parseSneakCase :: CodeParsing m => m Sneak -parseSneakCase = - Sneak <$> - sneakHeadChar <*> - P.many sneakChar +parseSnakeCase :: CodeParsing m => m Snake +parseSnakeCase = + Snake <$> + snakeHeadChar <*> + P.many snakeChar -- | -- Simular to 'nonEmptyQ', --- but naming outsides of 'Sneak' will be rejected. +-- but naming outsides of 'Snake' will be rejected. -- --- >>> [sneakQ|foo_bar|] --- Sneak (SneakHeadAlpha (AlphaLower F_)) [SneakAlphaNum (AlphaNumAlpha (AlphaLower O_)),SneakAlphaNum (AlphaNumAlpha (AlphaLower O_)),SneakUnderscore,SneakAlphaNum (AlphaNumAlpha (AlphaLower B_)),SneakAlphaNum (AlphaNumAlpha (AlphaLower A_)),SneakAlphaNum (AlphaNumAlpha (AlphaLower R_))] +-- >>> [snakeQ|foo_bar|] +-- Snake (SnakeHeadAlpha (AlphaLower F_)) [SnakeAlphaNum (AlphaNumAlpha (AlphaLower O_)),SnakeAlphaNum (AlphaNumAlpha (AlphaLower O_)),SnakeUnderscore,SnakeAlphaNum (AlphaNumAlpha (AlphaLower B_)),SnakeAlphaNum (AlphaNumAlpha (AlphaLower A_)),SnakeAlphaNum (AlphaNumAlpha (AlphaLower R_))] -- --- >>> [sneakQ|__constructor|] --- Sneak SneakHeadUnderscore [SneakUnderscore,SneakAlphaNum (AlphaNumAlpha (AlphaLower C_)),SneakAlphaNum (AlphaNumAlpha (AlphaLower O_)),SneakAlphaNum (AlphaNumAlpha (AlphaLower N_)),SneakAlphaNum (AlphaNumAlpha (AlphaLower S_)),SneakAlphaNum (AlphaNumAlpha (AlphaLower T_)),SneakAlphaNum (AlphaNumAlpha (AlphaLower R_)),SneakAlphaNum (AlphaNumAlpha (AlphaLower U_)),SneakAlphaNum (AlphaNumAlpha (AlphaLower C_)),SneakAlphaNum (AlphaNumAlpha (AlphaLower T_)),SneakAlphaNum (AlphaNumAlpha (AlphaLower O_)),SneakAlphaNum (AlphaNumAlpha (AlphaLower R_))] +-- >>> [snakeQ|__constructor|] +-- Snake SnakeHeadUnderscore [SnakeUnderscore,SnakeAlphaNum (AlphaNumAlpha (AlphaLower C_)),SnakeAlphaNum (AlphaNumAlpha (AlphaLower O_)),SnakeAlphaNum (AlphaNumAlpha (AlphaLower N_)),SnakeAlphaNum (AlphaNumAlpha (AlphaLower S_)),SnakeAlphaNum (AlphaNumAlpha (AlphaLower T_)),SnakeAlphaNum (AlphaNumAlpha (AlphaLower R_)),SnakeAlphaNum (AlphaNumAlpha (AlphaLower U_)),SnakeAlphaNum (AlphaNumAlpha (AlphaLower C_)),SnakeAlphaNum (AlphaNumAlpha (AlphaLower T_)),SnakeAlphaNum (AlphaNumAlpha (AlphaLower O_)),SnakeAlphaNum (AlphaNumAlpha (AlphaLower R_))] -- --- >>> [sneakQ|FOO_MEE_9|] --- Sneak (SneakHeadAlpha (AlphaUpper F)) [SneakAlphaNum (AlphaNumAlpha (AlphaUpper O)),SneakAlphaNum (AlphaNumAlpha (AlphaUpper O)),SneakUnderscore,SneakAlphaNum (AlphaNumAlpha (AlphaUpper M)),SneakAlphaNum (AlphaNumAlpha (AlphaUpper E)),SneakAlphaNum (AlphaNumAlpha (AlphaUpper E)),SneakUnderscore,SneakAlphaNum (AlphaNumDigit D9)] -sneakQ :: QuasiQuoter -sneakQ = QuasiQuoter +-- >>> [snakeQ|FOO_MEE_9|] +-- Snake (SnakeHeadAlpha (AlphaUpper F)) [SnakeAlphaNum (AlphaNumAlpha (AlphaUpper O)),SnakeAlphaNum (AlphaNumAlpha (AlphaUpper O)),SnakeUnderscore,SnakeAlphaNum (AlphaNumAlpha (AlphaUpper M)),SnakeAlphaNum (AlphaNumAlpha (AlphaUpper E)),SnakeAlphaNum (AlphaNumAlpha (AlphaUpper E)),SnakeUnderscore,SnakeAlphaNum (AlphaNumDigit D9)] +snakeQ :: QuasiQuoter +snakeQ = QuasiQuoter { quoteExp = expQ , quotePat = error "not supported" , quoteType = error "not supported" @@ -182,11 +182,11 @@ } where expQ :: String -> Q Exp - expQ [] = fail "sneakQ required a non empty string, but the empty string is specified." + expQ [] = fail "snakeQ required a non empty string, but the empty string is specified." expQ (x : xs) = do - z <- (quoteExp sneakHeadCharQ) [x] - zs <- mapM (quoteExp sneakCharQ) $ map (: []) xs - pure $ ConE (mkName "Sneak") `AppE` z `AppE` ListE zs + z <- (quoteExp snakeHeadCharQ) [x] + zs <- mapM (quoteExp snakeCharQ) $ map (: []) xs + pure $ ConE (mkName "Snake") `AppE` z `AppE` ListE zs -- | Non empty "veryflatten" names [a-z]+ diff --git a/test/doctest/Main.hs b/test/doctest/Main.hs --- a/test/doctest/Main.hs +++ b/test/doctest/Main.hs @@ -13,8 +13,7 @@ ghcExtensions :: [String] ghcExtensions = - [ "-XAutoDeriveTypeable" - , "-XBangPatterns" + [ "-XBangPatterns" , "-XBinaryLiterals" , "-XConstraintKinds" , "-XDataKinds" @@ -36,7 +35,6 @@ , "-XInstanceSigs" , "-XKindSignatures" , "-XLambdaCase" - , "-XMonadFailDesugaring" , "-XMultiParamTypeClasses" , "-XMultiWayIf" , "-XNamedFieldPuns"