IsSubAPI constraint

[fizruk]

I am using this currently to tag sub APIs in servant-swagger, but I believe this belongs in servant:

-- | Check whether @sub@ is a sub API of @api@.
type family IsSubAPI sub api :: Constraint where
  IsSubAPI sub api = AllIsElem (EndpointsList sub) api

-- | Check that every element of @xs@ is an endpoint of @api@.
type family AllIsElem xs api :: Constraint where
  AllIsElem '[] api = ()
  AllIsElem (x ': xs) api = (IsElem x api, AllIsElem xs api)

-- | Apply @(e :>)@ to every API in @xs@.
type family MapSub e xs where
  MapSub e '[] = '[]
  MapSub e (x ': xs) = (e :> x) ': MapSub e xs

-- | Append two type-level lists.
type family AppendList xs ys where
  AppendList '[]       ys = ys
  AppendList (x ': xs) ys = x ': AppendList xs ys

-- | Build a list of endpoints from an API.
type family EndpointsList api where
  EndpointsList (a :<|> b) = AppendList (EndpointsList a) (EndpointsList b)
  EndpointsList (e :> a)   = MapSub e (EndpointsList a)
  EndpointsList a = '[a]

I am not sure where to put it though.

[fizruk]

I guess IsIn from servant-docs would be more appropriate here than IsElem though.

[jkarni]

I'm very much in favour of organizing and adding to the type-level functionality bits!

There's a lot of related stuff in Servant.Utils.Links, though as you've pointed out also elsewhere (e.g. servant-docs). Maybe we should have a Servant.Utils.TypeUtils in servant, and move everything in there?

While we're at it, we can maybe generalize some of these functions.

type family Map e xs where
  Map e '[] = '[]
  Map e (x ': xs) = (e x) ': Map e xs

type family All (pred :: k -> Constraint) (ls :: '[k]) :: Constraint where
  All pred '[] = ()
  All pred (x ': xs) = (pred x, All pred xs)

type family Const a b = b

Then MapSub e xs == Map (e :>) xs, and AllIsElem xs api == All Const (Map (Flip (IsElem api))) (there might be partial application issues lurking though).

[alpmestan]

I'm all for putting together a little group of type families that are of interest to people using servant in non trivial ways, including for use in core servant packages.

But please folks, let's not pretend those things are "miscellaneous" -- I suggest we move the links machinery + those things in modules with proper names, without "Utils". I remember seeing a lot of people being thrilled to find out servant supports type-safe links... several weeks/months after they started using it. Let's move all those things in decent modules, Servant.Links etc.

[fizruk]

I agree that these should not be merely Utils.

How about putting IsElem, IsIn and IsSubAPI into Servant.API.Types or Servant.API.Constraints?

[jkarni]

I feel like .Types is traditionally a module containing all the types of a package, whereas here what we mean is that it contains functionality for working with types (which is why I suggested TypeUtils).

[alpmestan]

Typelevel ?

[fizruk]

I am okay with Servant.API.TypeLevel.

[phadej]

Superseded by #345. Closing this.