These are singleton variants of the commonly used classes from base, hashable, and aeson. These variants work on higher-kinded types instead of on ground types. For example, if you wrote the following:

data MyType = MyInt | MyBool | MyChar
$(genSingletons [''MyType])
type family Interpret m where
  Interpret 'MyInt  = Int
  Interpret 'MyChar = Char
  Interpret 'MyBool = Bool
newtype MyValue x = MyValue { getMyValue :: Interpret x }

You could then write MyValue instances for all of the classes that in this module that end in Sing1. For example:

instance EqSing1 MyValue where
  eqSing1 x a b = case x of
    SMyInt  -> a == b
    SMyChar -> a == b
    SMyBool -> a == b

For our example MyValue type, the EqSing1 instance is trivial. We simply pattern match on the singleton and then do the same thing in each case. This kind of pattern matching ends up happening any time our universe interpreter maps to types that all have Eq instances. Since writing this out is tedious, we can instead use a template haskell function provided in the Data.Case.Enumerate module:

instance EqSing1 MyValue where
  eqSing1 x a b $(enumerateConstructors 'x ''MyValue =<< [|a == b|])

Instances for the other classes here can be written similarly.

These are kind classes. They express that something is true for all singletons of a particular kind. Note that these are different from the kind classes provided in the singletons library itself. The methods in those classes (SOrd,SEnum,etc.) work entirely on singletons. Here, the methods also work with normal data types.

Notice that classes like EqKind and OrdKind have been omitted from this library. The reason is that that functions that would be provided by these can be trivially recovered by demoting the results of methods in SEq and SOrd.

These methods in these classes all have defaults that involve demoting the singleton and using the corresponding method from the normal typeclass.

These are additional classes used to provide instances for Applied1. If you have a defunctionalized typeclass that provides produces types in the category hask, you can use this. Instances will often look like this:

data Thing = ...
type family ToType (x :: Thing) :: Type where ...
instance EqApplied1 ToTypeSym0 where
  eqApplied1 _ x (Applied a) (Applied b) = $(enumerateConstructors 'x ''Thing =<< [|a == b|])