{-# LANGUAGE GeneralizedNewtypeDeriving, DeriveDataTypeable, DeriveFunctor, ViewPatterns #-}
{-# LANGUAGE RecordWildCards, OverloadedStrings, PatternGuards, ScopedTypeVariables #-}

-- | Types used to generate the input.
module Input.Item(
    Sig(..), Ctx(..), Ty(..), prettySig,
    Item(..), itemName,
    Target(..), targetExpandURL, TargetId(..),
    splitIPackage, splitIModule,
    hseToSig, hseToItem, item_test,
    unHTMLTarget
    ) where

import Numeric
import Control.Applicative
import Data.Tuple.Extra
import Language.Haskell.Exts
import Data.Char
import Data.List.Extra
import Data.Maybe
import Data.Ix
import Data.Binary
import Foreign.Storable
import Control.DeepSeq
import Data.Data
import General.Util
import General.Str
import General.IString
import Prelude
import qualified Data.Aeson as J
import Data.Aeson.Types
import qualified Data.Text as T
import Test.QuickCheck
---------------------------------------------------------------------
-- TYPES

data Sig n = Sig {Sig n -> [Ctx n]
sigCtx :: [Ctx n], Sig n -> [Ty n]
sigTy :: [Ty n]} deriving (Int -> Sig n -> ShowS
[Sig n] -> ShowS
Sig n -> String
(Int -> Sig n -> ShowS)
-> (Sig n -> String) -> ([Sig n] -> ShowS) -> Show (Sig n)
forall n. Show n => Int -> Sig n -> ShowS
forall n. Show n => [Sig n] -> ShowS
forall n. Show n => Sig n -> String
forall a.
(Int -> a -> ShowS) -> (a -> String) -> ([a] -> ShowS) -> Show a
showList :: [Sig n] -> ShowS
$cshowList :: forall n. Show n => [Sig n] -> ShowS
show :: Sig n -> String
$cshow :: forall n. Show n => Sig n -> String
showsPrec :: Int -> Sig n -> ShowS
$cshowsPrec :: forall n. Show n => Int -> Sig n -> ShowS
Show,Sig n -> Sig n -> Bool
(Sig n -> Sig n -> Bool) -> (Sig n -> Sig n -> Bool) -> Eq (Sig n)
forall n. Eq n => Sig n -> Sig n -> Bool
forall a. (a -> a -> Bool) -> (a -> a -> Bool) -> Eq a
/= :: Sig n -> Sig n -> Bool
$c/= :: forall n. Eq n => Sig n -> Sig n -> Bool
== :: Sig n -> Sig n -> Bool
$c== :: forall n. Eq n => Sig n -> Sig n -> Bool
Eq,Eq (Sig n)
Eq (Sig n)
-> (Sig n -> Sig n -> Ordering)
-> (Sig n -> Sig n -> Bool)
-> (Sig n -> Sig n -> Bool)
-> (Sig n -> Sig n -> Bool)
-> (Sig n -> Sig n -> Bool)
-> (Sig n -> Sig n -> Sig n)
-> (Sig n -> Sig n -> Sig n)
-> Ord (Sig n)
Sig n -> Sig n -> Bool
Sig n -> Sig n -> Ordering
Sig n -> Sig n -> Sig n
forall a.
Eq a
-> (a -> a -> Ordering)
-> (a -> a -> Bool)
-> (a -> a -> Bool)
-> (a -> a -> Bool)
-> (a -> a -> Bool)
-> (a -> a -> a)
-> (a -> a -> a)
-> Ord a
forall n. Ord n => Eq (Sig n)
forall n. Ord n => Sig n -> Sig n -> Bool
forall n. Ord n => Sig n -> Sig n -> Ordering
forall n. Ord n => Sig n -> Sig n -> Sig n
min :: Sig n -> Sig n -> Sig n
$cmin :: forall n. Ord n => Sig n -> Sig n -> Sig n
max :: Sig n -> Sig n -> Sig n
$cmax :: forall n. Ord n => Sig n -> Sig n -> Sig n
>= :: Sig n -> Sig n -> Bool
$c>= :: forall n. Ord n => Sig n -> Sig n -> Bool
> :: Sig n -> Sig n -> Bool
$c> :: forall n. Ord n => Sig n -> Sig n -> Bool
<= :: Sig n -> Sig n -> Bool
$c<= :: forall n. Ord n => Sig n -> Sig n -> Bool
< :: Sig n -> Sig n -> Bool
$c< :: forall n. Ord n => Sig n -> Sig n -> Bool
compare :: Sig n -> Sig n -> Ordering
$ccompare :: forall n. Ord n => Sig n -> Sig n -> Ordering
$cp1Ord :: forall n. Ord n => Eq (Sig n)
Ord,Typeable,Typeable (Sig n)
DataType
Constr
Typeable (Sig n)
-> (forall (c :: * -> *).
    (forall d b. Data d => c (d -> b) -> d -> c b)
    -> (forall g. g -> c g) -> Sig n -> c (Sig n))
-> (forall (c :: * -> *).
    (forall b r. Data b => c (b -> r) -> c r)
    -> (forall r. r -> c r) -> Constr -> c (Sig n))
-> (Sig n -> Constr)
-> (Sig n -> DataType)
-> (forall (t :: * -> *) (c :: * -> *).
    Typeable t =>
    (forall d. Data d => c (t d)) -> Maybe (c (Sig n)))
-> (forall (t :: * -> * -> *) (c :: * -> *).
    Typeable t =>
    (forall d e. (Data d, Data e) => c (t d e)) -> Maybe (c (Sig n)))
-> ((forall b. Data b => b -> b) -> Sig n -> Sig n)
-> (forall r r'.
    (r -> r' -> r) -> r -> (forall d. Data d => d -> r') -> Sig n -> r)
-> (forall r r'.
    (r' -> r -> r) -> r -> (forall d. Data d => d -> r') -> Sig n -> r)
-> (forall u. (forall d. Data d => d -> u) -> Sig n -> [u])
-> (forall u. Int -> (forall d. Data d => d -> u) -> Sig n -> u)
-> (forall (m :: * -> *).
    Monad m =>
    (forall d. Data d => d -> m d) -> Sig n -> m (Sig n))
-> (forall (m :: * -> *).
    MonadPlus m =>
    (forall d. Data d => d -> m d) -> Sig n -> m (Sig n))
-> (forall (m :: * -> *).
    MonadPlus m =>
    (forall d. Data d => d -> m d) -> Sig n -> m (Sig n))
-> Data (Sig n)
Sig n -> DataType
Sig n -> Constr
(forall d. Data d => c (t d)) -> Maybe (c (Sig n))
(forall b. Data b => b -> b) -> Sig n -> Sig n
(forall d b. Data d => c (d -> b) -> d -> c b)
-> (forall g. g -> c g) -> Sig n -> c (Sig n)
(forall b r. Data b => c (b -> r) -> c r)
-> (forall r. r -> c r) -> Constr -> c (Sig n)
forall n. Data n => Typeable (Sig n)
forall n. Data n => Sig n -> DataType
forall n. Data n => Sig n -> Constr
forall n. Data n => (forall b. Data b => b -> b) -> Sig n -> Sig n
forall n u.
Data n =>
Int -> (forall d. Data d => d -> u) -> Sig n -> u
forall n u. Data n => (forall d. Data d => d -> u) -> Sig n -> [u]
forall n r r'.
Data n =>
(r -> r' -> r) -> r -> (forall d. Data d => d -> r') -> Sig n -> r
forall n r r'.
Data n =>
(r' -> r -> r) -> r -> (forall d. Data d => d -> r') -> Sig n -> r
forall n (m :: * -> *).
(Data n, Monad m) =>
(forall d. Data d => d -> m d) -> Sig n -> m (Sig n)
forall n (m :: * -> *).
(Data n, MonadPlus m) =>
(forall d. Data d => d -> m d) -> Sig n -> m (Sig n)
forall n (c :: * -> *).
Data n =>
(forall b r. Data b => c (b -> r) -> c r)
-> (forall r. r -> c r) -> Constr -> c (Sig n)
forall n (c :: * -> *).
Data n =>
(forall d b. Data d => c (d -> b) -> d -> c b)
-> (forall g. g -> c g) -> Sig n -> c (Sig n)
forall n (t :: * -> *) (c :: * -> *).
(Data n, Typeable t) =>
(forall d. Data d => c (t d)) -> Maybe (c (Sig n))
forall n (t :: * -> * -> *) (c :: * -> *).
(Data n, Typeable t) =>
(forall d e. (Data d, Data e) => c (t d e)) -> Maybe (c (Sig n))
forall a.
Typeable a
-> (forall (c :: * -> *).
    (forall d b. Data d => c (d -> b) -> d -> c b)
    -> (forall g. g -> c g) -> a -> c a)
-> (forall (c :: * -> *).
    (forall b r. Data b => c (b -> r) -> c r)
    -> (forall r. r -> c r) -> Constr -> c a)
-> (a -> Constr)
-> (a -> DataType)
-> (forall (t :: * -> *) (c :: * -> *).
    Typeable t =>
    (forall d. Data d => c (t d)) -> Maybe (c a))
-> (forall (t :: * -> * -> *) (c :: * -> *).
    Typeable t =>
    (forall d e. (Data d, Data e) => c (t d e)) -> Maybe (c a))
-> ((forall b. Data b => b -> b) -> a -> a)
-> (forall r r'.
    (r -> r' -> r) -> r -> (forall d. Data d => d -> r') -> a -> r)
-> (forall r r'.
    (r' -> r -> r) -> r -> (forall d. Data d => d -> r') -> a -> r)
-> (forall u. (forall d. Data d => d -> u) -> a -> [u])
-> (forall u. Int -> (forall d. Data d => d -> u) -> a -> u)
-> (forall (m :: * -> *).
    Monad m =>
    (forall d. Data d => d -> m d) -> a -> m a)
-> (forall (m :: * -> *).
    MonadPlus m =>
    (forall d. Data d => d -> m d) -> a -> m a)
-> (forall (m :: * -> *).
    MonadPlus m =>
    (forall d. Data d => d -> m d) -> a -> m a)
-> Data a
forall u. Int -> (forall d. Data d => d -> u) -> Sig n -> u
forall u. (forall d. Data d => d -> u) -> Sig n -> [u]
forall r r'.
(r -> r' -> r) -> r -> (forall d. Data d => d -> r') -> Sig n -> r
forall r r'.
(r' -> r -> r) -> r -> (forall d. Data d => d -> r') -> Sig n -> r
forall (m :: * -> *).
Monad m =>
(forall d. Data d => d -> m d) -> Sig n -> m (Sig n)
forall (m :: * -> *).
MonadPlus m =>
(forall d. Data d => d -> m d) -> Sig n -> m (Sig n)
forall (c :: * -> *).
(forall b r. Data b => c (b -> r) -> c r)
-> (forall r. r -> c r) -> Constr -> c (Sig n)
forall (c :: * -> *).
(forall d b. Data d => c (d -> b) -> d -> c b)
-> (forall g. g -> c g) -> Sig n -> c (Sig n)
forall (t :: * -> *) (c :: * -> *).
Typeable t =>
(forall d. Data d => c (t d)) -> Maybe (c (Sig n))
forall (t :: * -> * -> *) (c :: * -> *).
Typeable t =>
(forall d e. (Data d, Data e) => c (t d e)) -> Maybe (c (Sig n))
$cSig :: Constr
$tSig :: DataType
gmapMo :: (forall d. Data d => d -> m d) -> Sig n -> m (Sig n)
$cgmapMo :: forall n (m :: * -> *).
(Data n, MonadPlus m) =>
(forall d. Data d => d -> m d) -> Sig n -> m (Sig n)
gmapMp :: (forall d. Data d => d -> m d) -> Sig n -> m (Sig n)
$cgmapMp :: forall n (m :: * -> *).
(Data n, MonadPlus m) =>
(forall d. Data d => d -> m d) -> Sig n -> m (Sig n)
gmapM :: (forall d. Data d => d -> m d) -> Sig n -> m (Sig n)
$cgmapM :: forall n (m :: * -> *).
(Data n, Monad m) =>
(forall d. Data d => d -> m d) -> Sig n -> m (Sig n)
gmapQi :: Int -> (forall d. Data d => d -> u) -> Sig n -> u
$cgmapQi :: forall n u.
Data n =>
Int -> (forall d. Data d => d -> u) -> Sig n -> u
gmapQ :: (forall d. Data d => d -> u) -> Sig n -> [u]
$cgmapQ :: forall n u. Data n => (forall d. Data d => d -> u) -> Sig n -> [u]
gmapQr :: (r' -> r -> r) -> r -> (forall d. Data d => d -> r') -> Sig n -> r
$cgmapQr :: forall n r r'.
Data n =>
(r' -> r -> r) -> r -> (forall d. Data d => d -> r') -> Sig n -> r
gmapQl :: (r -> r' -> r) -> r -> (forall d. Data d => d -> r') -> Sig n -> r
$cgmapQl :: forall n r r'.
Data n =>
(r -> r' -> r) -> r -> (forall d. Data d => d -> r') -> Sig n -> r
gmapT :: (forall b. Data b => b -> b) -> Sig n -> Sig n
$cgmapT :: forall n. Data n => (forall b. Data b => b -> b) -> Sig n -> Sig n
dataCast2 :: (forall d e. (Data d, Data e) => c (t d e)) -> Maybe (c (Sig n))
$cdataCast2 :: forall n (t :: * -> * -> *) (c :: * -> *).
(Data n, Typeable t) =>
(forall d e. (Data d, Data e) => c (t d e)) -> Maybe (c (Sig n))
dataCast1 :: (forall d. Data d => c (t d)) -> Maybe (c (Sig n))
$cdataCast1 :: forall n (t :: * -> *) (c :: * -> *).
(Data n, Typeable t) =>
(forall d. Data d => c (t d)) -> Maybe (c (Sig n))
dataTypeOf :: Sig n -> DataType
$cdataTypeOf :: forall n. Data n => Sig n -> DataType
toConstr :: Sig n -> Constr
$ctoConstr :: forall n. Data n => Sig n -> Constr
gunfold :: (forall b r. Data b => c (b -> r) -> c r)
-> (forall r. r -> c r) -> Constr -> c (Sig n)
$cgunfold :: forall n (c :: * -> *).
Data n =>
(forall b r. Data b => c (b -> r) -> c r)
-> (forall r. r -> c r) -> Constr -> c (Sig n)
gfoldl :: (forall d b. Data d => c (d -> b) -> d -> c b)
-> (forall g. g -> c g) -> Sig n -> c (Sig n)
$cgfoldl :: forall n (c :: * -> *).
Data n =>
(forall d b. Data d => c (d -> b) -> d -> c b)
-> (forall g. g -> c g) -> Sig n -> c (Sig n)
$cp1Data :: forall n. Data n => Typeable (Sig n)
Data,a -> Sig b -> Sig a
(a -> b) -> Sig a -> Sig b
(forall a b. (a -> b) -> Sig a -> Sig b)
-> (forall a b. a -> Sig b -> Sig a) -> Functor Sig
forall a b. a -> Sig b -> Sig a
forall a b. (a -> b) -> Sig a -> Sig b
forall (f :: * -> *).
(forall a b. (a -> b) -> f a -> f b)
-> (forall a b. a -> f b -> f a) -> Functor f
<$ :: a -> Sig b -> Sig a
$c<$ :: forall a b. a -> Sig b -> Sig a
fmap :: (a -> b) -> Sig a -> Sig b
$cfmap :: forall a b. (a -> b) -> Sig a -> Sig b
Functor) -- list of -> types
data Ctx n = Ctx n n deriving (Int -> Ctx n -> ShowS
[Ctx n] -> ShowS
Ctx n -> String
(Int -> Ctx n -> ShowS)
-> (Ctx n -> String) -> ([Ctx n] -> ShowS) -> Show (Ctx n)
forall n. Show n => Int -> Ctx n -> ShowS
forall n. Show n => [Ctx n] -> ShowS
forall n. Show n => Ctx n -> String
forall a.
(Int -> a -> ShowS) -> (a -> String) -> ([a] -> ShowS) -> Show a
showList :: [Ctx n] -> ShowS
$cshowList :: forall n. Show n => [Ctx n] -> ShowS
show :: Ctx n -> String
$cshow :: forall n. Show n => Ctx n -> String
showsPrec :: Int -> Ctx n -> ShowS
$cshowsPrec :: forall n. Show n => Int -> Ctx n -> ShowS
Show,Ctx n -> Ctx n -> Bool
(Ctx n -> Ctx n -> Bool) -> (Ctx n -> Ctx n -> Bool) -> Eq (Ctx n)
forall n. Eq n => Ctx n -> Ctx n -> Bool
forall a. (a -> a -> Bool) -> (a -> a -> Bool) -> Eq a
/= :: Ctx n -> Ctx n -> Bool
$c/= :: forall n. Eq n => Ctx n -> Ctx n -> Bool
== :: Ctx n -> Ctx n -> Bool
$c== :: forall n. Eq n => Ctx n -> Ctx n -> Bool
Eq,Eq (Ctx n)
Eq (Ctx n)
-> (Ctx n -> Ctx n -> Ordering)
-> (Ctx n -> Ctx n -> Bool)
-> (Ctx n -> Ctx n -> Bool)
-> (Ctx n -> Ctx n -> Bool)
-> (Ctx n -> Ctx n -> Bool)
-> (Ctx n -> Ctx n -> Ctx n)
-> (Ctx n -> Ctx n -> Ctx n)
-> Ord (Ctx n)
Ctx n -> Ctx n -> Bool
Ctx n -> Ctx n -> Ordering
Ctx n -> Ctx n -> Ctx n
forall a.
Eq a
-> (a -> a -> Ordering)
-> (a -> a -> Bool)
-> (a -> a -> Bool)
-> (a -> a -> Bool)
-> (a -> a -> Bool)
-> (a -> a -> a)
-> (a -> a -> a)
-> Ord a
forall n. Ord n => Eq (Ctx n)
forall n. Ord n => Ctx n -> Ctx n -> Bool
forall n. Ord n => Ctx n -> Ctx n -> Ordering
forall n. Ord n => Ctx n -> Ctx n -> Ctx n
min :: Ctx n -> Ctx n -> Ctx n
$cmin :: forall n. Ord n => Ctx n -> Ctx n -> Ctx n
max :: Ctx n -> Ctx n -> Ctx n
$cmax :: forall n. Ord n => Ctx n -> Ctx n -> Ctx n
>= :: Ctx n -> Ctx n -> Bool
$c>= :: forall n. Ord n => Ctx n -> Ctx n -> Bool
> :: Ctx n -> Ctx n -> Bool
$c> :: forall n. Ord n => Ctx n -> Ctx n -> Bool
<= :: Ctx n -> Ctx n -> Bool
$c<= :: forall n. Ord n => Ctx n -> Ctx n -> Bool
< :: Ctx n -> Ctx n -> Bool
$c< :: forall n. Ord n => Ctx n -> Ctx n -> Bool
compare :: Ctx n -> Ctx n -> Ordering
$ccompare :: forall n. Ord n => Ctx n -> Ctx n -> Ordering
$cp1Ord :: forall n. Ord n => Eq (Ctx n)
Ord,Typeable,Typeable (Ctx n)
DataType
Constr
Typeable (Ctx n)
-> (forall (c :: * -> *).
    (forall d b. Data d => c (d -> b) -> d -> c b)
    -> (forall g. g -> c g) -> Ctx n -> c (Ctx n))
-> (forall (c :: * -> *).
    (forall b r. Data b => c (b -> r) -> c r)
    -> (forall r. r -> c r) -> Constr -> c (Ctx n))
-> (Ctx n -> Constr)
-> (Ctx n -> DataType)
-> (forall (t :: * -> *) (c :: * -> *).
    Typeable t =>
    (forall d. Data d => c (t d)) -> Maybe (c (Ctx n)))
-> (forall (t :: * -> * -> *) (c :: * -> *).
    Typeable t =>
    (forall d e. (Data d, Data e) => c (t d e)) -> Maybe (c (Ctx n)))
-> ((forall b. Data b => b -> b) -> Ctx n -> Ctx n)
-> (forall r r'.
    (r -> r' -> r) -> r -> (forall d. Data d => d -> r') -> Ctx n -> r)
-> (forall r r'.
    (r' -> r -> r) -> r -> (forall d. Data d => d -> r') -> Ctx n -> r)
-> (forall u. (forall d. Data d => d -> u) -> Ctx n -> [u])
-> (forall u. Int -> (forall d. Data d => d -> u) -> Ctx n -> u)
-> (forall (m :: * -> *).
    Monad m =>
    (forall d. Data d => d -> m d) -> Ctx n -> m (Ctx n))
-> (forall (m :: * -> *).
    MonadPlus m =>
    (forall d. Data d => d -> m d) -> Ctx n -> m (Ctx n))
-> (forall (m :: * -> *).
    MonadPlus m =>
    (forall d. Data d => d -> m d) -> Ctx n -> m (Ctx n))
-> Data (Ctx n)
Ctx n -> DataType
Ctx n -> Constr
(forall d. Data d => c (t d)) -> Maybe (c (Ctx n))
(forall b. Data b => b -> b) -> Ctx n -> Ctx n
(forall d b. Data d => c (d -> b) -> d -> c b)
-> (forall g. g -> c g) -> Ctx n -> c (Ctx n)
(forall b r. Data b => c (b -> r) -> c r)
-> (forall r. r -> c r) -> Constr -> c (Ctx n)
forall n. Data n => Typeable (Ctx n)
forall n. Data n => Ctx n -> DataType
forall n. Data n => Ctx n -> Constr
forall n. Data n => (forall b. Data b => b -> b) -> Ctx n -> Ctx n
forall n u.
Data n =>
Int -> (forall d. Data d => d -> u) -> Ctx n -> u
forall n u. Data n => (forall d. Data d => d -> u) -> Ctx n -> [u]
forall n r r'.
Data n =>
(r -> r' -> r) -> r -> (forall d. Data d => d -> r') -> Ctx n -> r
forall n r r'.
Data n =>
(r' -> r -> r) -> r -> (forall d. Data d => d -> r') -> Ctx n -> r
forall n (m :: * -> *).
(Data n, Monad m) =>
(forall d. Data d => d -> m d) -> Ctx n -> m (Ctx n)
forall n (m :: * -> *).
(Data n, MonadPlus m) =>
(forall d. Data d => d -> m d) -> Ctx n -> m (Ctx n)
forall n (c :: * -> *).
Data n =>
(forall b r. Data b => c (b -> r) -> c r)
-> (forall r. r -> c r) -> Constr -> c (Ctx n)
forall n (c :: * -> *).
Data n =>
(forall d b. Data d => c (d -> b) -> d -> c b)
-> (forall g. g -> c g) -> Ctx n -> c (Ctx n)
forall n (t :: * -> *) (c :: * -> *).
(Data n, Typeable t) =>
(forall d. Data d => c (t d)) -> Maybe (c (Ctx n))
forall n (t :: * -> * -> *) (c :: * -> *).
(Data n, Typeable t) =>
(forall d e. (Data d, Data e) => c (t d e)) -> Maybe (c (Ctx n))
forall a.
Typeable a
-> (forall (c :: * -> *).
    (forall d b. Data d => c (d -> b) -> d -> c b)
    -> (forall g. g -> c g) -> a -> c a)
-> (forall (c :: * -> *).
    (forall b r. Data b => c (b -> r) -> c r)
    -> (forall r. r -> c r) -> Constr -> c a)
-> (a -> Constr)
-> (a -> DataType)
-> (forall (t :: * -> *) (c :: * -> *).
    Typeable t =>
    (forall d. Data d => c (t d)) -> Maybe (c a))
-> (forall (t :: * -> * -> *) (c :: * -> *).
    Typeable t =>
    (forall d e. (Data d, Data e) => c (t d e)) -> Maybe (c a))
-> ((forall b. Data b => b -> b) -> a -> a)
-> (forall r r'.
    (r -> r' -> r) -> r -> (forall d. Data d => d -> r') -> a -> r)
-> (forall r r'.
    (r' -> r -> r) -> r -> (forall d. Data d => d -> r') -> a -> r)
-> (forall u. (forall d. Data d => d -> u) -> a -> [u])
-> (forall u. Int -> (forall d. Data d => d -> u) -> a -> u)
-> (forall (m :: * -> *).
    Monad m =>
    (forall d. Data d => d -> m d) -> a -> m a)
-> (forall (m :: * -> *).
    MonadPlus m =>
    (forall d. Data d => d -> m d) -> a -> m a)
-> (forall (m :: * -> *).
    MonadPlus m =>
    (forall d. Data d => d -> m d) -> a -> m a)
-> Data a
forall u. Int -> (forall d. Data d => d -> u) -> Ctx n -> u
forall u. (forall d. Data d => d -> u) -> Ctx n -> [u]
forall r r'.
(r -> r' -> r) -> r -> (forall d. Data d => d -> r') -> Ctx n -> r
forall r r'.
(r' -> r -> r) -> r -> (forall d. Data d => d -> r') -> Ctx n -> r
forall (m :: * -> *).
Monad m =>
(forall d. Data d => d -> m d) -> Ctx n -> m (Ctx n)
forall (m :: * -> *).
MonadPlus m =>
(forall d. Data d => d -> m d) -> Ctx n -> m (Ctx n)
forall (c :: * -> *).
(forall b r. Data b => c (b -> r) -> c r)
-> (forall r. r -> c r) -> Constr -> c (Ctx n)
forall (c :: * -> *).
(forall d b. Data d => c (d -> b) -> d -> c b)
-> (forall g. g -> c g) -> Ctx n -> c (Ctx n)
forall (t :: * -> *) (c :: * -> *).
Typeable t =>
(forall d. Data d => c (t d)) -> Maybe (c (Ctx n))
forall (t :: * -> * -> *) (c :: * -> *).
Typeable t =>
(forall d e. (Data d, Data e) => c (t d e)) -> Maybe (c (Ctx n))
$cCtx :: Constr
$tCtx :: DataType
gmapMo :: (forall d. Data d => d -> m d) -> Ctx n -> m (Ctx n)
$cgmapMo :: forall n (m :: * -> *).
(Data n, MonadPlus m) =>
(forall d. Data d => d -> m d) -> Ctx n -> m (Ctx n)
gmapMp :: (forall d. Data d => d -> m d) -> Ctx n -> m (Ctx n)
$cgmapMp :: forall n (m :: * -> *).
(Data n, MonadPlus m) =>
(forall d. Data d => d -> m d) -> Ctx n -> m (Ctx n)
gmapM :: (forall d. Data d => d -> m d) -> Ctx n -> m (Ctx n)
$cgmapM :: forall n (m :: * -> *).
(Data n, Monad m) =>
(forall d. Data d => d -> m d) -> Ctx n -> m (Ctx n)
gmapQi :: Int -> (forall d. Data d => d -> u) -> Ctx n -> u
$cgmapQi :: forall n u.
Data n =>
Int -> (forall d. Data d => d -> u) -> Ctx n -> u
gmapQ :: (forall d. Data d => d -> u) -> Ctx n -> [u]
$cgmapQ :: forall n u. Data n => (forall d. Data d => d -> u) -> Ctx n -> [u]
gmapQr :: (r' -> r -> r) -> r -> (forall d. Data d => d -> r') -> Ctx n -> r
$cgmapQr :: forall n r r'.
Data n =>
(r' -> r -> r) -> r -> (forall d. Data d => d -> r') -> Ctx n -> r
gmapQl :: (r -> r' -> r) -> r -> (forall d. Data d => d -> r') -> Ctx n -> r
$cgmapQl :: forall n r r'.
Data n =>
(r -> r' -> r) -> r -> (forall d. Data d => d -> r') -> Ctx n -> r
gmapT :: (forall b. Data b => b -> b) -> Ctx n -> Ctx n
$cgmapT :: forall n. Data n => (forall b. Data b => b -> b) -> Ctx n -> Ctx n
dataCast2 :: (forall d e. (Data d, Data e) => c (t d e)) -> Maybe (c (Ctx n))
$cdataCast2 :: forall n (t :: * -> * -> *) (c :: * -> *).
(Data n, Typeable t) =>
(forall d e. (Data d, Data e) => c (t d e)) -> Maybe (c (Ctx n))
dataCast1 :: (forall d. Data d => c (t d)) -> Maybe (c (Ctx n))
$cdataCast1 :: forall n (t :: * -> *) (c :: * -> *).
(Data n, Typeable t) =>
(forall d. Data d => c (t d)) -> Maybe (c (Ctx n))
dataTypeOf :: Ctx n -> DataType
$cdataTypeOf :: forall n. Data n => Ctx n -> DataType
toConstr :: Ctx n -> Constr
$ctoConstr :: forall n. Data n => Ctx n -> Constr
gunfold :: (forall b r. Data b => c (b -> r) -> c r)
-> (forall r. r -> c r) -> Constr -> c (Ctx n)
$cgunfold :: forall n (c :: * -> *).
Data n =>
(forall b r. Data b => c (b -> r) -> c r)
-> (forall r. r -> c r) -> Constr -> c (Ctx n)
gfoldl :: (forall d b. Data d => c (d -> b) -> d -> c b)
-> (forall g. g -> c g) -> Ctx n -> c (Ctx n)
$cgfoldl :: forall n (c :: * -> *).
Data n =>
(forall d b. Data d => c (d -> b) -> d -> c b)
-> (forall g. g -> c g) -> Ctx n -> c (Ctx n)
$cp1Data :: forall n. Data n => Typeable (Ctx n)
Data,a -> Ctx b -> Ctx a
(a -> b) -> Ctx a -> Ctx b
(forall a b. (a -> b) -> Ctx a -> Ctx b)
-> (forall a b. a -> Ctx b -> Ctx a) -> Functor Ctx
forall a b. a -> Ctx b -> Ctx a
forall a b. (a -> b) -> Ctx a -> Ctx b
forall (f :: * -> *).
(forall a b. (a -> b) -> f a -> f b)
-> (forall a b. a -> f b -> f a) -> Functor f
<$ :: a -> Ctx b -> Ctx a
$c<$ :: forall a b. a -> Ctx b -> Ctx a
fmap :: (a -> b) -> Ctx a -> Ctx b
$cfmap :: forall a b. (a -> b) -> Ctx a -> Ctx b
Functor) -- context, second will usually be a free variable
data Ty n = TCon n [Ty n] | TVar n [Ty n] deriving (Int -> Ty n -> ShowS
[Ty n] -> ShowS
Ty n -> String
(Int -> Ty n -> ShowS)
-> (Ty n -> String) -> ([Ty n] -> ShowS) -> Show (Ty n)
forall n. Show n => Int -> Ty n -> ShowS
forall n. Show n => [Ty n] -> ShowS
forall n. Show n => Ty n -> String
forall a.
(Int -> a -> ShowS) -> (a -> String) -> ([a] -> ShowS) -> Show a
showList :: [Ty n] -> ShowS
$cshowList :: forall n. Show n => [Ty n] -> ShowS
show :: Ty n -> String
$cshow :: forall n. Show n => Ty n -> String
showsPrec :: Int -> Ty n -> ShowS
$cshowsPrec :: forall n. Show n => Int -> Ty n -> ShowS
Show,Ty n -> Ty n -> Bool
(Ty n -> Ty n -> Bool) -> (Ty n -> Ty n -> Bool) -> Eq (Ty n)
forall n. Eq n => Ty n -> Ty n -> Bool
forall a. (a -> a -> Bool) -> (a -> a -> Bool) -> Eq a
/= :: Ty n -> Ty n -> Bool
$c/= :: forall n. Eq n => Ty n -> Ty n -> Bool
== :: Ty n -> Ty n -> Bool
$c== :: forall n. Eq n => Ty n -> Ty n -> Bool
Eq,Eq (Ty n)
Eq (Ty n)
-> (Ty n -> Ty n -> Ordering)
-> (Ty n -> Ty n -> Bool)
-> (Ty n -> Ty n -> Bool)
-> (Ty n -> Ty n -> Bool)
-> (Ty n -> Ty n -> Bool)
-> (Ty n -> Ty n -> Ty n)
-> (Ty n -> Ty n -> Ty n)
-> Ord (Ty n)
Ty n -> Ty n -> Bool
Ty n -> Ty n -> Ordering
Ty n -> Ty n -> Ty n
forall a.
Eq a
-> (a -> a -> Ordering)
-> (a -> a -> Bool)
-> (a -> a -> Bool)
-> (a -> a -> Bool)
-> (a -> a -> Bool)
-> (a -> a -> a)
-> (a -> a -> a)
-> Ord a
forall n. Ord n => Eq (Ty n)
forall n. Ord n => Ty n -> Ty n -> Bool
forall n. Ord n => Ty n -> Ty n -> Ordering
forall n. Ord n => Ty n -> Ty n -> Ty n
min :: Ty n -> Ty n -> Ty n
$cmin :: forall n. Ord n => Ty n -> Ty n -> Ty n
max :: Ty n -> Ty n -> Ty n
$cmax :: forall n. Ord n => Ty n -> Ty n -> Ty n
>= :: Ty n -> Ty n -> Bool
$c>= :: forall n. Ord n => Ty n -> Ty n -> Bool
> :: Ty n -> Ty n -> Bool
$c> :: forall n. Ord n => Ty n -> Ty n -> Bool
<= :: Ty n -> Ty n -> Bool
$c<= :: forall n. Ord n => Ty n -> Ty n -> Bool
< :: Ty n -> Ty n -> Bool
$c< :: forall n. Ord n => Ty n -> Ty n -> Bool
compare :: Ty n -> Ty n -> Ordering
$ccompare :: forall n. Ord n => Ty n -> Ty n -> Ordering
$cp1Ord :: forall n. Ord n => Eq (Ty n)
Ord,Typeable,Typeable (Ty n)
DataType
Constr
Typeable (Ty n)
-> (forall (c :: * -> *).
    (forall d b. Data d => c (d -> b) -> d -> c b)
    -> (forall g. g -> c g) -> Ty n -> c (Ty n))
-> (forall (c :: * -> *).
    (forall b r. Data b => c (b -> r) -> c r)
    -> (forall r. r -> c r) -> Constr -> c (Ty n))
-> (Ty n -> Constr)
-> (Ty n -> DataType)
-> (forall (t :: * -> *) (c :: * -> *).
    Typeable t =>
    (forall d. Data d => c (t d)) -> Maybe (c (Ty n)))
-> (forall (t :: * -> * -> *) (c :: * -> *).
    Typeable t =>
    (forall d e. (Data d, Data e) => c (t d e)) -> Maybe (c (Ty n)))
-> ((forall b. Data b => b -> b) -> Ty n -> Ty n)
-> (forall r r'.
    (r -> r' -> r) -> r -> (forall d. Data d => d -> r') -> Ty n -> r)
-> (forall r r'.
    (r' -> r -> r) -> r -> (forall d. Data d => d -> r') -> Ty n -> r)
-> (forall u. (forall d. Data d => d -> u) -> Ty n -> [u])
-> (forall u. Int -> (forall d. Data d => d -> u) -> Ty n -> u)
-> (forall (m :: * -> *).
    Monad m =>
    (forall d. Data d => d -> m d) -> Ty n -> m (Ty n))
-> (forall (m :: * -> *).
    MonadPlus m =>
    (forall d. Data d => d -> m d) -> Ty n -> m (Ty n))
-> (forall (m :: * -> *).
    MonadPlus m =>
    (forall d. Data d => d -> m d) -> Ty n -> m (Ty n))
-> Data (Ty n)
Ty n -> DataType
Ty n -> Constr
(forall d. Data d => c (t d)) -> Maybe (c (Ty n))
(forall b. Data b => b -> b) -> Ty n -> Ty n
(forall d b. Data d => c (d -> b) -> d -> c b)
-> (forall g. g -> c g) -> Ty n -> c (Ty n)
(forall b r. Data b => c (b -> r) -> c r)
-> (forall r. r -> c r) -> Constr -> c (Ty n)
forall n. Data n => Typeable (Ty n)
forall n. Data n => Ty n -> DataType
forall n. Data n => Ty n -> Constr
forall n. Data n => (forall b. Data b => b -> b) -> Ty n -> Ty n
forall n u.
Data n =>
Int -> (forall d. Data d => d -> u) -> Ty n -> u
forall n u. Data n => (forall d. Data d => d -> u) -> Ty n -> [u]
forall n r r'.
Data n =>
(r -> r' -> r) -> r -> (forall d. Data d => d -> r') -> Ty n -> r
forall n r r'.
Data n =>
(r' -> r -> r) -> r -> (forall d. Data d => d -> r') -> Ty n -> r
forall n (m :: * -> *).
(Data n, Monad m) =>
(forall d. Data d => d -> m d) -> Ty n -> m (Ty n)
forall n (m :: * -> *).
(Data n, MonadPlus m) =>
(forall d. Data d => d -> m d) -> Ty n -> m (Ty n)
forall n (c :: * -> *).
Data n =>
(forall b r. Data b => c (b -> r) -> c r)
-> (forall r. r -> c r) -> Constr -> c (Ty n)
forall n (c :: * -> *).
Data n =>
(forall d b. Data d => c (d -> b) -> d -> c b)
-> (forall g. g -> c g) -> Ty n -> c (Ty n)
forall n (t :: * -> *) (c :: * -> *).
(Data n, Typeable t) =>
(forall d. Data d => c (t d)) -> Maybe (c (Ty n))
forall n (t :: * -> * -> *) (c :: * -> *).
(Data n, Typeable t) =>
(forall d e. (Data d, Data e) => c (t d e)) -> Maybe (c (Ty n))
forall a.
Typeable a
-> (forall (c :: * -> *).
    (forall d b. Data d => c (d -> b) -> d -> c b)
    -> (forall g. g -> c g) -> a -> c a)
-> (forall (c :: * -> *).
    (forall b r. Data b => c (b -> r) -> c r)
    -> (forall r. r -> c r) -> Constr -> c a)
-> (a -> Constr)
-> (a -> DataType)
-> (forall (t :: * -> *) (c :: * -> *).
    Typeable t =>
    (forall d. Data d => c (t d)) -> Maybe (c a))
-> (forall (t :: * -> * -> *) (c :: * -> *).
    Typeable t =>
    (forall d e. (Data d, Data e) => c (t d e)) -> Maybe (c a))
-> ((forall b. Data b => b -> b) -> a -> a)
-> (forall r r'.
    (r -> r' -> r) -> r -> (forall d. Data d => d -> r') -> a -> r)
-> (forall r r'.
    (r' -> r -> r) -> r -> (forall d. Data d => d -> r') -> a -> r)
-> (forall u. (forall d. Data d => d -> u) -> a -> [u])
-> (forall u. Int -> (forall d. Data d => d -> u) -> a -> u)
-> (forall (m :: * -> *).
    Monad m =>
    (forall d. Data d => d -> m d) -> a -> m a)
-> (forall (m :: * -> *).
    MonadPlus m =>
    (forall d. Data d => d -> m d) -> a -> m a)
-> (forall (m :: * -> *).
    MonadPlus m =>
    (forall d. Data d => d -> m d) -> a -> m a)
-> Data a
forall u. Int -> (forall d. Data d => d -> u) -> Ty n -> u
forall u. (forall d. Data d => d -> u) -> Ty n -> [u]
forall r r'.
(r -> r' -> r) -> r -> (forall d. Data d => d -> r') -> Ty n -> r
forall r r'.
(r' -> r -> r) -> r -> (forall d. Data d => d -> r') -> Ty n -> r
forall (m :: * -> *).
Monad m =>
(forall d. Data d => d -> m d) -> Ty n -> m (Ty n)
forall (m :: * -> *).
MonadPlus m =>
(forall d. Data d => d -> m d) -> Ty n -> m (Ty n)
forall (c :: * -> *).
(forall b r. Data b => c (b -> r) -> c r)
-> (forall r. r -> c r) -> Constr -> c (Ty n)
forall (c :: * -> *).
(forall d b. Data d => c (d -> b) -> d -> c b)
-> (forall g. g -> c g) -> Ty n -> c (Ty n)
forall (t :: * -> *) (c :: * -> *).
Typeable t =>
(forall d. Data d => c (t d)) -> Maybe (c (Ty n))
forall (t :: * -> * -> *) (c :: * -> *).
Typeable t =>
(forall d e. (Data d, Data e) => c (t d e)) -> Maybe (c (Ty n))
$cTVar :: Constr
$cTCon :: Constr
$tTy :: DataType
gmapMo :: (forall d. Data d => d -> m d) -> Ty n -> m (Ty n)
$cgmapMo :: forall n (m :: * -> *).
(Data n, MonadPlus m) =>
(forall d. Data d => d -> m d) -> Ty n -> m (Ty n)
gmapMp :: (forall d. Data d => d -> m d) -> Ty n -> m (Ty n)
$cgmapMp :: forall n (m :: * -> *).
(Data n, MonadPlus m) =>
(forall d. Data d => d -> m d) -> Ty n -> m (Ty n)
gmapM :: (forall d. Data d => d -> m d) -> Ty n -> m (Ty n)
$cgmapM :: forall n (m :: * -> *).
(Data n, Monad m) =>
(forall d. Data d => d -> m d) -> Ty n -> m (Ty n)
gmapQi :: Int -> (forall d. Data d => d -> u) -> Ty n -> u
$cgmapQi :: forall n u.
Data n =>
Int -> (forall d. Data d => d -> u) -> Ty n -> u
gmapQ :: (forall d. Data d => d -> u) -> Ty n -> [u]
$cgmapQ :: forall n u. Data n => (forall d. Data d => d -> u) -> Ty n -> [u]
gmapQr :: (r' -> r -> r) -> r -> (forall d. Data d => d -> r') -> Ty n -> r
$cgmapQr :: forall n r r'.
Data n =>
(r' -> r -> r) -> r -> (forall d. Data d => d -> r') -> Ty n -> r
gmapQl :: (r -> r' -> r) -> r -> (forall d. Data d => d -> r') -> Ty n -> r
$cgmapQl :: forall n r r'.
Data n =>
(r -> r' -> r) -> r -> (forall d. Data d => d -> r') -> Ty n -> r
gmapT :: (forall b. Data b => b -> b) -> Ty n -> Ty n
$cgmapT :: forall n. Data n => (forall b. Data b => b -> b) -> Ty n -> Ty n
dataCast2 :: (forall d e. (Data d, Data e) => c (t d e)) -> Maybe (c (Ty n))
$cdataCast2 :: forall n (t :: * -> * -> *) (c :: * -> *).
(Data n, Typeable t) =>
(forall d e. (Data d, Data e) => c (t d e)) -> Maybe (c (Ty n))
dataCast1 :: (forall d. Data d => c (t d)) -> Maybe (c (Ty n))
$cdataCast1 :: forall n (t :: * -> *) (c :: * -> *).
(Data n, Typeable t) =>
(forall d. Data d => c (t d)) -> Maybe (c (Ty n))
dataTypeOf :: Ty n -> DataType
$cdataTypeOf :: forall n. Data n => Ty n -> DataType
toConstr :: Ty n -> Constr
$ctoConstr :: forall n. Data n => Ty n -> Constr
gunfold :: (forall b r. Data b => c (b -> r) -> c r)
-> (forall r. r -> c r) -> Constr -> c (Ty n)
$cgunfold :: forall n (c :: * -> *).
Data n =>
(forall b r. Data b => c (b -> r) -> c r)
-> (forall r. r -> c r) -> Constr -> c (Ty n)
gfoldl :: (forall d b. Data d => c (d -> b) -> d -> c b)
-> (forall g. g -> c g) -> Ty n -> c (Ty n)
$cgfoldl :: forall n (c :: * -> *).
Data n =>
(forall d b. Data d => c (d -> b) -> d -> c b)
-> (forall g. g -> c g) -> Ty n -> c (Ty n)
$cp1Data :: forall n. Data n => Typeable (Ty n)
Data,a -> Ty b -> Ty a
(a -> b) -> Ty a -> Ty b
(forall a b. (a -> b) -> Ty a -> Ty b)
-> (forall a b. a -> Ty b -> Ty a) -> Functor Ty
forall a b. a -> Ty b -> Ty a
forall a b. (a -> b) -> Ty a -> Ty b
forall (f :: * -> *).
(forall a b. (a -> b) -> f a -> f b)
-> (forall a b. a -> f b -> f a) -> Functor f
<$ :: a -> Ty b -> Ty a
$c<$ :: forall a b. a -> Ty b -> Ty a
fmap :: (a -> b) -> Ty a -> Ty b
$cfmap :: forall a b. (a -> b) -> Ty a -> Ty b
Functor) -- type application, vectorised, all symbols may occur at multiple kinds

instance NFData n => NFData (Sig n) where rnf :: Sig n -> ()
rnf (Sig [Ctx n]
x [Ty n]
y) = [Ctx n] -> ()
forall a. NFData a => a -> ()
rnf [Ctx n]
x () -> () -> ()
`seq` [Ty n] -> ()
forall a. NFData a => a -> ()
rnf [Ty n]
y
instance NFData n => NFData (Ctx n) where rnf :: Ctx n -> ()
rnf (Ctx n
x n
y) = n -> ()
forall a. NFData a => a -> ()
rnf n
x () -> () -> ()
`seq` n -> ()
forall a. NFData a => a -> ()
rnf n
y
instance NFData n => NFData (Ty  n) where
    rnf :: Ty n -> ()
rnf (TCon n
x [Ty n]
y) = n -> ()
forall a. NFData a => a -> ()
rnf n
x () -> () -> ()
`seq` [Ty n] -> ()
forall a. NFData a => a -> ()
rnf [Ty n]
y
    rnf (TVar n
x [Ty n]
y) = n -> ()
forall a. NFData a => a -> ()
rnf n
x () -> () -> ()
`seq` [Ty n] -> ()
forall a. NFData a => a -> ()
rnf [Ty n]
y

instance Binary n => Binary (Sig n) where
    put :: Sig n -> Put
put (Sig [Ctx n]
a [Ty n]
b) = [Ctx n] -> Put
forall t. Binary t => t -> Put
put [Ctx n]
a Put -> Put -> Put
forall (m :: * -> *) a b. Monad m => m a -> m b -> m b
>> [Ty n] -> Put
forall t. Binary t => t -> Put
put [Ty n]
b
    get :: Get (Sig n)
get = ([Ctx n] -> [Ty n] -> Sig n)
-> Get [Ctx n] -> Get [Ty n] -> Get (Sig n)
forall (f :: * -> *) a b c.
Applicative f =>
(a -> b -> c) -> f a -> f b -> f c
liftA2 [Ctx n] -> [Ty n] -> Sig n
forall n. [Ctx n] -> [Ty n] -> Sig n
Sig Get [Ctx n]
forall t. Binary t => Get t
get Get [Ty n]
forall t. Binary t => Get t
get

instance Binary n => Binary (Ctx n) where
    put :: Ctx n -> Put
put (Ctx n
a n
b) = n -> Put
forall t. Binary t => t -> Put
put n
a Put -> Put -> Put
forall (m :: * -> *) a b. Monad m => m a -> m b -> m b
>> n -> Put
forall t. Binary t => t -> Put
put n
b
    get :: Get (Ctx n)
get = (n -> n -> Ctx n) -> Get n -> Get n -> Get (Ctx n)
forall (f :: * -> *) a b c.
Applicative f =>
(a -> b -> c) -> f a -> f b -> f c
liftA2 n -> n -> Ctx n
forall n. n -> n -> Ctx n
Ctx Get n
forall t. Binary t => Get t
get Get n
forall t. Binary t => Get t
get

instance Binary n => Binary (Ty n) where
    put :: Ty n -> Put
put (TCon n
x [Ty n]
y) = Word8 -> Put
forall t. Binary t => t -> Put
put (Word8
0 :: Word8) Put -> Put -> Put
forall (m :: * -> *) a b. Monad m => m a -> m b -> m b
>> n -> Put
forall t. Binary t => t -> Put
put n
x Put -> Put -> Put
forall (m :: * -> *) a b. Monad m => m a -> m b -> m b
>> [Ty n] -> Put
forall t. Binary t => t -> Put
put [Ty n]
y
    put (TVar n
x [Ty n]
y) = Word8 -> Put
forall t. Binary t => t -> Put
put (Word8
1 :: Word8) Put -> Put -> Put
forall (m :: * -> *) a b. Monad m => m a -> m b -> m b
>> n -> Put
forall t. Binary t => t -> Put
put n
x Put -> Put -> Put
forall (m :: * -> *) a b. Monad m => m a -> m b -> m b
>> [Ty n] -> Put
forall t. Binary t => t -> Put
put [Ty n]
y
    get :: Get (Ty n)
get = do Word8
i :: Word8 <- Get Word8
forall t. Binary t => Get t
get; (n -> [Ty n] -> Ty n) -> Get n -> Get [Ty n] -> Get (Ty n)
forall (f :: * -> *) a b c.
Applicative f =>
(a -> b -> c) -> f a -> f b -> f c
liftA2 (case Word8
i of Word8
0 -> n -> [Ty n] -> Ty n
forall n. n -> [Ty n] -> Ty n
TCon; Word8
1 -> n -> [Ty n] -> Ty n
forall n. n -> [Ty n] -> Ty n
TVar) Get n
forall t. Binary t => Get t
get Get [Ty n]
forall t. Binary t => Get t
get

prettySig :: Sig String -> String
prettySig :: Sig String -> String
prettySig Sig{[Ty String]
[Ctx String]
sigTy :: [Ty String]
sigCtx :: [Ctx String]
sigTy :: forall n. Sig n -> [Ty n]
sigCtx :: forall n. Sig n -> [Ctx n]
..} =
        (if String -> Int
forall (t :: * -> *) a. Foldable t => t a -> Int
length String
ctx Int -> Int -> Bool
forall a. Ord a => a -> a -> Bool
> Int
1 then String
"(" String -> ShowS
forall a. [a] -> [a] -> [a]
++ String
ctx String -> ShowS
forall a. [a] -> [a] -> [a]
++ String
") => "
         else if String -> Bool
forall (t :: * -> *) a. Foldable t => t a -> Bool
null String
ctx then String
"" else String
ctx String -> ShowS
forall a. [a] -> [a] -> [a]
++ String
" => ") String -> ShowS
forall a. [a] -> [a] -> [a]
++
        String -> [String] -> String
forall a. [a] -> [[a]] -> [a]
intercalate String
" -> " ((Ty String -> String) -> [Ty String] -> [String]
forall a b. (a -> b) -> [a] -> [b]
map Ty String -> String
f [Ty String]
sigTy)
    where
        ctx :: String
ctx = String -> [String] -> String
forall a. [a] -> [[a]] -> [a]
intercalate String
", " [String
a String -> ShowS
forall a. [a] -> [a] -> [a]
++ String
" " String -> ShowS
forall a. [a] -> [a] -> [a]
++ String
b | Ctx String
a String
b <- [Ctx String]
sigCtx]

        f :: Ty String -> String
f (TVar String
x [Ty String]
xs) = Ty String -> String
f (Ty String -> String) -> Ty String -> String
forall a b. (a -> b) -> a -> b
$ String -> [Ty String] -> Ty String
forall n. n -> [Ty n] -> Ty n
TCon String
x [Ty String]
xs
        f (TCon String
x []) = String
x
        f (TCon String
x [Ty String]
xs) = String
"(" String -> ShowS
forall a. [a] -> [a] -> [a]
++ [String] -> String
unwords (String
x String -> [String] -> [String]
forall a. a -> [a] -> [a]
: (Ty String -> String) -> [Ty String] -> [String]
forall a b. (a -> b) -> [a] -> [b]
map Ty String -> String
f [Ty String]
xs) String -> ShowS
forall a. [a] -> [a] -> [a]
++ String
")"


---------------------------------------------------------------------
-- ITEMS

data Item
    = IPackage PkgName
    | IModule ModName
    | IName Str
    | ISignature (Sig IString)
    | IAlias Str [IString] (Sig IString)
    | IInstance (Sig IString)
      deriving (Int -> Item -> ShowS
[Item] -> ShowS
Item -> String
(Int -> Item -> ShowS)
-> (Item -> String) -> ([Item] -> ShowS) -> Show Item
forall a.
(Int -> a -> ShowS) -> (a -> String) -> ([a] -> ShowS) -> Show a
showList :: [Item] -> ShowS
$cshowList :: [Item] -> ShowS
show :: Item -> String
$cshow :: Item -> String
showsPrec :: Int -> Item -> ShowS
$cshowsPrec :: Int -> Item -> ShowS
Show,Item -> Item -> Bool
(Item -> Item -> Bool) -> (Item -> Item -> Bool) -> Eq Item
forall a. (a -> a -> Bool) -> (a -> a -> Bool) -> Eq a
/= :: Item -> Item -> Bool
$c/= :: Item -> Item -> Bool
== :: Item -> Item -> Bool
$c== :: Item -> Item -> Bool
Eq,Eq Item
Eq Item
-> (Item -> Item -> Ordering)
-> (Item -> Item -> Bool)
-> (Item -> Item -> Bool)
-> (Item -> Item -> Bool)
-> (Item -> Item -> Bool)
-> (Item -> Item -> Item)
-> (Item -> Item -> Item)
-> Ord Item
Item -> Item -> Bool
Item -> Item -> Ordering
Item -> Item -> Item
forall a.
Eq a
-> (a -> a -> Ordering)
-> (a -> a -> Bool)
-> (a -> a -> Bool)
-> (a -> a -> Bool)
-> (a -> a -> Bool)
-> (a -> a -> a)
-> (a -> a -> a)
-> Ord a
min :: Item -> Item -> Item
$cmin :: Item -> Item -> Item
max :: Item -> Item -> Item
$cmax :: Item -> Item -> Item
>= :: Item -> Item -> Bool
$c>= :: Item -> Item -> Bool
> :: Item -> Item -> Bool
$c> :: Item -> Item -> Bool
<= :: Item -> Item -> Bool
$c<= :: Item -> Item -> Bool
< :: Item -> Item -> Bool
$c< :: Item -> Item -> Bool
compare :: Item -> Item -> Ordering
$ccompare :: Item -> Item -> Ordering
$cp1Ord :: Eq Item
Ord,Typeable,Typeable Item
DataType
Constr
Typeable Item
-> (forall (c :: * -> *).
    (forall d b. Data d => c (d -> b) -> d -> c b)
    -> (forall g. g -> c g) -> Item -> c Item)
-> (forall (c :: * -> *).
    (forall b r. Data b => c (b -> r) -> c r)
    -> (forall r. r -> c r) -> Constr -> c Item)
-> (Item -> Constr)
-> (Item -> DataType)
-> (forall (t :: * -> *) (c :: * -> *).
    Typeable t =>
    (forall d. Data d => c (t d)) -> Maybe (c Item))
-> (forall (t :: * -> * -> *) (c :: * -> *).
    Typeable t =>
    (forall d e. (Data d, Data e) => c (t d e)) -> Maybe (c Item))
-> ((forall b. Data b => b -> b) -> Item -> Item)
-> (forall r r'.
    (r -> r' -> r) -> r -> (forall d. Data d => d -> r') -> Item -> r)
-> (forall r r'.
    (r' -> r -> r) -> r -> (forall d. Data d => d -> r') -> Item -> r)
-> (forall u. (forall d. Data d => d -> u) -> Item -> [u])
-> (forall u. Int -> (forall d. Data d => d -> u) -> Item -> u)
-> (forall (m :: * -> *).
    Monad m =>
    (forall d. Data d => d -> m d) -> Item -> m Item)
-> (forall (m :: * -> *).
    MonadPlus m =>
    (forall d. Data d => d -> m d) -> Item -> m Item)
-> (forall (m :: * -> *).
    MonadPlus m =>
    (forall d. Data d => d -> m d) -> Item -> m Item)
-> Data Item
Item -> DataType
Item -> Constr
(forall b. Data b => b -> b) -> Item -> Item
(forall d b. Data d => c (d -> b) -> d -> c b)
-> (forall g. g -> c g) -> Item -> c Item
(forall b r. Data b => c (b -> r) -> c r)
-> (forall r. r -> c r) -> Constr -> c Item
forall a.
Typeable a
-> (forall (c :: * -> *).
    (forall d b. Data d => c (d -> b) -> d -> c b)
    -> (forall g. g -> c g) -> a -> c a)
-> (forall (c :: * -> *).
    (forall b r. Data b => c (b -> r) -> c r)
    -> (forall r. r -> c r) -> Constr -> c a)
-> (a -> Constr)
-> (a -> DataType)
-> (forall (t :: * -> *) (c :: * -> *).
    Typeable t =>
    (forall d. Data d => c (t d)) -> Maybe (c a))
-> (forall (t :: * -> * -> *) (c :: * -> *).
    Typeable t =>
    (forall d e. (Data d, Data e) => c (t d e)) -> Maybe (c a))
-> ((forall b. Data b => b -> b) -> a -> a)
-> (forall r r'.
    (r -> r' -> r) -> r -> (forall d. Data d => d -> r') -> a -> r)
-> (forall r r'.
    (r' -> r -> r) -> r -> (forall d. Data d => d -> r') -> a -> r)
-> (forall u. (forall d. Data d => d -> u) -> a -> [u])
-> (forall u. Int -> (forall d. Data d => d -> u) -> a -> u)
-> (forall (m :: * -> *).
    Monad m =>
    (forall d. Data d => d -> m d) -> a -> m a)
-> (forall (m :: * -> *).
    MonadPlus m =>
    (forall d. Data d => d -> m d) -> a -> m a)
-> (forall (m :: * -> *).
    MonadPlus m =>
    (forall d. Data d => d -> m d) -> a -> m a)
-> Data a
forall u. Int -> (forall d. Data d => d -> u) -> Item -> u
forall u. (forall d. Data d => d -> u) -> Item -> [u]
forall r r'.
(r -> r' -> r) -> r -> (forall d. Data d => d -> r') -> Item -> r
forall r r'.
(r' -> r -> r) -> r -> (forall d. Data d => d -> r') -> Item -> r
forall (m :: * -> *).
Monad m =>
(forall d. Data d => d -> m d) -> Item -> m Item
forall (m :: * -> *).
MonadPlus m =>
(forall d. Data d => d -> m d) -> Item -> m Item
forall (c :: * -> *).
(forall b r. Data b => c (b -> r) -> c r)
-> (forall r. r -> c r) -> Constr -> c Item
forall (c :: * -> *).
(forall d b. Data d => c (d -> b) -> d -> c b)
-> (forall g. g -> c g) -> Item -> c Item
forall (t :: * -> *) (c :: * -> *).
Typeable t =>
(forall d. Data d => c (t d)) -> Maybe (c Item)
forall (t :: * -> * -> *) (c :: * -> *).
Typeable t =>
(forall d e. (Data d, Data e) => c (t d e)) -> Maybe (c Item)
$cIInstance :: Constr
$cIAlias :: Constr
$cISignature :: Constr
$cIName :: Constr
$cIModule :: Constr
$cIPackage :: Constr
$tItem :: DataType
gmapMo :: (forall d. Data d => d -> m d) -> Item -> m Item
$cgmapMo :: forall (m :: * -> *).
MonadPlus m =>
(forall d. Data d => d -> m d) -> Item -> m Item
gmapMp :: (forall d. Data d => d -> m d) -> Item -> m Item
$cgmapMp :: forall (m :: * -> *).
MonadPlus m =>
(forall d. Data d => d -> m d) -> Item -> m Item
gmapM :: (forall d. Data d => d -> m d) -> Item -> m Item
$cgmapM :: forall (m :: * -> *).
Monad m =>
(forall d. Data d => d -> m d) -> Item -> m Item
gmapQi :: Int -> (forall d. Data d => d -> u) -> Item -> u
$cgmapQi :: forall u. Int -> (forall d. Data d => d -> u) -> Item -> u
gmapQ :: (forall d. Data d => d -> u) -> Item -> [u]
$cgmapQ :: forall u. (forall d. Data d => d -> u) -> Item -> [u]
gmapQr :: (r' -> r -> r) -> r -> (forall d. Data d => d -> r') -> Item -> r
$cgmapQr :: forall r r'.
(r' -> r -> r) -> r -> (forall d. Data d => d -> r') -> Item -> r
gmapQl :: (r -> r' -> r) -> r -> (forall d. Data d => d -> r') -> Item -> r
$cgmapQl :: forall r r'.
(r -> r' -> r) -> r -> (forall d. Data d => d -> r') -> Item -> r
gmapT :: (forall b. Data b => b -> b) -> Item -> Item
$cgmapT :: (forall b. Data b => b -> b) -> Item -> Item
dataCast2 :: (forall d e. (Data d, Data e) => c (t d e)) -> Maybe (c Item)
$cdataCast2 :: forall (t :: * -> * -> *) (c :: * -> *).
Typeable t =>
(forall d e. (Data d, Data e) => c (t d e)) -> Maybe (c Item)
dataCast1 :: (forall d. Data d => c (t d)) -> Maybe (c Item)
$cdataCast1 :: forall (t :: * -> *) (c :: * -> *).
Typeable t =>
(forall d. Data d => c (t d)) -> Maybe (c Item)
dataTypeOf :: Item -> DataType
$cdataTypeOf :: Item -> DataType
toConstr :: Item -> Constr
$ctoConstr :: Item -> Constr
gunfold :: (forall b r. Data b => c (b -> r) -> c r)
-> (forall r. r -> c r) -> Constr -> c Item
$cgunfold :: forall (c :: * -> *).
(forall b r. Data b => c (b -> r) -> c r)
-> (forall r. r -> c r) -> Constr -> c Item
gfoldl :: (forall d b. Data d => c (d -> b) -> d -> c b)
-> (forall g. g -> c g) -> Item -> c Item
$cgfoldl :: forall (c :: * -> *).
(forall d b. Data d => c (d -> b) -> d -> c b)
-> (forall g. g -> c g) -> Item -> c Item
$cp1Data :: Typeable Item
Data)

instance NFData Item where
    rnf :: Item -> ()
rnf (IPackage PkgName
x) = PkgName -> ()
forall a. NFData a => a -> ()
rnf PkgName
x
    rnf (IModule PkgName
x) = PkgName -> ()
forall a. NFData a => a -> ()
rnf PkgName
x
    rnf (IName PkgName
x) = PkgName
x PkgName -> () -> ()
`seq` ()
    rnf (ISignature Sig IString
x) = Sig IString -> ()
forall a. NFData a => a -> ()
rnf Sig IString
x
    rnf (IAlias PkgName
a [IString]
b Sig IString
c) = (PkgName, [IString], Sig IString) -> ()
forall a. NFData a => a -> ()
rnf (PkgName
a,[IString]
b,Sig IString
c)
    rnf (IInstance Sig IString
a) = Sig IString -> ()
forall a. NFData a => a -> ()
rnf Sig IString
a

itemName :: Item -> Maybe Str
itemName :: Item -> Maybe PkgName
itemName (IPackage PkgName
x) = PkgName -> Maybe PkgName
forall a. a -> Maybe a
Just PkgName
x
itemName (IModule PkgName
x) = PkgName -> Maybe PkgName
forall a. a -> Maybe a
Just PkgName
x
itemName (IName PkgName
x) = PkgName -> Maybe PkgName
forall a. a -> Maybe a
Just PkgName
x
itemName (ISignature Sig IString
_) = Maybe PkgName
forall a. Maybe a
Nothing
itemName (IAlias PkgName
x [IString]
_ Sig IString
_) = PkgName -> Maybe PkgName
forall a. a -> Maybe a
Just PkgName
x
itemName (IInstance Sig IString
_) = Maybe PkgName
forall a. Maybe a
Nothing


---------------------------------------------------------------------
-- DATABASE

newtype TargetId = TargetId Word32 deriving (TargetId -> TargetId -> Bool
(TargetId -> TargetId -> Bool)
-> (TargetId -> TargetId -> Bool) -> Eq TargetId
forall a. (a -> a -> Bool) -> (a -> a -> Bool) -> Eq a
/= :: TargetId -> TargetId -> Bool
$c/= :: TargetId -> TargetId -> Bool
== :: TargetId -> TargetId -> Bool
$c== :: TargetId -> TargetId -> Bool
Eq,Eq TargetId
Eq TargetId
-> (TargetId -> TargetId -> Ordering)
-> (TargetId -> TargetId -> Bool)
-> (TargetId -> TargetId -> Bool)
-> (TargetId -> TargetId -> Bool)
-> (TargetId -> TargetId -> Bool)
-> (TargetId -> TargetId -> TargetId)
-> (TargetId -> TargetId -> TargetId)
-> Ord TargetId
TargetId -> TargetId -> Bool
TargetId -> TargetId -> Ordering
TargetId -> TargetId -> TargetId
forall a.
Eq a
-> (a -> a -> Ordering)
-> (a -> a -> Bool)
-> (a -> a -> Bool)
-> (a -> a -> Bool)
-> (a -> a -> Bool)
-> (a -> a -> a)
-> (a -> a -> a)
-> Ord a
min :: TargetId -> TargetId -> TargetId
$cmin :: TargetId -> TargetId -> TargetId
max :: TargetId -> TargetId -> TargetId
$cmax :: TargetId -> TargetId -> TargetId
>= :: TargetId -> TargetId -> Bool
$c>= :: TargetId -> TargetId -> Bool
> :: TargetId -> TargetId -> Bool
$c> :: TargetId -> TargetId -> Bool
<= :: TargetId -> TargetId -> Bool
$c<= :: TargetId -> TargetId -> Bool
< :: TargetId -> TargetId -> Bool
$c< :: TargetId -> TargetId -> Bool
compare :: TargetId -> TargetId -> Ordering
$ccompare :: TargetId -> TargetId -> Ordering
$cp1Ord :: Eq TargetId
Ord,Ptr b -> Int -> IO TargetId
Ptr b -> Int -> TargetId -> IO ()
Ptr TargetId -> IO TargetId
Ptr TargetId -> Int -> IO TargetId
Ptr TargetId -> Int -> TargetId -> IO ()
Ptr TargetId -> TargetId -> IO ()
TargetId -> Int
(TargetId -> Int)
-> (TargetId -> Int)
-> (Ptr TargetId -> Int -> IO TargetId)
-> (Ptr TargetId -> Int -> TargetId -> IO ())
-> (forall b. Ptr b -> Int -> IO TargetId)
-> (forall b. Ptr b -> Int -> TargetId -> IO ())
-> (Ptr TargetId -> IO TargetId)
-> (Ptr TargetId -> TargetId -> IO ())
-> Storable TargetId
forall b. Ptr b -> Int -> IO TargetId
forall b. Ptr b -> Int -> TargetId -> IO ()
forall a.
(a -> Int)
-> (a -> Int)
-> (Ptr a -> Int -> IO a)
-> (Ptr a -> Int -> a -> IO ())
-> (forall b. Ptr b -> Int -> IO a)
-> (forall b. Ptr b -> Int -> a -> IO ())
-> (Ptr a -> IO a)
-> (Ptr a -> a -> IO ())
-> Storable a
poke :: Ptr TargetId -> TargetId -> IO ()
$cpoke :: Ptr TargetId -> TargetId -> IO ()
peek :: Ptr TargetId -> IO TargetId
$cpeek :: Ptr TargetId -> IO TargetId
pokeByteOff :: Ptr b -> Int -> TargetId -> IO ()
$cpokeByteOff :: forall b. Ptr b -> Int -> TargetId -> IO ()
peekByteOff :: Ptr b -> Int -> IO TargetId
$cpeekByteOff :: forall b. Ptr b -> Int -> IO TargetId
pokeElemOff :: Ptr TargetId -> Int -> TargetId -> IO ()
$cpokeElemOff :: Ptr TargetId -> Int -> TargetId -> IO ()
peekElemOff :: Ptr TargetId -> Int -> IO TargetId
$cpeekElemOff :: Ptr TargetId -> Int -> IO TargetId
alignment :: TargetId -> Int
$calignment :: TargetId -> Int
sizeOf :: TargetId -> Int
$csizeOf :: TargetId -> Int
Storable,TargetId -> ()
(TargetId -> ()) -> NFData TargetId
forall a. (a -> ()) -> NFData a
rnf :: TargetId -> ()
$crnf :: TargetId -> ()
NFData,Ord TargetId
Ord TargetId
-> ((TargetId, TargetId) -> [TargetId])
-> ((TargetId, TargetId) -> TargetId -> Int)
-> ((TargetId, TargetId) -> TargetId -> Int)
-> ((TargetId, TargetId) -> TargetId -> Bool)
-> ((TargetId, TargetId) -> Int)
-> ((TargetId, TargetId) -> Int)
-> Ix TargetId
(TargetId, TargetId) -> Int
(TargetId, TargetId) -> [TargetId]
(TargetId, TargetId) -> TargetId -> Bool
(TargetId, TargetId) -> TargetId -> Int
forall a.
Ord a
-> ((a, a) -> [a])
-> ((a, a) -> a -> Int)
-> ((a, a) -> a -> Int)
-> ((a, a) -> a -> Bool)
-> ((a, a) -> Int)
-> ((a, a) -> Int)
-> Ix a
unsafeRangeSize :: (TargetId, TargetId) -> Int
$cunsafeRangeSize :: (TargetId, TargetId) -> Int
rangeSize :: (TargetId, TargetId) -> Int
$crangeSize :: (TargetId, TargetId) -> Int
inRange :: (TargetId, TargetId) -> TargetId -> Bool
$cinRange :: (TargetId, TargetId) -> TargetId -> Bool
unsafeIndex :: (TargetId, TargetId) -> TargetId -> Int
$cunsafeIndex :: (TargetId, TargetId) -> TargetId -> Int
index :: (TargetId, TargetId) -> TargetId -> Int
$cindex :: (TargetId, TargetId) -> TargetId -> Int
range :: (TargetId, TargetId) -> [TargetId]
$crange :: (TargetId, TargetId) -> [TargetId]
$cp1Ix :: Ord TargetId
Ix,Typeable)

instance Show TargetId where
    show :: TargetId -> String
show (TargetId Word32
x) = Word32 -> ShowS
forall a. (Integral a, Show a) => a -> ShowS
showHex Word32
x String
""

-- | A location of documentation.
data Target = Target
    {Target -> String
targetURL :: URL -- ^ URL where this thing is located
    ,Target -> Maybe (String, String)
targetPackage :: Maybe (String, URL) -- ^ Name and URL of the package it is in (Nothing if it is a package)
    ,Target -> Maybe (String, String)
targetModule :: Maybe (String, URL) -- ^ Name and URL of the module it is in (Nothing if it is a package or module)
    ,Target -> String
targetType :: String -- ^ One of package, module or empty string
    ,Target -> String
targetItem :: String -- ^ HTML span of the item, using @\<s0\>@ for the name and @\<s1\>@ onwards for arguments
    ,Target -> String
targetDocs :: String -- ^ HTML documentation to show, a sequence of block level elements
    } deriving (Int -> Target -> ShowS
[Target] -> ShowS
Target -> String
(Int -> Target -> ShowS)
-> (Target -> String) -> ([Target] -> ShowS) -> Show Target
forall a.
(Int -> a -> ShowS) -> (a -> String) -> ([a] -> ShowS) -> Show a
showList :: [Target] -> ShowS
$cshowList :: [Target] -> ShowS
show :: Target -> String
$cshow :: Target -> String
showsPrec :: Int -> Target -> ShowS
$cshowsPrec :: Int -> Target -> ShowS
Show,Target -> Target -> Bool
(Target -> Target -> Bool)
-> (Target -> Target -> Bool) -> Eq Target
forall a. (a -> a -> Bool) -> (a -> a -> Bool) -> Eq a
/= :: Target -> Target -> Bool
$c/= :: Target -> Target -> Bool
== :: Target -> Target -> Bool
$c== :: Target -> Target -> Bool
Eq,Eq Target
Eq Target
-> (Target -> Target -> Ordering)
-> (Target -> Target -> Bool)
-> (Target -> Target -> Bool)
-> (Target -> Target -> Bool)
-> (Target -> Target -> Bool)
-> (Target -> Target -> Target)
-> (Target -> Target -> Target)
-> Ord Target
Target -> Target -> Bool
Target -> Target -> Ordering
Target -> Target -> Target
forall a.
Eq a
-> (a -> a -> Ordering)
-> (a -> a -> Bool)
-> (a -> a -> Bool)
-> (a -> a -> Bool)
-> (a -> a -> Bool)
-> (a -> a -> a)
-> (a -> a -> a)
-> Ord a
min :: Target -> Target -> Target
$cmin :: Target -> Target -> Target
max :: Target -> Target -> Target
$cmax :: Target -> Target -> Target
>= :: Target -> Target -> Bool
$c>= :: Target -> Target -> Bool
> :: Target -> Target -> Bool
$c> :: Target -> Target -> Bool
<= :: Target -> Target -> Bool
$c<= :: Target -> Target -> Bool
< :: Target -> Target -> Bool
$c< :: Target -> Target -> Bool
compare :: Target -> Target -> Ordering
$ccompare :: Target -> Target -> Ordering
$cp1Ord :: Eq Target
Ord)

instance NFData Target where
    rnf :: Target -> ()
rnf (Target String
a Maybe (String, String)
b Maybe (String, String)
c String
d String
e String
f) = String -> ()
forall a. NFData a => a -> ()
rnf String
a () -> () -> ()
`seq` Maybe (String, String) -> ()
forall a. NFData a => a -> ()
rnf Maybe (String, String)
b () -> () -> ()
`seq` Maybe (String, String) -> ()
forall a. NFData a => a -> ()
rnf Maybe (String, String)
c () -> () -> ()
`seq` String -> ()
forall a. NFData a => a -> ()
rnf String
d () -> () -> ()
`seq` String -> ()
forall a. NFData a => a -> ()
rnf String
e () -> () -> ()
`seq` String -> ()
forall a. NFData a => a -> ()
rnf String
f

instance ToJSON Target where
    toJSON :: Target -> Value
toJSON (Target String
a Maybe (String, String)
b Maybe (String, String)
c String
d String
e String
f) = [Pair] -> Value
object [
      (Text
"url" :: T.Text, String -> Value
forall a. ToJSON a => a -> Value
toJSON String
a),
      (Text
"package" :: T.Text, Maybe (String, String) -> Value
forall a a. (ToJSON a, ToJSON a) => Maybe (a, a) -> Value
maybeNamedURL Maybe (String, String)
b),
      (Text
"module" :: T.Text, Maybe (String, String) -> Value
forall a a. (ToJSON a, ToJSON a) => Maybe (a, a) -> Value
maybeNamedURL Maybe (String, String)
c),
      (Text
"type" :: T.Text, String -> Value
forall a. ToJSON a => a -> Value
toJSON String
d),
      (Text
"item" :: T.Text, String -> Value
forall a. ToJSON a => a -> Value
toJSON String
e),
      (Text
"docs" :: T.Text, String -> Value
forall a. ToJSON a => a -> Value
toJSON String
f)
      ]
      where
        maybeNamedURL :: Maybe (a, a) -> Value
maybeNamedURL Maybe (a, a)
m = Value -> ((a, a) -> Value) -> Maybe (a, a) -> Value
forall b a. b -> (a -> b) -> Maybe a -> b
maybe Value
emptyObject (a, a) -> Value
forall a a. (ToJSON a, ToJSON a) => (a, a) -> Value
namedURL Maybe (a, a)
m
        namedURL :: (a, a) -> Value
namedURL (a
name, a
url) = [Pair] -> Value
object [(Text
"name" :: T.Text, a -> Value
forall a. ToJSON a => a -> Value
toJSON a
name), (Text
"url" :: T.Text, a -> Value
forall a. ToJSON a => a -> Value
toJSON a
url)]

instance FromJSON Target where
  parseJSON :: Value -> Parser Target
parseJSON = String -> (Object -> Parser Target) -> Value -> Parser Target
forall a. String -> (Object -> Parser a) -> Value -> Parser a
withObject String
"Target" ((Object -> Parser Target) -> Value -> Parser Target)
-> (Object -> Parser Target) -> Value -> Parser Target
forall a b. (a -> b) -> a -> b
$ \Object
o ->
    String
-> Maybe (String, String)
-> Maybe (String, String)
-> String
-> String
-> String
-> Target
Target (String
 -> Maybe (String, String)
 -> Maybe (String, String)
 -> String
 -> String
 -> String
 -> Target)
-> Parser String
-> Parser
     (Maybe (String, String)
      -> Maybe (String, String) -> String -> String -> String -> Target)
forall (f :: * -> *) a b. Functor f => (a -> b) -> f a -> f b
<$> Object
o Object -> Text -> Parser String
forall a. FromJSON a => Object -> Text -> Parser a
.: (Text
"url" :: T.Text)
           Parser
  (Maybe (String, String)
   -> Maybe (String, String) -> String -> String -> String -> Target)
-> Parser (Maybe (String, String))
-> Parser
     (Maybe (String, String) -> String -> String -> String -> Target)
forall (f :: * -> *) a b. Applicative f => f (a -> b) -> f a -> f b
<*> Object
o Object -> Text -> Parser (Maybe (String, String))
forall a b.
(FromJSON a, FromJSON b) =>
Object -> Text -> Parser (Maybe (a, b))
`namedUrl` (Text
"package" :: T.Text)
           Parser
  (Maybe (String, String) -> String -> String -> String -> Target)
-> Parser (Maybe (String, String))
-> Parser (String -> String -> String -> Target)
forall (f :: * -> *) a b. Applicative f => f (a -> b) -> f a -> f b
<*> Object
o Object -> Text -> Parser (Maybe (String, String))
forall a b.
(FromJSON a, FromJSON b) =>
Object -> Text -> Parser (Maybe (a, b))
`namedUrl` (Text
"module" :: T.Text)
           Parser (String -> String -> String -> Target)
-> Parser String -> Parser (String -> String -> Target)
forall (f :: * -> *) a b. Applicative f => f (a -> b) -> f a -> f b
<*> Object
o Object -> Text -> Parser String
forall a. FromJSON a => Object -> Text -> Parser a
.: (Text
"type" :: T.Text)
           Parser (String -> String -> Target)
-> Parser String -> Parser (String -> Target)
forall (f :: * -> *) a b. Applicative f => f (a -> b) -> f a -> f b
<*> Object
o Object -> Text -> Parser String
forall a. FromJSON a => Object -> Text -> Parser a
.: (Text
"item" :: T.Text)
           Parser (String -> Target) -> Parser String -> Parser Target
forall (f :: * -> *) a b. Applicative f => f (a -> b) -> f a -> f b
<*> Object
o Object -> Text -> Parser String
forall a. FromJSON a => Object -> Text -> Parser a
.: (Text
"docs" :: T.Text)
    where namedUrl :: Object -> Text -> Parser (Maybe (a, b))
namedUrl Object
o' Text
n = do
             Object
mObj <- Object
o' Object -> Text -> Parser Object
forall a. FromJSON a => Object -> Text -> Parser a
.: Text
n
             if Object -> Bool
forall (t :: * -> *) a. Foldable t => t a -> Bool
null Object
mObj then Maybe (a, b) -> Parser (Maybe (a, b))
forall (f :: * -> *) a. Applicative f => a -> f a
pure Maybe (a, b)
forall a. Maybe a
Nothing
                        else do
                           a
pkName <- Object
mObj Object -> Text -> Parser a
forall a. FromJSON a => Object -> Text -> Parser a
.: (Text
"name" :: T.Text)
                           b
pkUrl  <- Object
mObj Object -> Text -> Parser b
forall a. FromJSON a => Object -> Text -> Parser a
.: (Text
"url" :: T.Text)
                           Maybe (a, b) -> Parser (Maybe (a, b))
forall (f :: * -> *) a. Applicative f => a -> f a
pure (Maybe (a, b) -> Parser (Maybe (a, b)))
-> Maybe (a, b) -> Parser (Maybe (a, b))
forall a b. (a -> b) -> a -> b
$ (a, b) -> Maybe (a, b)
forall a. a -> Maybe a
Just (a
pkName, b
pkUrl)

instance Arbitrary Target where
  arbitrary :: Gen Target
arbitrary = String
-> Maybe (String, String)
-> Maybe (String, String)
-> String
-> String
-> String
-> Target
Target (String
 -> Maybe (String, String)
 -> Maybe (String, String)
 -> String
 -> String
 -> String
 -> Target)
-> Gen String
-> Gen
     (Maybe (String, String)
      -> Maybe (String, String) -> String -> String -> String -> Target)
forall (f :: * -> *) a b. Functor f => (a -> b) -> f a -> f b
<$> Gen String
a
                     Gen
  (Maybe (String, String)
   -> Maybe (String, String) -> String -> String -> String -> Target)
-> Gen (Maybe (String, String))
-> Gen
     (Maybe (String, String) -> String -> String -> String -> Target)
forall (f :: * -> *) a b. Applicative f => f (a -> b) -> f a -> f b
<*> Gen (Maybe (String, String))
mNurl
                     Gen
  (Maybe (String, String) -> String -> String -> String -> Target)
-> Gen (Maybe (String, String))
-> Gen (String -> String -> String -> Target)
forall (f :: * -> *) a b. Applicative f => f (a -> b) -> f a -> f b
<*> Gen (Maybe (String, String))
mNurl
                     Gen (String -> String -> String -> Target)
-> Gen String -> Gen (String -> String -> Target)
forall (f :: * -> *) a b. Applicative f => f (a -> b) -> f a -> f b
<*> Gen String
a
                     Gen (String -> String -> Target)
-> Gen String -> Gen (String -> Target)
forall (f :: * -> *) a b. Applicative f => f (a -> b) -> f a -> f b
<*> Gen String
a
                     Gen (String -> Target) -> Gen String -> Gen Target
forall (f :: * -> *) a b. Applicative f => f (a -> b) -> f a -> f b
<*> Gen String
a
    where a :: Gen String
a = Gen String
forall a. Arbitrary a => Gen a
arbitrary
          mNurl :: Gen (Maybe (String, String))
mNurl = do
            [Gen (Maybe (String, String))] -> Gen (Maybe (String, String))
forall a. [Gen a] -> Gen a
oneof [Maybe (String, String) -> Gen (Maybe (String, String))
forall (f :: * -> *) a. Applicative f => a -> f a
pure Maybe (String, String)
forall a. Maybe a
Nothing
                 , (String, String) -> Maybe (String, String)
forall a. a -> Maybe a
Just ((String, String) -> Maybe (String, String))
-> Gen (String, String) -> Gen (Maybe (String, String))
forall (f :: * -> *) a b. Functor f => (a -> b) -> f a -> f b
<$> (String -> String -> (String, String))
-> Gen String -> Gen String -> Gen (String, String)
forall (f :: * -> *) a b c.
Applicative f =>
(a -> b -> c) -> f a -> f b -> f c
liftA2 (,) Gen String
a Gen String
a]

targetExpandURL :: Target -> Target
targetExpandURL :: Target -> Target
targetExpandURL t :: Target
t@Target{String
Maybe (String, String)
targetDocs :: String
targetItem :: String
targetType :: String
targetModule :: Maybe (String, String)
targetPackage :: Maybe (String, String)
targetURL :: String
targetDocs :: Target -> String
targetItem :: Target -> String
targetType :: Target -> String
targetModule :: Target -> Maybe (String, String)
targetPackage :: Target -> Maybe (String, String)
targetURL :: Target -> String
..} = Target
t{targetURL :: String
targetURL = String
url, targetModule :: Maybe (String, String)
targetModule = ShowS -> (String, String) -> (String, String)
forall b b' a. (b -> b') -> (a, b) -> (a, b')
second (String -> ShowS
forall a b. a -> b -> a
const String
mod) ((String, String) -> (String, String))
-> Maybe (String, String) -> Maybe (String, String)
forall (f :: * -> *) a b. Functor f => (a -> b) -> f a -> f b
<$> Maybe (String, String)
targetModule}
    where
        pkg :: String
pkg = String
-> ((String, String) -> String) -> Maybe (String, String) -> String
forall b a. b -> (a -> b) -> Maybe a -> b
maybe String
"" (String, String) -> String
forall a b. (a, b) -> b
snd Maybe (String, String)
targetPackage
        mod :: String
mod = String
-> ((String, String) -> String) -> Maybe (String, String) -> String
forall b a. b -> (a -> b) -> Maybe a -> b
maybe String
pkg (String -> ShowS
plus String
pkg ShowS -> ((String, String) -> String) -> (String, String) -> String
forall b c a. (b -> c) -> (a -> b) -> a -> c
. (String, String) -> String
forall a b. (a, b) -> b
snd) Maybe (String, String)
targetModule
        url :: String
url = String -> ShowS
plus String
mod String
targetURL

        plus :: String -> ShowS
plus String
a String
b | String
b String -> String -> Bool
forall a. Eq a => a -> a -> Bool
== String
"" = String
""
                 | Char
':':String
_ <- (Char -> Bool) -> ShowS
forall a. (a -> Bool) -> [a] -> [a]
dropWhile Char -> Bool
isAsciiLower String
b = String
b -- match http: etc
                 | Bool
otherwise = String
a String -> ShowS
forall a. [a] -> [a] -> [a]
++ String
b

unHTMLTarget :: Target -> Target
unHTMLTarget :: Target -> Target
unHTMLTarget t :: Target
t@Target {String
Maybe (String, String)
targetDocs :: String
targetItem :: String
targetType :: String
targetModule :: Maybe (String, String)
targetPackage :: Maybe (String, String)
targetURL :: String
targetDocs :: Target -> String
targetItem :: Target -> String
targetType :: Target -> String
targetModule :: Target -> Maybe (String, String)
targetPackage :: Target -> Maybe (String, String)
targetURL :: Target -> String
..} = Target
t{targetItem :: String
targetItem=ShowS
unHTML String
targetItem, targetDocs :: String
targetDocs=ShowS
unHTML String
targetDocs}

splitIPackage, splitIModule :: [(a, Item)] -> [(Str, [(a, Item)])]
splitIPackage :: [(a, Item)] -> [(PkgName, [(a, Item)])]
splitIPackage = ((a, Item) -> Maybe PkgName)
-> [(a, Item)] -> [(PkgName, [(a, Item)])]
forall a. (a -> Maybe PkgName) -> [a] -> [(PkgName, [a])]
splitUsing (((a, Item) -> Maybe PkgName)
 -> [(a, Item)] -> [(PkgName, [(a, Item)])])
-> ((a, Item) -> Maybe PkgName)
-> [(a, Item)]
-> [(PkgName, [(a, Item)])]
forall a b. (a -> b) -> a -> b
$ \(a, Item)
x -> case (a, Item) -> Item
forall a b. (a, b) -> b
snd (a, Item)
x of IPackage PkgName
x -> PkgName -> Maybe PkgName
forall a. a -> Maybe a
Just PkgName
x; Item
_ -> Maybe PkgName
forall a. Maybe a
Nothing
splitIModule :: [(a, Item)] -> [(PkgName, [(a, Item)])]
splitIModule = ((a, Item) -> Maybe PkgName)
-> [(a, Item)] -> [(PkgName, [(a, Item)])]
forall a. (a -> Maybe PkgName) -> [a] -> [(PkgName, [a])]
splitUsing (((a, Item) -> Maybe PkgName)
 -> [(a, Item)] -> [(PkgName, [(a, Item)])])
-> ((a, Item) -> Maybe PkgName)
-> [(a, Item)]
-> [(PkgName, [(a, Item)])]
forall a b. (a -> b) -> a -> b
$ \(a, Item)
x -> case (a, Item) -> Item
forall a b. (a, b) -> b
snd (a, Item)
x of IModule PkgName
x -> PkgName -> Maybe PkgName
forall a. a -> Maybe a
Just PkgName
x; Item
_ -> Maybe PkgName
forall a. Maybe a
Nothing

splitUsing :: (a -> Maybe Str) -> [a] -> [(Str, [a])]
splitUsing :: (a -> Maybe PkgName) -> [a] -> [(PkgName, [a])]
splitUsing a -> Maybe PkgName
f = ([a] -> ((PkgName, [a]), [a])) -> [a] -> [(PkgName, [a])]
forall a b. ([a] -> (b, [a])) -> [a] -> [b]
repeatedly (([a] -> ((PkgName, [a]), [a])) -> [a] -> [(PkgName, [a])])
-> ([a] -> ((PkgName, [a]), [a])) -> [a] -> [(PkgName, [a])]
forall a b. (a -> b) -> a -> b
$ \(a
x:[a]
xs) ->
    let ([a]
a,[a]
b) = (a -> Bool) -> [a] -> ([a], [a])
forall a. (a -> Bool) -> [a] -> ([a], [a])
break (Maybe PkgName -> Bool
forall a. Maybe a -> Bool
isJust (Maybe PkgName -> Bool) -> (a -> Maybe PkgName) -> a -> Bool
forall b c a. (b -> c) -> (a -> b) -> a -> c
. a -> Maybe PkgName
f) [a]
xs
    in ((PkgName -> Maybe PkgName -> PkgName
forall a. a -> Maybe a -> a
fromMaybe PkgName
forall a. Monoid a => a
mempty (Maybe PkgName -> PkgName) -> Maybe PkgName -> PkgName
forall a b. (a -> b) -> a -> b
$ a -> Maybe PkgName
f a
x, a
xa -> [a] -> [a]
forall a. a -> [a] -> [a]
:[a]
a), [a]
b)

item_test :: IO ()
item_test :: IO ()
item_test = String -> IO () -> IO ()
testing String
"Input.Item.Target JSON (encode . decode = id) " (IO () -> IO ()) -> IO () -> IO ()
forall a b. (a -> b) -> a -> b
$ do
  (Target -> Bool) -> IO ()
forall prop. Testable prop => prop -> IO ()
quickCheck ((Target -> Bool) -> IO ()) -> (Target -> Bool) -> IO ()
forall a b. (a -> b) -> a -> b
$ \(Target
t :: Target) -> case ByteString -> Either String Target
forall a. FromJSON a => ByteString -> Either String a
J.eitherDecode (ByteString -> Either String Target)
-> ByteString -> Either String Target
forall a b. (a -> b) -> a -> b
$ Target -> ByteString
forall a. ToJSON a => a -> ByteString
J.encode Target
t of
    (Left  String
e ) -> Bool
False
    (Right Target
t') -> Target
t Target -> Target -> Bool
forall a. Eq a => a -> a -> Bool
== Target
t'

---------------------------------------------------------------------
-- HSE CONVERSION

hseToSig :: Type a -> Sig String
hseToSig :: Type a -> Sig String
hseToSig = Type a -> Sig String
forall l. Type l -> Sig String
tyForall
    where
        -- forall at the top is different
        tyForall :: Type l -> Sig String
tyForall (TyParen l
_ Type l
x) = Type l -> Sig String
tyForall Type l
x
        tyForall (TyForall l
_ Maybe [TyVarBind l]
_ Maybe (Context l)
c Type l
t) | Sig [Ctx String]
cs [Ty String]
ts <- Type l -> Sig String
tyForall Type l
t =
            [Ctx String] -> [Ty String] -> Sig String
forall n. [Ctx n] -> [Ty n] -> Sig n
Sig ([Ctx String]
-> (Context l -> [Ctx String]) -> Maybe (Context l) -> [Ctx String]
forall b a. b -> (a -> b) -> Maybe a -> b
maybe [] ((Asst l -> [Ctx String]) -> [Asst l] -> [Ctx String]
forall (t :: * -> *) a b. Foldable t => (a -> [b]) -> t a -> [b]
concatMap Asst l -> [Ctx String]
forall a. Asst a -> [Ctx String]
ctx ([Asst l] -> [Ctx String])
-> (Context l -> [Asst l]) -> Context l -> [Ctx String]
forall b c a. (b -> c) -> (a -> b) -> a -> c
. Context l -> [Asst l]
forall a. Context a -> [Asst a]
fromContext) Maybe (Context l)
c [Ctx String] -> [Ctx String] -> [Ctx String]
forall a. [a] -> [a] -> [a]
++ [Ctx String]
cs) [Ty String]
ts
        tyForall Type l
x = [Ctx String] -> [Ty String] -> Sig String
forall n. [Ctx n] -> [Ty n] -> Sig n
Sig [] ([Ty String] -> Sig String) -> [Ty String] -> Sig String
forall a b. (a -> b) -> a -> b
$ Type l -> [Ty String]
forall l. Type l -> [Ty String]
tyFun Type l
x

        tyFun :: Type l -> [Ty String]
tyFun (TyParen l
_ Type l
x) = Type l -> [Ty String]
tyFun Type l
x
        tyFun (TyFun l
_ Type l
a Type l
b) = Type l -> Ty String
ty Type l
a Ty String -> [Ty String] -> [Ty String]
forall a. a -> [a] -> [a]
: Type l -> [Ty String]
tyFun Type l
b
        tyFun Type l
x = [Type l -> Ty String
ty Type l
x]

        ty :: Type l -> Ty String
ty (TyForall l
_ Maybe [TyVarBind l]
_ Maybe (Context l)
_ Type l
x) = String -> [Ty String] -> Ty String
forall n. n -> [Ty n] -> Ty n
TCon String
"\\/" [Type l -> Ty String
ty Type l
x]
        ty x :: Type l
x@TyFun{} = String -> [Ty String] -> Ty String
forall n. n -> [Ty n] -> Ty n
TCon String
"->" ([Ty String] -> Ty String) -> [Ty String] -> Ty String
forall a b. (a -> b) -> a -> b
$ Type l -> [Ty String]
tyFun Type l
x
        ty (TyTuple l
an Boxed
box [Type l]
ts) = String -> [Ty String] -> Ty String
forall n. n -> [Ty n] -> Ty n
TCon (QName l -> String
forall a. QName a -> String
fromQName (QName l -> String) -> QName l -> String
forall a b. (a -> b) -> a -> b
$ l -> SpecialCon l -> QName l
forall l. l -> SpecialCon l -> QName l
Special l
an (SpecialCon l -> QName l) -> SpecialCon l -> QName l
forall a b. (a -> b) -> a -> b
$ l -> Boxed -> Int -> SpecialCon l
forall l. l -> Boxed -> Int -> SpecialCon l
TupleCon l
an Boxed
box (Int -> SpecialCon l) -> Int -> SpecialCon l
forall a b. (a -> b) -> a -> b
$ [Type l] -> Int
forall (t :: * -> *) a. Foldable t => t a -> Int
length [Type l]
ts Int -> Int -> Int
forall a. Num a => a -> a -> a
- Int
1) ((Type l -> Ty String) -> [Type l] -> [Ty String]
forall a b. (a -> b) -> [a] -> [b]
map Type l -> Ty String
ty [Type l]
ts)
        ty (TyList l
_ Type l
x) = String -> [Ty String] -> Ty String
forall n. n -> [Ty n] -> Ty n
TCon String
"[]" [Type l -> Ty String
ty Type l
x]
        ty (TyParArray l
_ Type l
x) = String -> [Ty String] -> Ty String
forall n. n -> [Ty n] -> Ty n
TCon String
"[::]" [Type l -> Ty String
ty Type l
x]
        ty (TyApp l
_ Type l
x Type l
y) = case Type l -> Ty String
ty Type l
x of
            TCon String
a [Ty String]
b -> String -> [Ty String] -> Ty String
forall n. n -> [Ty n] -> Ty n
TCon String
a ([Ty String]
b [Ty String] -> [Ty String] -> [Ty String]
forall a. [a] -> [a] -> [a]
++ [Type l -> Ty String
ty Type l
y])
            TVar String
a [Ty String]
b -> String -> [Ty String] -> Ty String
forall n. n -> [Ty n] -> Ty n
TVar String
a ([Ty String]
b [Ty String] -> [Ty String] -> [Ty String]
forall a. [a] -> [a] -> [a]
++ [Type l -> Ty String
ty Type l
y])
        ty (TyVar l
_ Name l
x) = String -> [Ty String] -> Ty String
forall n. n -> [Ty n] -> Ty n
TVar (Name l -> String
forall a. Name a -> String
fromName Name l
x) []
        ty (TyCon l
_ QName l
x) = String -> [Ty String] -> Ty String
forall n. n -> [Ty n] -> Ty n
TCon (QName l -> String
forall a. QName a -> String
fromQName QName l
x) []
        ty (TyInfix l
an Type l
a (UnpromotedName l
_ QName l
b) Type l
c) = Type l -> Ty String
ty (Type l -> Ty String) -> Type l -> Ty String
forall a b. (a -> b) -> a -> b
$ let ap :: Type l -> Type l -> Type l
ap = l -> Type l -> Type l -> Type l
forall l. l -> Type l -> Type l -> Type l
TyApp l
an in l -> QName l -> Type l
forall l. l -> QName l -> Type l
TyCon l
an QName l
b Type l -> Type l -> Type l
`ap` Type l
a Type l -> Type l -> Type l
`ap` Type l
c
        ty (TyKind l
_ Type l
x Type l
_) = Type l -> Ty String
ty Type l
x
        ty (TyBang l
_ BangType l
_ Unpackedness l
_ Type l
x) = Type l -> Ty String
ty Type l
x
        ty (TyParen l
_ Type l
x) = Type l -> Ty String
ty Type l
x
        ty Type l
_ = String -> [Ty String] -> Ty String
forall n. n -> [Ty n] -> Ty n
TVar String
"_" []

        ctx :: Asst a -> [Ctx String]
ctx (ParenA a
_ Asst a
x) = Asst a -> [Ctx String]
ctx Asst a
x
        ctx (TypeA a
_ Type a
x)  = Type a -> [Ctx String]
forall a. Type a -> [Ctx String]
ctxTy Type a
x
        ctx Asst a
_ = []

        ctxTy :: Type a -> [Ctx String]
ctxTy (TyInfix a
an Type a
a (UnpromotedName a
_ QName a
con) Type a
b) = Type a -> [Ctx String]
ctxTy (Type a -> [Ctx String]) -> Type a -> [Ctx String]
forall a b. (a -> b) -> a -> b
$ a -> Type a -> Type a -> Type a
forall l. l -> Type l -> Type l -> Type l
TyApp a
an (a -> Type a -> Type a -> Type a
forall l. l -> Type l -> Type l -> Type l
TyApp a
an (a -> QName a -> Type a
forall l. l -> QName l -> Type l
TyCon a
an QName a
con) Type a
a) Type a
b
        ctxTy (Type a -> [Type a]
forall l. Type l -> [Type l]
fromTyApps -> TyCon a
_ QName a
con:TyVar a
_ Name a
var:[Type a]
_) = [String -> String -> Ctx String
forall n. n -> n -> Ctx n
Ctx (QName a -> String
forall a. QName a -> String
fromQName QName a
con) (Name a -> String
forall a. Name a -> String
fromName Name a
var)]
        ctxTy Type a
_ = []

        fromTyApps :: Type l -> [Type l]
fromTyApps (TyApp l
_ Type l
x Type l
y) = Type l -> [Type l]
fromTyApps Type l
x [Type l] -> [Type l] -> [Type l]
forall a. [a] -> [a] -> [a]
++ [Type l
y]
        fromTyApps Type l
x = [Type l
x]


hseToItem :: Decl a -> [Item]
hseToItem :: Decl a -> [Item]
hseToItem (TypeSig a
_ [Name a]
names Type a
ty) = Sig IString -> Item
ISignature (PkgName -> IString
toIString (PkgName -> IString) -> (String -> PkgName) -> String -> IString
forall b c a. (b -> c) -> (a -> b) -> a -> c
. String -> PkgName
strPack (String -> IString) -> Sig String -> Sig IString
forall (f :: * -> *) a b. Functor f => (a -> b) -> f a -> f b
<$> Type a -> Sig String
forall l. Type l -> Sig String
hseToSig Type a
ty) Item -> [Item] -> [Item]
forall a. a -> [a] -> [a]
: (Name a -> Item) -> [Name a] -> [Item]
forall a b. (a -> b) -> [a] -> [b]
map (PkgName -> Item
IName (PkgName -> Item) -> (Name a -> PkgName) -> Name a -> Item
forall b c a. (b -> c) -> (a -> b) -> a -> c
. String -> PkgName
strPack (String -> PkgName) -> (Name a -> String) -> Name a -> PkgName
forall b c a. (b -> c) -> (a -> b) -> a -> c
. Name a -> String
forall a. Name a -> String
fromName) [Name a]
names
hseToItem (TypeDecl a
_ (DeclHead a -> (Name a, [TyVarBind a])
forall a. DeclHead a -> (Name a, [TyVarBind a])
fromDeclHead -> (Name a
name, [TyVarBind a]
bind)) Type a
rhs) = [PkgName -> [IString] -> Sig IString -> Item
IAlias (String -> PkgName
strPack (String -> PkgName) -> String -> PkgName
forall a b. (a -> b) -> a -> b
$ Name a -> String
forall a. Name a -> String
fromName Name a
name) ((TyVarBind a -> IString) -> [TyVarBind a] -> [IString]
forall a b. (a -> b) -> [a] -> [b]
map (PkgName -> IString
toIString (PkgName -> IString)
-> (TyVarBind a -> PkgName) -> TyVarBind a -> IString
forall b c a. (b -> c) -> (a -> b) -> a -> c
. String -> PkgName
strPack (String -> PkgName)
-> (TyVarBind a -> String) -> TyVarBind a -> PkgName
forall b c a. (b -> c) -> (a -> b) -> a -> c
. Name a -> String
forall a. Name a -> String
fromName (Name a -> String)
-> (TyVarBind a -> Name a) -> TyVarBind a -> String
forall b c a. (b -> c) -> (a -> b) -> a -> c
. TyVarBind a -> Name a
forall a. TyVarBind a -> Name a
fromTyVarBind) [TyVarBind a]
bind) (PkgName -> IString
toIString (PkgName -> IString) -> (String -> PkgName) -> String -> IString
forall b c a. (b -> c) -> (a -> b) -> a -> c
. String -> PkgName
strPack (String -> IString) -> Sig String -> Sig IString
forall (f :: * -> *) a b. Functor f => (a -> b) -> f a -> f b
<$> Type a -> Sig String
forall l. Type l -> Sig String
hseToSig Type a
rhs)]
hseToItem (InstDecl a
an Maybe (Overlap a)
_ (InstRule a -> InstRule a
forall a. InstRule a -> InstRule a
fromIParen -> IRule a
_ Maybe [TyVarBind a]
_ Maybe (Context a)
ctx (InstHead a -> (QName a, [Type a])
forall a. InstHead a -> (QName a, [Type a])
fromInstHead -> (QName a
name, [Type a]
args))) Maybe [InstDecl a]
_) = [Sig IString -> Item
IInstance (Sig IString -> Item) -> Sig IString -> Item
forall a b. (a -> b) -> a -> b
$ (String -> IString) -> Sig String -> Sig IString
forall (f :: * -> *) a b. Functor f => (a -> b) -> f a -> f b
fmap (PkgName -> IString
toIString (PkgName -> IString) -> (String -> PkgName) -> String -> IString
forall b c a. (b -> c) -> (a -> b) -> a -> c
. String -> PkgName
strPack) (Sig String -> Sig IString) -> Sig String -> Sig IString
forall a b. (a -> b) -> a -> b
$ Type a -> Sig String
forall l. Type l -> Sig String
hseToSig (Type a -> Sig String) -> Type a -> Sig String
forall a b. (a -> b) -> a -> b
$ a -> Maybe [TyVarBind a] -> Maybe (Context a) -> Type a -> Type a
forall l.
l -> Maybe [TyVarBind l] -> Maybe (Context l) -> Type l -> Type l
TyForall a
an Maybe [TyVarBind a]
forall a. Maybe a
Nothing Maybe (Context a)
ctx (Type a -> Type a) -> Type a -> Type a
forall a b. (a -> b) -> a -> b
$ Type a -> [Type a] -> Type a
forall a. Type a -> [Type a] -> Type a
applyType (a -> QName a -> Type a
forall l. l -> QName l -> Type l
TyCon a
an QName a
name) [Type a]
args]
hseToItem Decl a
x = (String -> Item) -> [String] -> [Item]
forall a b. (a -> b) -> [a] -> [b]
map (PkgName -> Item
IName (PkgName -> Item) -> (String -> PkgName) -> String -> Item
forall b c a. (b -> c) -> (a -> b) -> a -> c
. String -> PkgName
strPack) ([String] -> [Item]) -> [String] -> [Item]
forall a b. (a -> b) -> a -> b
$ Decl a -> [String]
forall a. Decl a -> [String]
declNames Decl a
x