simonpj at microsoft.com
Tue Oct 4 10:24:20 CEST 2011
I like both George's proposals.
| -----Original Message-----
| From: glasgow-haskell-users-bounces at haskell.org [mailto:glasgow-haskell-users-
| bounces at haskell.org] On Behalf Of George Giorgidze
| Sent: 30 September 2011 18:28
| To: glasgow-haskell-users at haskell.org
| Subject: Two Proposals
| GHC Users,
| I would like to make to the following two proposals:
| * Eliminate the default grouping close from SQL-like comprehensions
| * Introduce a GHC extension for list literal overloading
| OK, let me start with the first proposal.
| Currently, the SQL-like comprehension notation (both in its list comprehension and
| monad comprehension variants) features the following five clauses:
| then f
| then f by e
| then group by e
| then group using f
| then group by e using f
| The first two clauses are used for specifying transformations of type [a] -> [a] (or
| Monad m => m a-> m a for monad comprehensions). The following three clauses are used
| for specifying transformations of type [a] -> [[a]] (or Monad m, Functor f => m a ->
| m (f a) for monad comprehensions). See  for further details.
| Note that the third clause does not mention which function is used for grouping. In
| this case GHC.Exts.groupWith function is used as a default for list comprehensions
| and the mgroupWith function from the MonadGroup class is used as a default for monad
| I would like to suggest to remove the third clause for the following reasons:
| * Currently the syntax is asymmetrical. Note that there is the default case for the
| 'then group' clause and not for the 'then' clause.
| * In the current notation it is not clear which grouping function is used in the
| default case
| * For many monads including lists it is not clear which function should be selected
| as a default (e.g., the groupWith function also does sorting and it is not clear to
| me why this should be the default)
| * Gets rid of the MonadGroup class. Currently the sole purpose of this class is to
| introduce a default grouping function for monad comprehensions.
| * Explicit mention of the grouping function would make monad/list comprehensions
| much easier to read by making it immediately apparent which function is used for
| My second proposal is to introduce the OverloadedLists extension that overloads list
| literals. See Section 5.2 in  for details.
| Basically the idea is to treat list literals like:
| fromList [1,2,3]
| class IsList l where
| type Item l
| fromList :: [Item l] -> l
| In the following I give useful instances of the IsList class.
| instance IsList [a] where
| type Item [a] = a
| fromList = id
| instance (Ord a) => IsList (Set a) where
| type Item (Set a) = a
| fromList = Set.fromList
| instance (Ord k) => IsList (Map k v) where
| type Item (Map k v) = (k,v)
| fromList = Map.fromList
| instance IsList (IntMap v) where
| type Item (IntMap v) = (Int,v)
| fromList = IntMap.fromList
| instance IsList Text where
| type Item Text = Char
| fromList = Text.pack
| As you can see the extension would allow list literals to be used for sets, maps and
| integer maps. In addition the suggested OverloadedLists extension would subsume
| OverloadedStrings extension (see the instance for Text, for example). Having said
| that, for now, I am not suggesting to remove the OverloadedStrings extension as it
| appears to be widely used.
| This extension could also be used for giving data-parallel array literals instead of
| the special syntax used currently.
| Unless there is a vocal opposition to the aforementioned two proposals, I would like
| to implement them in GHC. Both changes appear to be straightforward to implement.
| Thanks in advance for your feedback.
| Cheers, George
|  http://www-db.informatik.uni-tuebingen.de/files/giorgidze/haskell2011.pdf
| Glasgow-haskell-users mailing list
| Glasgow-haskell-users at haskell.org
More information about the Glasgow-haskell-users