content: {-# LANGUAGE FlexibleInstances #-}
  {-# LANGUAGE GeneralizedNewtypeDeriving #-}
  {-# LANGUAGE NoImplicitPrelude #-}
  {-# LANGUAGE PolyKinds #-}
  {-# LANGUAGE StandaloneDeriving #-}
  {-# LANGUAGE Trustworthy #-}
  {-# LANGUAGE TypeFamilies #-}
  {-# LANGUAGE TypeOperators #-}
  
  -----------------------------------------------------------------------------
  -- |
  -- Module      :  GHC.Internal.Data.String
  -- Copyright   :  (c) The University of Glasgow 2007
  -- License     :  BSD-style (see the file libraries/base/LICENSE)
  --
  -- Maintainer  :  libraries@haskell.org
  -- Stability   :  stable
  -- Portability :  portable
  --
  -- The @String@ type and associated operations.
  --
  -----------------------------------------------------------------------------
  
  module GHC.Internal.Data.String (
     String
   , IsString(..)
  
   -- * Functions on strings
   , lines
   , words
   , unlines
   , unwords
   ) where
  
  import GHC.Internal.Base
  import GHC.Internal.Data.Functor.Const (Const (Const))
  import GHC.Internal.Data.Functor.Identity (Identity (Identity))
  import GHC.Internal.Data.List (lines, words, unlines, unwords)
  
  -- | `IsString` is used in combination with the @-XOverloadedStrings@
  -- language extension to convert the literals to different string types.
  --
  -- For example, if you use the [text](https://hackage.haskell.org/package/text) package,
  -- you can say
  --
  -- @
  -- {-# LANGUAGE OverloadedStrings  #-}
  --
  -- myText = "hello world" :: Text
  -- @
  --
  -- Internally, the extension will convert this to the equivalent of
  --
  -- @
  -- myText = fromString @Text ("hello world" :: String)
  -- @
  --
  -- __Note:__ You can use @fromString@ in normal code as well,
  -- but the usual performance/memory efficiency problems with 'String' apply.
  class IsString a where
      fromString :: String -> a
  
  {- Note [IsString String]
  ~~~~~~~~~~~~~~~~~~~~~~~~~
  Previously, the IsString instance that covered String was a flexible
  instance for [Char]. This is in some sense the most accurate choice,
  but there are cases where it can lead to an ambiguity, for instance:
  
    show $ "foo" ++ "bar"
  
  The use of (++) ensures that "foo" and "bar" must have type [t] for
  some t, but a flexible instance for [Char] will _only_ match if
  something further determines t to be Char, and nothing in the above
  example actually does.
  
  So, the above example generates an error about the ambiguity of t,
  and what's worse, the above behavior can be generated by simply
  typing:
  
     "foo" ++ "bar"
  
  into GHCi with the OverloadedStrings extension enabled.
  
  The new instance fixes this by defining an instance that matches all
  [a], and forces a to be Char. This instance, of course, overlaps
  with things that the [Char] flexible instance doesn't, but this was
  judged to be an acceptable cost, for the gain of providing a less
  confusing experience for people experimenting with overloaded strings.
  
  It may be possible to fix this via (extended) defaulting. Currently,
  the rules are not able to default t to Char in the above example. If
  a more flexible system that enabled this defaulting were put in place,
  then it would probably make sense to revert to the flexible [Char]
  instance, since extended defaulting is enabled in GHCi. However, it
  is not clear at the time of this note exactly what such a system
  would be, and it certainly hasn't been implemented.
  
  A test case (should_run/overloadedstringsrun01.hs) has been added to
  ensure the good behavior of the above example remains in the future.
  -}
  
  -- | @(a ~ Char)@ context was introduced in @4.9.0.0@
  --
  -- @since base-2.01
  instance (a ~ Char) => IsString [a] where
           -- See Note [IsString String]
      fromString xs = xs
  
  -- | @since base-4.9.0.0
  deriving instance IsString a => IsString (Const a (b :: k))
  
  -- | @since base-4.9.0.0
  deriving instance IsString a => IsString (Identity a)
  