Unable to traverse with `types` if `Text` is present

[ShrykeWindgrace]

Hi, I was toying around with types traversal and observed a change of behaviour when I start using Text in my records.

Consider this MWE (imports in cabal : text, lens, generic-lens, generic-deriving, with lts-12.20 and ghc-8.4.4):

{-# LANGUAGE DataKinds         #-}
{-# LANGUAGE DeriveGeneric     #-}
{-# LANGUAGE FlexibleContexts  #-}
{-# LANGUAGE OverloadedStrings #-}
{-# LANGUAGE TypeApplications  #-}
module Main (main) where
import           Control.Lens.Fold
import           Data.Generics.Product.Types
import           Data.Text
import           GHC.Generics

newtype Name = Name Text deriving (Eq, Show, Generic)

data Description = N None | S Sirname | M Multiple deriving (Eq, Show, Generic)

data None = None deriving (Eq, Show, Generic)

data Sirname = Sirname {
    honorific :: Text,
    name      :: Name
} deriving (Eq, Show, Generic)

data Multiple = Multiple {
    descr  :: Text,
    titles :: [(Text, [Description])]
} deriving (Eq, Show, Generic )


main :: IO ()
main = 
    print $ toListOf (types @Name) person



person :: Description
person = M $ Multiple "" [
    ( "born", [N None] ),
    ( "created", [S $ Sirname "sir" (Name "John") ] ),
    ( "created", [S $ Sirname "duke of" (Name "Duchy") ] )
    ]

The compilation fails with

    • No instance for (Data.Generics.Product.Types.HasTypes'
                         (Data.Generics.Product.Types.Snd
                            (Data.Generics.Product.Types.InterestingOr
                               (Data.Generics.Product.Types.InterestingOr
                                  (Data.Generics.Product.Types.Interesting'
                                     (Rep Text) Name '[Text, Sirname, None, Description])
                                  (M1
                                     S
                                     ('MetaSel
                                        ('Just "name")
                                        'NoSourceUnpackedness
                                        'NoSourceStrictness
                                        'DecidedLazy)
                                     (Rec0 Name))
                                  Name)
                               (M1
                                  C
                                  ('MetaCons "M" 'PrefixI 'False)
                                  (S1
                                     ('MetaSel
                                        'Nothing
                                        'NoSourceUnpackedness
                                        'NoSourceStrictness
                                        'DecidedLazy)
                                     (Rec0 Multiple)))
                               Name))
                         Description
                         Name)
        arising from a use of ‘types’
    • In the first argument of ‘toListOf’, namely ‘(types @Name)’
      In the second argument of ‘($)’, namely
        ‘toListOf (types @Name) person’
      In the expression: print $ toListOf (types @Name) person

However, if I replace all mentions of Text by String, the compilation goes well and the output is correct.

How do I circumvent this problem?

[kcsongor]

Oh drat.

The issue is that for the traversal to be able to see inside the values, every value needs to have an instance of Generic. Primitive types, such as Int, don't have these instances, so the implementation treats them specially. Text is also a primitive, but at the moment, it's not handled specially, so types with Text in them won't work.

For now, the only solution I see is to add a dependency on text in generic-lens, and add the special case in the library. (As happened with Word32 in #63)

[phadej]

@kcsongor text is bundled with newer GHC (8.4+) so as a dep, it's not a problem. Remember to add both strict and lazy variants!

[kcsongor]

@phadej that's great news, I wasn't aware!

[klapaucius]

For now, the only solution I see is to add a dependency on text

generic-lens -> profunctors -> semigroups -> text

[klapaucius]

btw does this approach scales at all? what about bytestrings, vectors, filepaths, timestamps etc. ?

[Lysxia]

Indeed the current implementation doesn't scale. We could parameterize it by the set of uninteresting types (as currently defined by the Interesting' type family), so that users can extend it with primitive types from other places.

[kcsongor]

That sounds like a plausible solution, my only concern is how the ergonomics would be affected for cases where the current system works fine. Maybe we could have some defaulting behaviour in that case, or have an entirely new traversal that is parameterised, and leave the current one as it is.

Another solution would be to introduce

newtype Stop a = Stop a

and all values wrapped in Stop would be ignored. The problem with this is that it would require changing the data definitions so that they work with generic-lens, which sounds like a bad idea.

Or, perhaps Interesting could be implemented as a type class instead of a type family, which would allow mixing the overlapping behaviour with the openness, so ad-hoc "uninteresting" cases could be added. I haven't thought about this too much, so not sure if it would work.

[kcsongor]

This is fixed by #74