[GHC] #13028: Compile-time validation of literals in IsString instances

[GHC]

#13028: Compile-time validation of literals in IsString instances
-------------------------------------+-------------------------------------
           Reporter:  jml            |             Owner:
               Type:  feature        |            Status:  new
  request                            |
           Priority:  normal         |         Milestone:
          Component:  Compiler       |           Version:  8.0.1
           Keywords:                 |  Operating System:  Unknown/Multiple
       Architecture:                 |   Type of failure:  None/Unknown
  Unknown/Multiple                   |
          Test Case:                 |        Blocked By:
           Blocking:                 |   Related Tickets:
Differential Rev(s):                 |         Wiki Page:
-------------------------------------+-------------------------------------
 I would like to be able to make `IsString` instances using the
 `OverloadedStrings` extension such that my instance rejects some literals
 as being invalid and such that that rejection happens at compile time, so
 that programming mistakes don't make it into the code I give to my users.

 I have a couple of use cases where I have a `Name` type that only admits
 certain strings. e.g.

 {{{#!hs
 module Name (Name(getName), makeName) where

 import Data.Text (Text)
 import qualified Data.Text as Text

 -- | A guaranteed non-empty name.
 newtype Name = Name { getName :: Text } deriving (Eq, Show, Ord)

 makeName :: Text -> Maybe Name
 makeName name
   | Text.null name = Nothing
   | otherwise = Just name
 }}}

 In a real use case, I'd check for valid characters, not starting with a
 digit, that sort of thing.

 The idea is that we don't export the `Name` constructor, which means
 anyone using a `Name` value can trust that it has certain properties (in
 this case, non-empty).

 My problem is that I'd like to use literal names in many places. e.g.

 {{{#!hs
 programName :: Name
 programName = fromJust $ makeName "the-great-and-powerful-turtle"
 }}}

 Because I do this a lot, I've defined an `unsafeMakeName` helper that does
 pretty much the same thing:

 {{{#!hs
 unsafeMakeName :: Text -> Name
 unsafeMakeName name = fromMaybe (error $ "Invalid name: " <> Text.unpack
 name) (makeName name)
 }}}

 The problem with this approach is that even though the cause of the
 mistake is a programming error, I don't find out about it until run time.

 What I'd like to do is write an `IsString` instance for `Name` which does
 that validation, e.g.

 {{{#!hs
 instance IsString Name where
   fromString = unsafeMakeName . Text.pack
 }}}

 ... but to get the error about invalid names in literals at compile-time.
 This doesn't seem logically impossible to me, since the compiler could
 know the values of literals with certainty.

--
Ticket URL: <http://ghc.haskell.org/trac/ghc/ticket/13028>
GHC <http://www.haskell.org/ghc/>
The Glasgow Haskell Compiler