Type level cofree react router

Main.purs

module Type.React.Router where

import Control.Monad.Eff (Eff)
import Control.Monad.Eff.Console (CONSOLE, log)
import Prelude (Unit)
import Type.Proxy (Proxy(..))
import Type.Trout (type (:/), Capture, Lit, Named, QueryParam, QueryParams, Sub)

type PBool = Proxy Boolean

class IsLocation x

instance isLocationLit :: IsLocation (Lit v)
instance isLocationCapture :: IsLocation (Capture v t)
instance isLocationQueryParam :: IsLocation (QueryParam k v)
instance isLocationQueryParams :: IsLocation (QueryParams k v)
instance isLocationNamed :: (IsLocation l) => IsLocation (Named n l)
instance isLocationSub :: (IsLocation l) => IsLocation (Sub v l)

data Nil
data Cons a as

class IsList x

instance isListNil :: IsList Nil
instance isListCons :: (IsList as) => IsList (Cons a as)

list1 :: IsList (Cons Int (Cons String Nil)) => PBool
list1 = Proxy

notList1 :: IsList (Cons Int (Cons String Int)) => PBool
notList1 = Proxy

data Leaf a as

class IsLeafList x

instance isLeafListNil :: IsLeafList Nil
instance isLeafListCons :: (IsLocation a, IsList as, IsLeafList as, IsList bs, IsLeafList bs) => IsLeafList (Cons (Leaf a as) bs)

llist1 :: IsLeafList (Cons (Leaf (Lit "") (Cons (Leaf (Lit "") Nil) Nil)) Nil) => PBool
llist1 = Proxy

llist2 :: IsLeafList (Cons (Leaf (Lit "") (Cons (Leaf (Lit "") Nil) Nil)) (Cons (Leaf (Lit "") Nil) Nil)) => PBool
llist2 = Proxy

class IsRouter x

instance isRouterNil :: (IsLocation l) => IsRouter (Leaf l Nil)
instance isRouterCons :: (IsLocation l, IsRouter a, IsLeafList as) => IsRouter (Leaf l (Cons a as))

type Router1 = Leaf (Lit "home") (Cons (Leaf ("users" :/ Capture "userId" Int) Nil) Nil)

router1 :: IsRouter Router1 => PBool
router1 = Proxy

type Router2 = Leaf (Lit "home")
  (Cons
    (Leaf (Lit "books")
      (Cons (Leaf (Capture "bookId" Int) Nil) Nil))
    (Cons
      (Leaf (Lit "users")
        (Cons (Leaf (Capture "userId" Int) Nil) Nil))
      Nil))

router2 :: IsRouter Router2 => PBool
router2 = Proxy