
On Mon, Oct 11, 2010 at 1:12 PM, Malcolm Wallace
I have myself in the past implemented a Text-like library as a replacement for the standard list-of-char representation. (Before you ask, it is not publically releasable.) The basic decision I took there was that the Char type does not exist - the only thing available is Text. Another way of saying this, is that Char is simply the subset of all the Texts of size 1. I am not suggesting that the Prelude or ByteString should take this view, but if you proceed to look at the type signatures of the Data.Text package on the basis that Char/Text are the "same" thing, then it may become clearer how to resolve the apparent name/type clashes below.
Executive summary: most of the names/signatures turn out to be equivalent, with only a couple highlighted as significantly odd or worth changing.
import Prelude hiding (Char) type Char = Text -- At least we can pretend for a while.
text base bytestring type in text (or equivalent if absent)
--------------------------------------------------------------------------- break - breakSubstring Text -> Text -> (Text, Text) breakBy break break (Char -> Bool) -> Text -> (Text, Text)
break break break (Text -> Bool) -> Text -> (Text, Text)
The breakSubstring functionality is semantically: breakSubstring x = break (==x) although there may be a more efficient implementation. Proposal: rename Text.break to Text.breakSubstring, and Text.breakBy to Text.break.
breakEnd - - Text -> Text -> (Text, Text) - - breakEnd (Char -> Bool) -> Text -> (Text, Text)
breakEnd - breakEnd (Text -> Bool) -> Text -> (Text, Text)
Proposal: slightly generalise the type of Text.breakEnd.
count - - Text -> Text -> Int - - count Char -> Text -> Int
count - count Text -> Text -> Int
Proposal: these are equivalent, no action.
find - - Text -> Text -> [(Text, Text)]
I'm afraid that, from the signature alone, I cannot guess what this function does.
findBy find find (Char -> Bool) -> Text -> Maybe Char
find find find (Text -> Bool) -> Text -> Maybe Text
Proposal: rename Text.findBy to Text.find.
partitionBy partition - (Char -> Bool) -> Text -> (Text, Text)
partition partition - (Text -> Bool) -> Text -> (Text, Text)
Proposal: these are equivalent, no action.
replicate - - Int -> Text -> Text - replicate replicate Int -> Char -> Text
replicate replicate replicate Int -> Text -> Text
Proposal: these are equivalent, no action.
spanBy span span (Char -> Bool) -> Text -> (Text, Text)
span span span (Text -> Bool) -> Text -> (Text, Text)
Proposal: rename Text.spanBy to Text.span.
split - - Text -> Text -> [Text] - - split Char -> Text -> [Text]
split - split Text -> Text -> [Text]
Proposal: these are equivalent, no action,
splitBy - splitWith (Char -> Bool) -> Text -> [Text]
splitWith - splitWith (Text -> Bool) -> Text -> [Text]
Proposal: these are equivalent, no action.
unfoldrN - - Int -> (a -> Maybe (Char, a)) -> a -> Text - - unfoldrN Int -> (a -> Maybe (Char, a)) -> a -> (Text, Maybe a)
unfoldrN - unfoldrN Int -> (a -> Maybe (Text, a)) -> a -> (Text, Maybe a)
Proposal: slightly generalise the return type of Text.unfoldrN.
zipWith zipWith - (Char -> Char -> Char) -> Text -> Text -> Text - zipWith zipWith (Char -> Char -> a) -> Text -> Text -> [a]
zipWith zipWith zipWith (Text -> Text -> Text) -> Text -> Text -> Text
Proposal: This is just a specialised version of the standard zipWith. No action.
The only extra function required is to lift the ordinary Char type to become a Text:
Proposal: add char :: Prelude.Char -> Text if it does not already exist.
I hope this is a useful contribution, if only to spark other ideas for how to resolve the impasse.
Regards, Malcolm _______________________________________________ Libraries mailing list Libraries@haskell.org http://www.haskell.org/mailman/listinfo/libraries
I've found that the "split" library (by Brent Yorgey) offers a very nice API for selecting between all of the different types of splitting that may be necessary. Could that API perhaps be adapted for use with ByteString and Text, giving a unified splitting interface for all of the sequences in the Haskell Platform? Alex