Data.Monoid.Textual

Methods

• fromText :: Text -> t

  Contructs a new data type instance Like fromString, but from a Text input instead of String.

  fromText == fromString . Text.unpack

• singleton :: Char -> t

  Creates a prime monoid containing a single character.

  singleton c == fromString [c]

• splitCharacterPrefix :: t -> Maybe (Char, t)

  Specialized version of splitPrimePrefix. Every prime factor of a textual monoid must consist of a single character or no character at all.

• characterPrefix :: t -> Maybe Char

  Extracts a single character that prefixes the monoid, if the monoid begins with a character. Otherwise returns Nothing.

  characterPrefix == fmap fst . splitCharacterPrefix

• map :: (Char -> Char) -> t -> t

  Equivalent to map from Data.List with a Char -> Char function. Preserves all non-character data.

  map f == concatMap (singleton . f)

• concatMap :: (Char -> t) -> t -> t

  Equivalent to concatMap from Data.List with a Char -> String function. Preserves all non-character data.

• toString :: (t -> String) -> t -> String

  Returns the list of characters the monoid contains, once the argument function converts all its non-character factors into characters.

• toText :: (t -> Text) -> t -> Text

  Converts the monoid into Text, given a function to convert the non-character factors into chunks of Text.

• any :: (Char -> Bool) -> t -> Bool

  Equivalent to any from Data.List. Ignores all non-character data.

• all :: (Char -> Bool) -> t -> Bool

  Equivalent to all from Data.List. Ignores all non-character data.

• foldl :: (a -> t -> a) -> (a -> Char -> a) -> a -> t -> a

  The first argument folds over the non-character prime factors, the second over characters. Otherwise equivalent to foldl from Data.List.

• foldl' :: (a -> t -> a) -> (a -> Char -> a) -> a -> t -> a

  Strict version of foldl.

• foldr :: (t -> a -> a) -> (Char -> a -> a) -> a -> t -> a

  The first argument folds over the non-character prime factors, the second over characters. Otherwise equivalent to 'List.foldl'' from Data.List.

• scanl :: (Char -> Char -> Char) -> Char -> t -> t

  Equivalent to scanl from Data.List when applied to a String, but preserves all non-character data.

• scanl1 :: (Char -> Char -> Char) -> t -> t

  Equivalent to scanl1 from Data.List when applied to a String, but preserves all non-character data.

  scanl f c == scanl1 f . (singleton c <>)

• scanr :: (Char -> Char -> Char) -> Char -> t -> t

  Equivalent to scanr from Data.List when applied to a String, but preserves all non-character data.

• scanr1 :: (Char -> Char -> Char) -> t -> t

  Equivalent to scanr1 from Data.List when applied to a String, but preserves all non-character data.

  scanr f c == scanr1 f . (<> singleton c)

• mapAccumL :: (a -> Char -> (a, Char)) -> a -> t -> (a, t)

  Equivalent to mapAccumL from Data.List when applied to a String, but preserves all non-character data.

• mapAccumR :: (a -> Char -> (a, Char)) -> a -> t -> (a, t)

  Equivalent to mapAccumR from Data.List when applied to a String, but preserves all non-character data.

• takeWhile :: (t -> Bool) -> (Char -> Bool) -> t -> t

  The first predicate tests the non-character data, the second one the characters. Otherwise equivalent to takeWhile from Data.List when applied to a String.

• dropWhile :: (t -> Bool) -> (Char -> Bool) -> t -> t

  The first predicate tests the non-character data, the second one the characters. Otherwise equivalent to dropWhile from Data.List when applied to a String.

• break :: (t -> Bool) -> (Char -> Bool) -> t -> (t, t)

  'break pt pc' is equivalent to span (not . pt) (not . pc).

• span :: (t -> Bool) -> (Char -> Bool) -> t -> (t, t)

  'span pt pc t' is equivalent to (takeWhile pt pc t, dropWhile pt pc t).

• spanMaybe :: s -> (s -> t -> Maybe s) -> (s -> Char -> Maybe s) -> t -> (t, t, s)

  A stateful variant of span, threading the result of the test function as long as it returns Just.

• spanMaybe' :: s -> (s -> t -> Maybe s) -> (s -> Char -> Maybe s) -> t -> (t, t, s)

  Strict version of spanMaybe.

• split :: (Char -> Bool) -> t -> [t]

  Splits the monoid into components delimited by character separators satisfying the given predicate. The characters satisfying the predicate are not a part of the result.

  split p == Factorial.split (maybe False p . characterPrefix)

• find :: (Char -> Bool) -> t -> Maybe Char

  Like find from Data.List when applied to a String. Ignores non-character data.

• elem :: Char -> t -> Bool

  Like elem from Data.List when applied to a String. Ignores non-character data.

• foldl_ :: (a -> Char -> a) -> a -> t -> a

  foldl_ = foldl const

• foldl_' :: (a -> Char -> a) -> a -> t -> a
• foldr_ :: (Char -> a -> a) -> a -> t -> a
• takeWhile_ :: Bool -> (Char -> Bool) -> t -> t

  takeWhile_ = takeWhile . const

• dropWhile_ :: Bool -> (Char -> Bool) -> t -> t

  dropWhile_ = dropWhile . const

• break_ :: Bool -> (Char -> Bool) -> t -> (t, t)

  break_ = break . const

• span_ :: Bool -> (Char -> Bool) -> t -> (t, t)

  span_ = span . const

• spanMaybe_ :: s -> (s -> Char -> Maybe s) -> t -> (t, t, s)

  spanMaybe_ s = spanMaybe s (const . Just)

• spanMaybe_' :: s -> (s -> Char -> Maybe s) -> t -> (t, t, s)