11 Oct
2010
11 Oct
'10
8:12 p.m.
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