diff --git a/CHANGELOG.md b/CHANGELOG.md --- a/CHANGELOG.md +++ b/CHANGELOG.md @@ -27,3 +27,7 @@ * Fourth version. Added new functions. Changed the dependency boundaries. +## 0.5.0.0 -- 2022-01-11 + +* Fifth version. Added 3 new modules CLI.Arguments.Parsing, CLI.Arguments.Arr, CLI.Arguments.Get and the new functionality to +the first one, splitted the previous one between the last two. This should improve importing opportunities. diff --git a/CLI/Arguments.hs b/CLI/Arguments.hs --- a/CLI/Arguments.hs +++ b/CLI/Arguments.hs @@ -13,9 +13,7 @@ import Data.Monoid (mappend) import Data.Maybe (fromJust) -import GHC.Arr import Data.List (sortBy) -import qualified Data.Foldable as F data Arguments = A String @@ -271,179 +269,3 @@ -> Args takeAsSortedBy = takeArgsSortedBy (\x -> notNullArguments x && isA x) {-# INLINABLE takeAsSortedBy #-} - ------------------------------------------------------- - --- | For empty list of 'String's returns empty array that has no elements. Trying to index it always returns error and can cause --- segmentation fault in the running program or interpreter (GHCi). -takeABCsArr - :: (CLSpecifications -> [String] -> Args) -- ^ A function to collect the 'Args' - -> CLSpecifications - -> [String] - -> Array Int Arguments -takeABCsArr f ts xss = listArray (0,l-1) js - where js = f ts xss - l = length js -{-# INLINABLE takeABCsArr #-} - --- | For empty list of 'String's returns empty array that has no elements. Trying to index it always returns error and can cause --- segmentation fault in the running program or interpreter (GHCi). -takeCsArr - :: CLSpecifications - -> [String] - -> Array Int Arguments -takeCsArr = takeABCsArr takeCs -{-# INLINABLE takeCsArr #-} - --- | For empty list of 'String's returns empty array that has no elements. Trying to index it always returns error and can cause --- segmentation fault in the running program or interpreter (GHCi). -takeCs1Arr - :: FirstChars -- ^ A pair of the first characters of the starting group delimiter (the same for all 'String's in the all 'CLSpecifications') and the probable its modification (the first character of the last delimiter). - -> CLSpecifications - -> [String] - -> Array Int Arguments -takeCs1Arr (x1,x2) = takeABCsArr (takeCs1 (x1,x2)) -{-# INLINABLE takeCs1Arr #-} - --- | For empty list of 'String's returns empty array that has no elements. Trying to index it always returns error and can cause --- segmentation fault in the running program or interpreter (GHCi). -takeBsArr - :: CLSpecifications - -> [String] - -> Array Int Arguments -takeBsArr = takeABCsArr takeBs -{-# INLINABLE takeBsArr #-} - --- | For empty list of 'String's returns empty array that has no elements. Trying to index it always returns error and can cause --- segmentation fault in the running program or interpreter (GHCi). -takeAsArr - :: CLSpecifications - -> [String] - -> Array Int Arguments -takeAsArr = takeABCsArr takeAs -{-# INLINABLE takeAsArr #-} - ---------------------------------------------------- - --- | For empty list of 'String's returns empty array that has no elements. Trying to index it always returns error and can cause --- segmentation fault in the running program or interpreter (GHCi). -takeABCsArrSortedBy - :: ((Arguments -> Arguments -> Ordering) -> CLSpecifications -> [String] -> Args) - -> (Arguments -> Arguments -> Ordering) -- ^ A 'compare'-like implementation for 'Arguments'. If needed you can implement your own 'Ord' instance for 'Arguments' and use it here. Here can be partial, just for 'C's. - -> CLSpecifications - -> [String] - -> Array Int Arguments -takeABCsArrSortedBy g f ts xss = listArray (0,l-1) js - where js = g f ts xss - l = length js -{-# INLINABLE takeABCsArrSortedBy #-} - --- | For empty list of 'String's returns empty array that has no elements. Trying to index it always returns error and can cause --- segmentation fault in the running program or interpreter (GHCi). -takeCsArrSortedBy - :: (Arguments -> Arguments -> Ordering) -- ^ A 'compare'-like implementation for 'Arguments'. If needed you can implement your own 'Ord' instance for 'Arguments' and use it here. Here can be partial, just for 'C's. - -> CLSpecifications - -> [String] - -> Array Int Arguments -takeCsArrSortedBy = takeABCsArrSortedBy (takeArgsSortedBy (\x -> notNullArguments x && isC x)) -{-# INLINABLE takeCsArrSortedBy #-} - --- | For empty list of 'String's returns empty array that has no elements. Trying to index it always returns error and can cause --- segmentation fault in the running program or interpreter (GHCi). -takeCs1ArrSortedBy - :: FirstChars -- ^ A pair of the first characters of the starting group delimiter (the same for all 'String's in the all 'CLSpecifications') and the probable its modification being also the first character. - -> (Arguments -> Arguments -> Ordering) -- ^ A 'compare'-like implementation for 'Arguments'. If needed you can implement your own 'Ord' instance for 'Arguments' and use it here. Here can be partial, just for 'C's. - -> CLSpecifications - -> [String] - -> Array Int Arguments -takeCs1ArrSortedBy (x1,x2) = takeABCsArrSortedBy (takeArgs1SortedBy (x1,x2) (\x -> notNullArguments x && isC x)) -{-# INLINABLE takeCs1ArrSortedBy #-} - --- | For empty list of 'String's returns empty array that has no elements. Trying to index it always returns error and can cause --- segmentation fault in the running program or interpreter (GHCi). -takeBsArrSortedBy - :: (Arguments -> Arguments -> Ordering) -- ^ A 'compare'-like implementation for 'Arguments'. If needed you can implement your own 'Ord' instance for 'Arguments' and use it here. Here can be partial, just for 'B's. - -> CLSpecifications - -> [String] - -> Array Int Arguments -takeBsArrSortedBy = takeABCsArrSortedBy (takeArgsSortedBy (\x -> notNullArguments x && isB x)) -{-# INLINABLE takeBsArrSortedBy #-} - --- | For empty list of 'String's returns empty array that has no elements. Trying to index it always returns error and can cause --- segmentation fault in the running program or interpreter (GHCi). -takeAsArrSortedBy - :: (Arguments -> Arguments -> Ordering) -- ^ A 'compare'-like implementation for 'Arguments'. If needed you can implement your own 'Ord' instance for 'Arguments' and use it here. Here can be partial, just for 'A's. - -> CLSpecifications - -> [String] - -> Array Int Arguments -takeAsArrSortedBy = takeABCsArrSortedBy (takeArgsSortedBy (\x -> notNullArguments x && isA x)) -{-# INLINABLE takeAsArrSortedBy #-} - -------------------------------------------------------------------------------- - -oneA - :: (F.Foldable t) => String -> t Arguments -> Bool -oneA xs ys = F.any (\(A ts) -> ts == xs) ys - -oneB - :: (F.Foldable t) => String -> t Arguments -> Bool -oneB xs ys = F.any (\(B _ zs _) -> zs == xs) ys - -oneC - :: (F.Foldable t) => String -> t Arguments -> Bool -oneC xs ys = F.any (\(C zs _) -> zs == xs) ys - -listA - :: (F.Foldable t) => [String] -> t Arguments -> Bool -listA xss ys - | null xss = False - | otherwise = F.any (\(A ts) -> ts `elem` xss) ys - -listB - :: (F.Foldable t) => [String] -> t Arguments -> Bool -listB xss ys - | null xss = False - | otherwise = F.any (\(B _ zs _) -> zs `elem` xss) ys - -listC - :: (F.Foldable t) => [String] -> t Arguments -> Bool -listC xss ys - | null xss = False - | otherwise = F.any (\(C zs _) -> zs `elem` xss) ys - -getA - :: (F.Foldable t) => String -> t Arguments -> String -getA xs ys - | oneA xs ys = (\(A ts) -> ts) . fromJust . F.find (\(A rs) -> rs == xs) $ ys - | otherwise = [] - -getB - :: (F.Foldable t) => String -> t Arguments -> [String] -getB xs ys - | oneB xs ys = (\(B _ _ yss) -> yss) . fromJust . F.find (\(B _ zs _) -> zs == xs) $ ys - | otherwise = [] - -getC - :: (F.Foldable t) => String -> t Arguments -> [String] -getC xs ys - | oneC xs ys = (\(C _ yss) -> yss) . fromJust . F.find (\(C zs _) -> zs == xs) $ ys - | otherwise = [] - -getLstA - :: (F.Foldable t) => [String] -> t Arguments -> [String] -getLstA xss ys - | listA xss ys = filter (not . null) . map (\xs -> getA xs ys) $ xss - | otherwise = [] - -getLstB - :: (F.Foldable t) => [String] -> t Arguments -> [[String]] -getLstB xss ys - | listB xss ys = filter (not . null) . map (\xs -> getB xs ys) $ xss - | otherwise = [] - -getLstC - :: (F.Foldable t) => [String] -> t Arguments -> [[String]] -getLstC xss ys - | listC xss ys = filter (not . null) . map (\xs -> getC xs ys) $ xss - | otherwise = [] - diff --git a/CLI/Arguments/Arr.hs b/CLI/Arguments/Arr.hs new file mode 100644 --- /dev/null +++ b/CLI/Arguments/Arr.hs @@ -0,0 +1,123 @@ +{-# OPTIONS_HADDOCK show-extensions #-} + +-- | +-- Module : CLI.Arguments.Arr +-- Copyright : (c) OleksandrZhabenko 2021-2022 +-- License : MIT +-- Stability : Experimental +-- Maintainer : olexandr543@yahoo.com +-- +-- A library to process command line arguments in some more convenient way. + +module CLI.Arguments.Arr where + +import GHC.Arr +import Data.List (sortBy) +import CLI.Arguments + +-- | For empty list of 'String's returns empty array that has no elements. Trying to index it always returns error and can cause +-- segmentation fault in the running program or interpreter (GHCi). +takeABCsArr + :: (CLSpecifications -> [String] -> Args) -- ^ A function to collect the 'Args' + -> CLSpecifications + -> [String] + -> Array Int Arguments +takeABCsArr f ts xss = listArray (0,l-1) js + where js = f ts xss + l = length js +{-# INLINABLE takeABCsArr #-} + +-- | For empty list of 'String's returns empty array that has no elements. Trying to index it always returns error and can cause +-- segmentation fault in the running program or interpreter (GHCi). +takeCsArr + :: CLSpecifications + -> [String] + -> Array Int Arguments +takeCsArr = takeABCsArr takeCs +{-# INLINABLE takeCsArr #-} + +-- | For empty list of 'String's returns empty array that has no elements. Trying to index it always returns error and can cause +-- segmentation fault in the running program or interpreter (GHCi). +takeCs1Arr + :: FirstChars -- ^ A pair of the first characters of the starting group delimiter (the same for all 'String's in the all 'CLSpecifications') and the probable its modification (the first character of the last delimiter). + -> CLSpecifications + -> [String] + -> Array Int Arguments +takeCs1Arr (x1,x2) = takeABCsArr (takeCs1 (x1,x2)) +{-# INLINABLE takeCs1Arr #-} + +-- | For empty list of 'String's returns empty array that has no elements. Trying to index it always returns error and can cause +-- segmentation fault in the running program or interpreter (GHCi). +takeBsArr + :: CLSpecifications + -> [String] + -> Array Int Arguments +takeBsArr = takeABCsArr takeBs +{-# INLINABLE takeBsArr #-} + +-- | For empty list of 'String's returns empty array that has no elements. Trying to index it always returns error and can cause +-- segmentation fault in the running program or interpreter (GHCi). +takeAsArr + :: CLSpecifications + -> [String] + -> Array Int Arguments +takeAsArr = takeABCsArr takeAs +{-# INLINABLE takeAsArr #-} + +--------------------------------------------------- + +-- | For empty list of 'String's returns empty array that has no elements. Trying to index it always returns error and can cause +-- segmentation fault in the running program or interpreter (GHCi). +takeABCsArrSortedBy + :: ((Arguments -> Arguments -> Ordering) -> CLSpecifications -> [String] -> Args) + -> (Arguments -> Arguments -> Ordering) -- ^ A 'compare'-like implementation for 'Arguments'. If needed you can implement your own 'Ord' instance for 'Arguments' and use it here. Here can be partial, just for 'C's. + -> CLSpecifications + -> [String] + -> Array Int Arguments +takeABCsArrSortedBy g f ts xss = listArray (0,l-1) js + where js = g f ts xss + l = length js +{-# INLINABLE takeABCsArrSortedBy #-} + +-- | For empty list of 'String's returns empty array that has no elements. Trying to index it always returns error and can cause +-- segmentation fault in the running program or interpreter (GHCi). +takeCsArrSortedBy + :: (Arguments -> Arguments -> Ordering) -- ^ A 'compare'-like implementation for 'Arguments'. If needed you can implement your own 'Ord' instance for 'Arguments' and use it here. Here can be partial, just for 'C's. + -> CLSpecifications + -> [String] + -> Array Int Arguments +takeCsArrSortedBy = takeABCsArrSortedBy (takeArgsSortedBy (\x -> notNullArguments x && isC x)) +{-# INLINABLE takeCsArrSortedBy #-} + +-- | For empty list of 'String's returns empty array that has no elements. Trying to index it always returns error and can cause +-- segmentation fault in the running program or interpreter (GHCi). +takeCs1ArrSortedBy + :: FirstChars -- ^ A pair of the first characters of the starting group delimiter (the same for all 'String's in the all 'CLSpecifications') and the probable its modification being also the first character. + -> (Arguments -> Arguments -> Ordering) -- ^ A 'compare'-like implementation for 'Arguments'. If needed you can implement your own 'Ord' instance for 'Arguments' and use it here. Here can be partial, just for 'C's. + -> CLSpecifications + -> [String] + -> Array Int Arguments +takeCs1ArrSortedBy (x1,x2) = takeABCsArrSortedBy (takeArgs1SortedBy (x1,x2) (\x -> notNullArguments x && isC x)) +{-# INLINABLE takeCs1ArrSortedBy #-} + +-- | For empty list of 'String's returns empty array that has no elements. Trying to index it always returns error and can cause +-- segmentation fault in the running program or interpreter (GHCi). +takeBsArrSortedBy + :: (Arguments -> Arguments -> Ordering) -- ^ A 'compare'-like implementation for 'Arguments'. If needed you can implement your own 'Ord' instance for 'Arguments' and use it here. Here can be partial, just for 'B's. + -> CLSpecifications + -> [String] + -> Array Int Arguments +takeBsArrSortedBy = takeABCsArrSortedBy (takeArgsSortedBy (\x -> notNullArguments x && isB x)) +{-# INLINABLE takeBsArrSortedBy #-} + +-- | For empty list of 'String's returns empty array that has no elements. Trying to index it always returns error and can cause +-- segmentation fault in the running program or interpreter (GHCi). +takeAsArrSortedBy + :: (Arguments -> Arguments -> Ordering) -- ^ A 'compare'-like implementation for 'Arguments'. If needed you can implement your own 'Ord' instance for 'Arguments' and use it here. Here can be partial, just for 'A's. + -> CLSpecifications + -> [String] + -> Array Int Arguments +takeAsArrSortedBy = takeABCsArrSortedBy (takeArgsSortedBy (\x -> notNullArguments x && isA x)) +{-# INLINABLE takeAsArrSortedBy #-} + + diff --git a/CLI/Arguments/Get.hs b/CLI/Arguments/Get.hs new file mode 100644 --- /dev/null +++ b/CLI/Arguments/Get.hs @@ -0,0 +1,83 @@ +{-# OPTIONS_HADDOCK show-extensions #-} + +-- | +-- Module : CLI.Arguments.Get +-- Copyright : (c) OleksandrZhabenko 2022 +-- License : MIT +-- Stability : Experimental +-- Maintainer : olexandr543@yahoo.com +-- +-- A library to process command line arguments in some more convenient way. + +module CLI.Arguments.Get where + +import Data.Maybe (fromJust) +import qualified Data.Foldable as F +import CLI.Arguments + +oneA + :: (F.Foldable t) => String -> t Arguments -> Bool +oneA xs ys = F.any (\(A ts) -> ts == xs) ys + +oneB + :: (F.Foldable t) => String -> t Arguments -> Bool +oneB xs ys = F.any (\(B _ zs _) -> zs == xs) ys + +oneC + :: (F.Foldable t) => String -> t Arguments -> Bool +oneC xs ys = F.any (\(C zs _) -> zs == xs) ys + +listA + :: (F.Foldable t) => [String] -> t Arguments -> Bool +listA xss ys + | null xss = False + | otherwise = F.any (\(A ts) -> ts `elem` xss) ys + +listB + :: (F.Foldable t) => [String] -> t Arguments -> Bool +listB xss ys + | null xss = False + | otherwise = F.any (\(B _ zs _) -> zs `elem` xss) ys + +listC + :: (F.Foldable t) => [String] -> t Arguments -> Bool +listC xss ys + | null xss = False + | otherwise = F.any (\(C zs _) -> zs `elem` xss) ys + +getA + :: (F.Foldable t) => String -> t Arguments -> String +getA xs ys + | oneA xs ys = (\(A ts) -> ts) . fromJust . F.find (\(A rs) -> rs == xs) $ ys + | otherwise = [] + +getB + :: (F.Foldable t) => String -> t Arguments -> [String] +getB xs ys + | oneB xs ys = (\(B _ _ yss) -> yss) . fromJust . F.find (\(B _ zs _) -> zs == xs) $ ys + | otherwise = [] + +getC + :: (F.Foldable t) => String -> t Arguments -> [String] +getC xs ys + | oneC xs ys = (\(C _ yss) -> yss) . fromJust . F.find (\(C zs _) -> zs == xs) $ ys + | otherwise = [] + +getLstA + :: (F.Foldable t) => [String] -> t Arguments -> [String] +getLstA xss ys + | listA xss ys = filter (not . null) . map (\xs -> getA xs ys) $ xss + | otherwise = [] + +getLstB + :: (F.Foldable t) => [String] -> t Arguments -> [[String]] +getLstB xss ys + | listB xss ys = filter (not . null) . map (\xs -> getB xs ys) $ xss + | otherwise = [] + +getLstC + :: (F.Foldable t) => [String] -> t Arguments -> [[String]] +getLstC xss ys + | listC xss ys = filter (not . null) . map (\xs -> getC xs ys) $ xss + | otherwise = [] + diff --git a/CLI/Arguments/Parsing.hs b/CLI/Arguments/Parsing.hs new file mode 100644 --- /dev/null +++ b/CLI/Arguments/Parsing.hs @@ -0,0 +1,197 @@ +{-# OPTIONS_HADDOCK show-extensions #-} + +-- | +-- Module : CLI.Arguments.Parsing +-- Copyright : (c) OleksandrZhabenko 2022 +-- License : MIT +-- Stability : Experimental +-- Maintainer : olexandr543@yahoo.com +-- +-- A library to process command line arguments in some more convenient way. + +module CLI.Arguments.Parsing where + +import Data.Monoid (mappend) +import Data.Maybe (fromJust) +import GHC.Arr +import Data.List (sortBy) +import qualified Data.Foldable as F +import CLI.Arguments + +args2ArgsR + :: CLSpecifications + -> (Args,[String]) + -> (Args,[String]) +args2ArgsR ((t@(xs,n)):ms) q@(ls,xss@(js:jss)) + | n < 0 = case w0ss of + [] -> args2ArgsR ms q + w00ss -> case qss of + [] -> args2ArgsR ms q + q0ss -> args2ArgsR ms (C xs q0ss:ls,kss `mappend` rss) + | n == 0 = case w0ss of + [] -> args2ArgsR ms q + w00ss -> args2ArgsR ms (A xs:ls,kss `mappend` wss) + | otherwise = case w0ss of + [] -> args2ArgsR ms q + w00ss -> if length vss == n then args2ArgsR ms (B n xs vss:ls,kss `mappend` zss) + else args2ArgsR ms q + where (kss,uss) = break (== xs) xss + (w0ss,wss) = splitAt 1 uss + (qss,pss) = break (== xs) wss + (r0ss,rss) = splitAt 1 pss + (vss,zss) = splitAt n wss +args2ArgsR _ q = q + +args2ArgsR0 + :: CLSpecifications + -> [String] + -> (Args,[String]) +args2ArgsR0 xs yss = args2ArgsR xs ([],yss) +{-# INLINABLE args2ArgsR0 #-} + +args2Args3'R + :: CLSpecifications + -> (Args,Args,Args,[String]) + -> (Args,Args,Args,[String]) +args2Args3'R (t@(xs,n):ts) q@(w1,w2,w3,xss@(js:jss)) + | n < 0 = case w0ss of + [] -> args2Args3'R ts q + w00ss -> case qss of + [] -> args2Args3'R ts q + q0ss -> args2Args3'R ts (w1,w2,C xs q0ss:w3,kss `mappend` rss) + | n == 0 = case w0ss of + [] -> args2Args3'R ts q + w00ss -> args2Args3'R ts (A xs:w1,w2,w3,kss `mappend` wss) + | otherwise = case w0ss of + [] -> args2Args3'R ts q + w00ss -> if length vss == n then args2Args3'R ts (w1,B n xs vss:w2,w3,kss `mappend` zss) + else args2Args3'R ts q + where (kss,uss) = break (== xs) xss + (w0ss,wss) = splitAt 1 uss + (qss,pss) = break (== xs) wss + (r0ss,rss) = splitAt 1 pss + (vss,zss) = splitAt n wss +args2Args3'R _ q = q + +args2Args3R + :: CLSpecifications + -> [String] + -> (Args,Args,Args,[String]) +args2Args3R xs yss = args2Args3'R xs ([],[],[],yss) +{-# INLINABLE args2Args3R #-} + +------------------------------------------------------------------------------ + +args2Args1R + :: FirstChars -- ^ A pair of the first characters of the starting group delimiter (the same for all 'String's in the all 'CLSpecifications') and the probable its modification (the first character of the last delimiter). + -> CLSpecifications + -> (Args,[String]) + -> (Args,[String]) +args2Args1R (x1,x2) (t@(xs@(k:ks),n):ts) q@(ls,xss@(js:jss)) + | n < 0 = case w0ss of + [] -> args2Args1R (x1,x2) ts q + w00ss -> case qss of + [] -> args2Args1R (x1,x2) ts q + q0ss -> args2Args1R (x1,x2) ts (C xs qss:ls,kss `mappend` rss) + | n == 0 = case w0ss of + [] -> args2Args1R (x1,x2) ts q + w00ss -> args2Args1R (x1,x2) ts (A xs:ls,kss `mappend` wss) + | otherwise = case w0ss of + [] -> args2Args1R (x1,x2) ts q + w00ss -> if length vss == n then args2Args1R (x1,x2) ts (B n xs vss:ls,kss `mappend` zss) + else args2Args1R (x1,x2) ts q + where (kss,uss) = break (== xs) xss + (w0ss,wss) = splitAt 1 uss + (qss,pss) = break (\rs -> rs == xs || (k == x1 && rs == (x2:ks))) wss + (r0ss,rss) = splitAt 1 pss + (vss,zss) = splitAt n wss +args2Args1R (x1,x2) (t@([],n):ts) q = args2Args1R (x1,x2) ts q +args2Args1R _ _ q = q + +args2Args3'1R + :: FirstChars -- ^ A pair of the first characters of the starting group delimiter (the same for all 'String's in the all 'CLSpecifications') and the probable its modification (the first character of the last delimiter). + -> CLSpecifications + -> (Args,Args,Args,[String]) + -> (Args,Args,Args,[String]) +args2Args3'1R (x1,x2) (t@(xs@(k:ks),n):ts) q@(w1,w2,w3,xss@(js:jss)) + | n < 0 = case w0ss of + [] -> args2Args3'1R (x1,x2) ts q + w00ss -> case qss of + [] -> args2Args3'1R (x1,x2) ts q + q0ss -> args2Args3'1R (x1,x2) ts (w1,w2,C xs q0ss:w3,kss `mappend` rss) + | n == 0 = case w0ss of + [] -> args2Args3'1R (x1,x2) ts q + w00ss -> args2Args3'1R (x1,x2) ts (A xs:w1,w2,w3,kss `mappend` wss) + | otherwise = case w0ss of + [] -> args2Args3'1R (x1,x2) ts q + w00ss -> if length vss == n then args2Args3'1R (x1,x2) ts (w1,B n xs vss:w2,w3,kss `mappend` zss) + else args2Args3'1R (x1,x2) ts q + where (kss,uss) = break (== xs) xss + (w0ss,wss) = splitAt 1 uss + (qss,pss) = break (\rs -> rs == xs || (k == x1 && rs == (x2:ks))) wss + (r0ss,rss) = splitAt 1 pss + (vss,zss) = splitAt n wss +args2Args3'1R (x1,x2) _ q = q + +args2Args31R + :: FirstChars -- ^ A pair of the first characters of the starting group delimiter (the same for all 'String's in the all 'CLSpecifications') and the probable its modification (the first character of the last delimiter). + -> CLSpecifications + -> [String] + -> (Args,Args,Args,[String]) +args2Args31R (x1,x2) xs yss = args2Args3'1R (x1,x2) xs ([],[],[],yss) +{-# INLINABLE args2Args31R #-} + +---------------------------------------------------------------------- + +-- | This function can actually parse the command line arguments being the ['String']. +args2ArgsFilteredGR + :: (Arguments -> Bool) -- ^ A predicate to check which 'Arguments' must be kept in the result. + -> CLSpecifications + -> (Args,[String]) + -> (Args,[String]) +args2ArgsFilteredGR f ts r = (filter f . map b1Args2AArgs $ qs, yss) + where (qs,yss) = args2ArgsR ts r +{-# INLINABLE args2ArgsFilteredGR #-} + +-- | This function can actually parse the command line arguments being the ['String']. +args2ArgsFilteredG1R + :: FirstChars -- ^ A pair of the first characters of the starting group delimiter (the same for all 'String's in the all 'CLSpecifications') and the probable its modification (the first character of the last delimiter). + -> (Arguments -> Bool) -- ^ A predicate to check which 'Arguments' must be kept in the result. + -> CLSpecifications + -> (Args,[String]) + -> (Args,[String]) +args2ArgsFilteredG1R (x1,x2) f ts r = (filter f . map b1Args2AArgs $ qs, yss) + where (qs,yss) = args2Args1R (x1,x2) ts r +{-# INLINABLE args2ArgsFilteredG1R #-} + +---------------------------------------------------------------------- + +takeCsR + :: CLSpecifications + -> [String] + -> (Args,[String]) +takeCsR xs yss = args2ArgsFilteredGR (\x -> notNullArguments x && isC x) xs ([],yss) +{-# INLINABLE takeCsR #-} + +takeCs1R + :: FirstChars -- ^ A pair of the first characters of the starting group delimiter (the same for all 'String's in the all 'CLSpecifications') and the probable its modification (the first character of the last delimiter). + -> CLSpecifications + -> [String] + -> (Args,[String]) +takeCs1R (x1,x2) xs yss = args2ArgsFilteredG1R (x1,x2) (\x -> notNullArguments x && isC x) xs ([],yss) +{-# INLINABLE takeCs1R #-} + +takeBsR + :: CLSpecifications + -> [String] + -> (Args,[String]) +takeBsR xs yss = args2ArgsFilteredGR (\x -> notNullArguments x && isB x) xs ([],yss) +{-# INLINABLE takeBsR #-} + +takeAsR + :: CLSpecifications + -> [String] + -> (Args,[String]) +takeAsR xs yss = args2ArgsFilteredGR (\x -> notNullArguments x && isA x) xs ([],yss) +{-# INLINABLE takeAsR #-} + diff --git a/cli-arguments.cabal b/cli-arguments.cabal --- a/cli-arguments.cabal +++ b/cli-arguments.cabal @@ -4,7 +4,7 @@ -- http://haskell.org/cabal/users-guide/ name: cli-arguments -version: 0.4.0.0 +version: 0.5.0.0 synopsis: A library to process command line arguments in some more convenient way. description: Uses three types of the command line arguments and order of their parsing. Usually firstly the framed by some string delimiter (the different ones) are parsed, then the groups of arguments and then the rest single-field arguments. All these groups must be not nested one into the others. -- bug-reports: @@ -18,7 +18,7 @@ extra-source-files: CHANGELOG.md library - exposed-modules: CLI.Arguments + exposed-modules: CLI.Arguments, CLI.Arguments.Parsing, CLI.Arguments.Arr, CLI.Arguments.Get -- other-modules: -- other-extensions: build-depends: base >=4.8 && <5