instance Show Show is imprecise.

[phadej]

In singletons-3.0.4

infixr 4 :&:

      => Show (SSigma sig) where
  showsPrec p ((sa :: Sing ('WrapSing (sfst :: Sing fst))) :%&: (sb :: Sing snd)) =
    showParen (p >= 5) $
      showsPrec 5 sa . showString " :&: " . showsPrec 5 sb

Technically this is not wrong, but it's a bit imprecise. :&: is right associative, butShow` instance doesn't use it.

Compare to e.g. Show (NP f xs) from sop-core, where :* is also right associative so it's easy to compare:

infixr 5 :*

instance All (Show `Compose` f) xs => Show (NP f xs) where
  showsPrec _ Nil       = showString "Nil"
  showsPrec d (f :* fs) = showParen (d > 5)
    $ showsPrec (5 + 1) f
    . showString " :* "
    . showsPrec 5 fs

Given the above, I'd rewrite

  showsPrec p ((sa :: Sing ('WrapSing (sfst :: Sing fst))) :%&: (sb :: Sing snd)) =
    showParen (p > 4) $
      showsPrec 5 sa . showString " :&: " . showsPrec 4 sb

I.e. use p > 4 to highlight that it's the 4 as in infixr 4 :&:, and change to showsPrec 4 sb: we don't need to bump precendence level for right argument.

IF there is a reason to prefer "more parentheses" i.e. current version, then it probably should be written in the code as comment.

[RyanGlScott]

Sigma's Show instance is intentionally written to mirror what would happen if you derived a Show instance for a data constructor declared as infixr. For instance, if you write the following:

infixr 4 :&:
data Pair s t = s :&: t deriving Show

Then GHC will derive the following Show instance:

==================== Derived instances ====================
Derived class instances:
  instance (GHC.Show.Show s, GHC.Show.Show t) =>
           GHC.Show.Show (Ghci4.Pair s t) where
    GHC.Show.showsPrec a_a199 ((Ghci4.:&:) b1_a19a b2_a19b)
      = GHC.Show.showParen
          (a_a199 GHC.Classes.>= 5)
          ((GHC.Base..)
             (GHC.Show.showsPrec 5 b1_a19a)
             ((GHC.Base..)
                (GHC.Show.showString " :&: ") (GHC.Show.showsPrec 5 b2_a19b)))

This uses the same precedence-related conventions as the Show instance for Sigma. (For technical reasons, Sigma's Show instance has to be hand-written, but it is otherwise the same.) Personally, I'd rather stick to the conventions that deriving Show uses here. I'd be happy to add a comment to the code which explains this reasoning.

There is a separate question of whether deriving Show should work this way or not, but that is a GHC question rather than a singletons one.

[phadej]

I'd be happy to add a comment to the code which explains this reasoning.

Please do.

should work this way or not,

FWIW, the way deriving Show works that way is why I do write Show instances for types with right associative infix constructors. (Left associative are tricky, as naive Read instances won't be able to read them - I think that part is actually documented).

[RyanGlScott]

Re-reading https://gitlab.haskell.org/ghc/ghc/-/issues/14860#note_454218 made me realize that we can do even better: we actually can derive these Show instances when using GHC 9.2 or later. I've done this in #634.