{-# LANGUAGE BangPatterns #-}
{-# LANGUAGE CPP #-}
{-# LANGUAGE DeriveAnyClass #-}
{-# LANGUAGE DeriveDataTypeable #-}
{-# LANGUAGE DeriveGeneric #-}
{-# LANGUAGE DeriveTraversable #-}
{-# LANGUAGE LambdaCase #-}
{-# LANGUAGE OverloadedStrings #-}
{-# LANGUAGE RankNTypes #-}
{-# LANGUAGE RecordWildCards #-}
{-# LANGUAGE StandaloneDeriving #-}
{-# LANGUAGE UnicodeSyntax #-}
module Dhall.Syntax (
Const(..)
, Var(..)
, Binding(..)
, makeBinding
, Chunks(..)
, DhallDouble(..)
, Expr(..)
, MultiLet(..)
, multiLet
, wrapInLets
, subExpressions
, chunkExprs
, bindingExprs
, denote
, renote
, shallowDenote
, Directory(..)
, File(..)
, FilePrefix(..)
, Import(..)
, ImportHashed(..)
, ImportMode(..)
, ImportType(..)
, URL(..)
, Scheme(..)
, pathCharacter
, reservedIdentifiers
, toDoubleQuoted
, longestSharedWhitespacePrefix
, linesLiteral
, unlinesLiteral
) where
import Control.DeepSeq (NFData)
import Data.Bifunctor (Bifunctor(..))
import Data.Bits (xor)
import Data.Data (Data)
import Data.Foldable
import Data.HashSet (HashSet)
import Data.List.NonEmpty (NonEmpty(..))
import Data.String (IsString(..))
import Data.Semigroup (Semigroup(..))
import Data.Sequence (Seq)
import Data.Text (Text)
import Data.Text.Prettyprint.Doc (Doc, Pretty)
import Data.Traversable
import Data.Void (Void)
import Dhall.Map (Map)
import Dhall.Set (Set)
import Dhall.Src (Src(..))
import {-# SOURCE #-} Dhall.Pretty.Internal
import GHC.Generics (Generic)
import Instances.TH.Lift ()
import Language.Haskell.TH.Syntax (Lift)
import Numeric.Natural (Natural)
import Prelude hiding (succ)
import Unsafe.Coerce (unsafeCoerce)
import qualified Control.Monad
import qualified Data.HashSet
import qualified Data.List.NonEmpty
import qualified Data.Text
import qualified Data.Text.Prettyprint.Doc as Pretty
import qualified Dhall.Crypto
import qualified Language.Haskell.TH.Syntax as Syntax
import qualified Network.URI as URI
data Const = Type | Kind | Sort
deriving (Int -> Const -> ShowS
[Const] -> ShowS
Const -> String
(Int -> Const -> ShowS)
-> (Const -> String) -> ([Const] -> ShowS) -> Show Const
forall a.
(Int -> a -> ShowS) -> (a -> String) -> ([a] -> ShowS) -> Show a
showList :: [Const] -> ShowS
$cshowList :: [Const] -> ShowS
show :: Const -> String
$cshow :: Const -> String
showsPrec :: Int -> Const -> ShowS
$cshowsPrec :: Int -> Const -> ShowS
Show, Const -> Const -> Bool
(Const -> Const -> Bool) -> (Const -> Const -> Bool) -> Eq Const
forall a. (a -> a -> Bool) -> (a -> a -> Bool) -> Eq a
/= :: Const -> Const -> Bool
$c/= :: Const -> Const -> Bool
== :: Const -> Const -> Bool
$c== :: Const -> Const -> Bool
Eq, Eq Const
Eq Const =>
(Const -> Const -> Ordering)
-> (Const -> Const -> Bool)
-> (Const -> Const -> Bool)
-> (Const -> Const -> Bool)
-> (Const -> Const -> Bool)
-> (Const -> Const -> Const)
-> (Const -> Const -> Const)
-> Ord Const
Const -> Const -> Bool
Const -> Const -> Ordering
Const -> Const -> Const
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 :: Const -> Const -> Const
$cmin :: Const -> Const -> Const
max :: Const -> Const -> Const
$cmax :: Const -> Const -> Const
>= :: Const -> Const -> Bool
$c>= :: Const -> Const -> Bool
> :: Const -> Const -> Bool
$c> :: Const -> Const -> Bool
<= :: Const -> Const -> Bool
$c<= :: Const -> Const -> Bool
< :: Const -> Const -> Bool
$c< :: Const -> Const -> Bool
compare :: Const -> Const -> Ordering
$ccompare :: Const -> Const -> Ordering
$cp1Ord :: Eq Const
Ord, Typeable Const
Constr
DataType
Typeable Const =>
(forall (c :: * -> *).
(forall d b. Data d => c (d -> b) -> d -> c b)
-> (forall g. g -> c g) -> Const -> c Const)
-> (forall (c :: * -> *).
(forall b r. Data b => c (b -> r) -> c r)
-> (forall r. r -> c r) -> Constr -> c Const)
-> (Const -> Constr)
-> (Const -> DataType)
-> (forall (t :: * -> *) (c :: * -> *).
Typeable t =>
(forall d. Data d => c (t d)) -> Maybe (c Const))
-> (forall (t :: * -> * -> *) (c :: * -> *).
Typeable t =>
(forall d e. (Data d, Data e) => c (t d e)) -> Maybe (c Const))
-> ((forall b. Data b => b -> b) -> Const -> Const)
-> (forall r r'.
(r -> r' -> r) -> r -> (forall d. Data d => d -> r') -> Const -> r)
-> (forall r r'.
(r' -> r -> r) -> r -> (forall d. Data d => d -> r') -> Const -> r)
-> (forall u. (forall d. Data d => d -> u) -> Const -> [u])
-> (forall u. Int -> (forall d. Data d => d -> u) -> Const -> u)
-> (forall (m :: * -> *).
Monad m =>
(forall d. Data d => d -> m d) -> Const -> m Const)
-> (forall (m :: * -> *).
MonadPlus m =>
(forall d. Data d => d -> m d) -> Const -> m Const)
-> (forall (m :: * -> *).
MonadPlus m =>
(forall d. Data d => d -> m d) -> Const -> m Const)
-> Data Const
Const -> Constr
Const -> DataType
(forall b. Data b => b -> b) -> Const -> Const
(forall d b. Data d => c (d -> b) -> d -> c b)
-> (forall g. g -> c g) -> Const -> c Const
(forall b r. Data b => c (b -> r) -> c r)
-> (forall r. r -> c r) -> Constr -> c Const
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) -> Const -> u
forall u. (forall d. Data d => d -> u) -> Const -> [u]
forall r r'.
(r -> r' -> r) -> r -> (forall d. Data d => d -> r') -> Const -> r
forall r r'.
(r' -> r -> r) -> r -> (forall d. Data d => d -> r') -> Const -> r
forall (m :: * -> *).
Monad m =>
(forall d. Data d => d -> m d) -> Const -> m Const
forall (m :: * -> *).
MonadPlus m =>
(forall d. Data d => d -> m d) -> Const -> m Const
forall (c :: * -> *).
(forall b r. Data b => c (b -> r) -> c r)
-> (forall r. r -> c r) -> Constr -> c Const
forall (c :: * -> *).
(forall d b. Data d => c (d -> b) -> d -> c b)
-> (forall g. g -> c g) -> Const -> c Const
forall (t :: * -> *) (c :: * -> *).
Typeable t =>
(forall d. Data d => c (t d)) -> Maybe (c Const)
forall (t :: * -> * -> *) (c :: * -> *).
Typeable t =>
(forall d e. (Data d, Data e) => c (t d e)) -> Maybe (c Const)
$cSort :: Constr
$cKind :: Constr
$cType :: Constr
$tConst :: DataType
gmapMo :: (forall d. Data d => d -> m d) -> Const -> m Const
$cgmapMo :: forall (m :: * -> *).
MonadPlus m =>
(forall d. Data d => d -> m d) -> Const -> m Const
gmapMp :: (forall d. Data d => d -> m d) -> Const -> m Const
$cgmapMp :: forall (m :: * -> *).
MonadPlus m =>
(forall d. Data d => d -> m d) -> Const -> m Const
gmapM :: (forall d. Data d => d -> m d) -> Const -> m Const
$cgmapM :: forall (m :: * -> *).
Monad m =>
(forall d. Data d => d -> m d) -> Const -> m Const
gmapQi :: Int -> (forall d. Data d => d -> u) -> Const -> u
$cgmapQi :: forall u. Int -> (forall d. Data d => d -> u) -> Const -> u
gmapQ :: (forall d. Data d => d -> u) -> Const -> [u]
$cgmapQ :: forall u. (forall d. Data d => d -> u) -> Const -> [u]
gmapQr :: (r' -> r -> r) -> r -> (forall d. Data d => d -> r') -> Const -> r
$cgmapQr :: forall r r'.
(r' -> r -> r) -> r -> (forall d. Data d => d -> r') -> Const -> r
gmapQl :: (r -> r' -> r) -> r -> (forall d. Data d => d -> r') -> Const -> r
$cgmapQl :: forall r r'.
(r -> r' -> r) -> r -> (forall d. Data d => d -> r') -> Const -> r
gmapT :: (forall b. Data b => b -> b) -> Const -> Const
$cgmapT :: (forall b. Data b => b -> b) -> Const -> Const
dataCast2 :: (forall d e. (Data d, Data e) => c (t d e)) -> Maybe (c Const)
$cdataCast2 :: forall (t :: * -> * -> *) (c :: * -> *).
Typeable t =>
(forall d e. (Data d, Data e) => c (t d e)) -> Maybe (c Const)
dataCast1 :: (forall d. Data d => c (t d)) -> Maybe (c Const)
$cdataCast1 :: forall (t :: * -> *) (c :: * -> *).
Typeable t =>
(forall d. Data d => c (t d)) -> Maybe (c Const)
dataTypeOf :: Const -> DataType
$cdataTypeOf :: Const -> DataType
toConstr :: Const -> Constr
$ctoConstr :: Const -> Constr
gunfold :: (forall b r. Data b => c (b -> r) -> c r)
-> (forall r. r -> c r) -> Constr -> c Const
$cgunfold :: forall (c :: * -> *).
(forall b r. Data b => c (b -> r) -> c r)
-> (forall r. r -> c r) -> Constr -> c Const
gfoldl :: (forall d b. Data d => c (d -> b) -> d -> c b)
-> (forall g. g -> c g) -> Const -> c Const
$cgfoldl :: forall (c :: * -> *).
(forall d b. Data d => c (d -> b) -> d -> c b)
-> (forall g. g -> c g) -> Const -> c Const
$cp1Data :: Typeable Const
Data, Const
Const -> Const -> Bounded Const
forall a. a -> a -> Bounded a
maxBound :: Const
$cmaxBound :: Const
minBound :: Const
$cminBound :: Const
Bounded, Int -> Const
Const -> Int
Const -> [Const]
Const -> Const
Const -> Const -> [Const]
Const -> Const -> Const -> [Const]
(Const -> Const)
-> (Const -> Const)
-> (Int -> Const)
-> (Const -> Int)
-> (Const -> [Const])
-> (Const -> Const -> [Const])
-> (Const -> Const -> [Const])
-> (Const -> Const -> Const -> [Const])
-> Enum Const
forall a.
(a -> a)
-> (a -> a)
-> (Int -> a)
-> (a -> Int)
-> (a -> [a])
-> (a -> a -> [a])
-> (a -> a -> [a])
-> (a -> a -> a -> [a])
-> Enum a
enumFromThenTo :: Const -> Const -> Const -> [Const]
$cenumFromThenTo :: Const -> Const -> Const -> [Const]
enumFromTo :: Const -> Const -> [Const]
$cenumFromTo :: Const -> Const -> [Const]
enumFromThen :: Const -> Const -> [Const]
$cenumFromThen :: Const -> Const -> [Const]
enumFrom :: Const -> [Const]
$cenumFrom :: Const -> [Const]
fromEnum :: Const -> Int
$cfromEnum :: Const -> Int
toEnum :: Int -> Const
$ctoEnum :: Int -> Const
pred :: Const -> Const
$cpred :: Const -> Const
succ :: Const -> Const
$csucc :: Const -> Const
Enum, (forall x. Const -> Rep Const x)
-> (forall x. Rep Const x -> Const) -> Generic Const
forall x. Rep Const x -> Const
forall x. Const -> Rep Const x
forall a.
(forall x. a -> Rep a x) -> (forall x. Rep a x -> a) -> Generic a
$cto :: forall x. Rep Const x -> Const
$cfrom :: forall x. Const -> Rep Const x
Generic, Const -> ()
(Const -> ()) -> NFData Const
forall a. (a -> ()) -> NFData a
rnf :: Const -> ()
$crnf :: Const -> ()
NFData)
instance Lift Const where
lift :: Const -> Q Exp
lift = Const -> Q Exp
forall a. Data a => a -> Q Exp
Syntax.liftData
instance Pretty Const where
pretty :: Const -> Doc ann
pretty = Doc Ann -> Doc ann
forall ann xxx. Doc ann -> Doc xxx
Pretty.unAnnotate (Doc Ann -> Doc ann) -> (Const -> Doc Ann) -> Const -> Doc ann
forall b c a. (b -> c) -> (a -> b) -> a -> c
. Const -> Doc Ann
prettyConst
data Var = V Text !Int
deriving (Typeable Var
Constr
DataType
Typeable Var =>
(forall (c :: * -> *).
(forall d b. Data d => c (d -> b) -> d -> c b)
-> (forall g. g -> c g) -> Var -> c Var)
-> (forall (c :: * -> *).
(forall b r. Data b => c (b -> r) -> c r)
-> (forall r. r -> c r) -> Constr -> c Var)
-> (Var -> Constr)
-> (Var -> DataType)
-> (forall (t :: * -> *) (c :: * -> *).
Typeable t =>
(forall d. Data d => c (t d)) -> Maybe (c Var))
-> (forall (t :: * -> * -> *) (c :: * -> *).
Typeable t =>
(forall d e. (Data d, Data e) => c (t d e)) -> Maybe (c Var))
-> ((forall b. Data b => b -> b) -> Var -> Var)
-> (forall r r'.
(r -> r' -> r) -> r -> (forall d. Data d => d -> r') -> Var -> r)
-> (forall r r'.
(r' -> r -> r) -> r -> (forall d. Data d => d -> r') -> Var -> r)
-> (forall u. (forall d. Data d => d -> u) -> Var -> [u])
-> (forall u. Int -> (forall d. Data d => d -> u) -> Var -> u)
-> (forall (m :: * -> *).
Monad m =>
(forall d. Data d => d -> m d) -> Var -> m Var)
-> (forall (m :: * -> *).
MonadPlus m =>
(forall d. Data d => d -> m d) -> Var -> m Var)
-> (forall (m :: * -> *).
MonadPlus m =>
(forall d. Data d => d -> m d) -> Var -> m Var)
-> Data Var
Var -> Constr
Var -> DataType
(forall b. Data b => b -> b) -> Var -> Var
(forall d b. Data d => c (d -> b) -> d -> c b)
-> (forall g. g -> c g) -> Var -> c Var
(forall b r. Data b => c (b -> r) -> c r)
-> (forall r. r -> c r) -> Constr -> c Var
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) -> Var -> u
forall u. (forall d. Data d => d -> u) -> Var -> [u]
forall r r'.
(r -> r' -> r) -> r -> (forall d. Data d => d -> r') -> Var -> r
forall r r'.
(r' -> r -> r) -> r -> (forall d. Data d => d -> r') -> Var -> r
forall (m :: * -> *).
Monad m =>
(forall d. Data d => d -> m d) -> Var -> m Var
forall (m :: * -> *).
MonadPlus m =>
(forall d. Data d => d -> m d) -> Var -> m Var
forall (c :: * -> *).
(forall b r. Data b => c (b -> r) -> c r)
-> (forall r. r -> c r) -> Constr -> c Var
forall (c :: * -> *).
(forall d b. Data d => c (d -> b) -> d -> c b)
-> (forall g. g -> c g) -> Var -> c Var
forall (t :: * -> *) (c :: * -> *).
Typeable t =>
(forall d. Data d => c (t d)) -> Maybe (c Var)
forall (t :: * -> * -> *) (c :: * -> *).
Typeable t =>
(forall d e. (Data d, Data e) => c (t d e)) -> Maybe (c Var)
$cV :: Constr
$tVar :: DataType
gmapMo :: (forall d. Data d => d -> m d) -> Var -> m Var
$cgmapMo :: forall (m :: * -> *).
MonadPlus m =>
(forall d. Data d => d -> m d) -> Var -> m Var
gmapMp :: (forall d. Data d => d -> m d) -> Var -> m Var
$cgmapMp :: forall (m :: * -> *).
MonadPlus m =>
(forall d. Data d => d -> m d) -> Var -> m Var
gmapM :: (forall d. Data d => d -> m d) -> Var -> m Var
$cgmapM :: forall (m :: * -> *).
Monad m =>
(forall d. Data d => d -> m d) -> Var -> m Var
gmapQi :: Int -> (forall d. Data d => d -> u) -> Var -> u
$cgmapQi :: forall u. Int -> (forall d. Data d => d -> u) -> Var -> u
gmapQ :: (forall d. Data d => d -> u) -> Var -> [u]
$cgmapQ :: forall u. (forall d. Data d => d -> u) -> Var -> [u]
gmapQr :: (r' -> r -> r) -> r -> (forall d. Data d => d -> r') -> Var -> r
$cgmapQr :: forall r r'.
(r' -> r -> r) -> r -> (forall d. Data d => d -> r') -> Var -> r
gmapQl :: (r -> r' -> r) -> r -> (forall d. Data d => d -> r') -> Var -> r
$cgmapQl :: forall r r'.
(r -> r' -> r) -> r -> (forall d. Data d => d -> r') -> Var -> r
gmapT :: (forall b. Data b => b -> b) -> Var -> Var
$cgmapT :: (forall b. Data b => b -> b) -> Var -> Var
dataCast2 :: (forall d e. (Data d, Data e) => c (t d e)) -> Maybe (c Var)
$cdataCast2 :: forall (t :: * -> * -> *) (c :: * -> *).
Typeable t =>
(forall d e. (Data d, Data e) => c (t d e)) -> Maybe (c Var)
dataCast1 :: (forall d. Data d => c (t d)) -> Maybe (c Var)
$cdataCast1 :: forall (t :: * -> *) (c :: * -> *).
Typeable t =>
(forall d. Data d => c (t d)) -> Maybe (c Var)
dataTypeOf :: Var -> DataType
$cdataTypeOf :: Var -> DataType
toConstr :: Var -> Constr
$ctoConstr :: Var -> Constr
gunfold :: (forall b r. Data b => c (b -> r) -> c r)
-> (forall r. r -> c r) -> Constr -> c Var
$cgunfold :: forall (c :: * -> *).
(forall b r. Data b => c (b -> r) -> c r)
-> (forall r. r -> c r) -> Constr -> c Var
gfoldl :: (forall d b. Data d => c (d -> b) -> d -> c b)
-> (forall g. g -> c g) -> Var -> c Var
$cgfoldl :: forall (c :: * -> *).
(forall d b. Data d => c (d -> b) -> d -> c b)
-> (forall g. g -> c g) -> Var -> c Var
$cp1Data :: Typeable Var
Data, (forall x. Var -> Rep Var x)
-> (forall x. Rep Var x -> Var) -> Generic Var
forall x. Rep Var x -> Var
forall x. Var -> Rep Var x
forall a.
(forall x. a -> Rep a x) -> (forall x. Rep a x -> a) -> Generic a
$cto :: forall x. Rep Var x -> Var
$cfrom :: forall x. Var -> Rep Var x
Generic, Var -> Var -> Bool
(Var -> Var -> Bool) -> (Var -> Var -> Bool) -> Eq Var
forall a. (a -> a -> Bool) -> (a -> a -> Bool) -> Eq a
/= :: Var -> Var -> Bool
$c/= :: Var -> Var -> Bool
== :: Var -> Var -> Bool
$c== :: Var -> Var -> Bool
Eq, Eq Var
Eq Var =>
(Var -> Var -> Ordering)
-> (Var -> Var -> Bool)
-> (Var -> Var -> Bool)
-> (Var -> Var -> Bool)
-> (Var -> Var -> Bool)
-> (Var -> Var -> Var)
-> (Var -> Var -> Var)
-> Ord Var
Var -> Var -> Bool
Var -> Var -> Ordering
Var -> Var -> Var
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 :: Var -> Var -> Var
$cmin :: Var -> Var -> Var
max :: Var -> Var -> Var
$cmax :: Var -> Var -> Var
>= :: Var -> Var -> Bool
$c>= :: Var -> Var -> Bool
> :: Var -> Var -> Bool
$c> :: Var -> Var -> Bool
<= :: Var -> Var -> Bool
$c<= :: Var -> Var -> Bool
< :: Var -> Var -> Bool
$c< :: Var -> Var -> Bool
compare :: Var -> Var -> Ordering
$ccompare :: Var -> Var -> Ordering
$cp1Ord :: Eq Var
Ord, Int -> Var -> ShowS
[Var] -> ShowS
Var -> String
(Int -> Var -> ShowS)
-> (Var -> String) -> ([Var] -> ShowS) -> Show Var
forall a.
(Int -> a -> ShowS) -> (a -> String) -> ([a] -> ShowS) -> Show a
showList :: [Var] -> ShowS
$cshowList :: [Var] -> ShowS
show :: Var -> String
$cshow :: Var -> String
showsPrec :: Int -> Var -> ShowS
$cshowsPrec :: Int -> Var -> ShowS
Show, Var -> ()
(Var -> ()) -> NFData Var
forall a. (a -> ()) -> NFData a
rnf :: Var -> ()
$crnf :: Var -> ()
NFData)
instance Lift Var where
lift :: Var -> Q Exp
lift = Var -> Q Exp
forall a. Data a => a -> Q Exp
Syntax.liftData
instance IsString Var where
fromString :: String -> Var
fromString str :: String
str = Text -> Int -> Var
V (String -> Text
forall a. IsString a => String -> a
fromString String
str) 0
instance Pretty Var where
pretty :: Var -> Doc ann
pretty = Doc Ann -> Doc ann
forall ann xxx. Doc ann -> Doc xxx
Pretty.unAnnotate (Doc Ann -> Doc ann) -> (Var -> Doc Ann) -> Var -> Doc ann
forall b c a. (b -> c) -> (a -> b) -> a -> c
. Var -> Doc Ann
prettyVar
data Binding s a = Binding
{ Binding s a -> Maybe s
bindingSrc0 :: Maybe s
, Binding s a -> Text
variable :: Text
, Binding s a -> Maybe s
bindingSrc1 :: Maybe s
, Binding s a -> Maybe (Maybe s, Expr s a)
annotation :: Maybe (Maybe s, Expr s a)
, Binding s a -> Maybe s
bindingSrc2 :: Maybe s
, Binding s a -> Expr s a
value :: Expr s a
} deriving (Typeable (Binding s a)
Constr
DataType
Typeable (Binding s a) =>
(forall (c :: * -> *).
(forall d b. Data d => c (d -> b) -> d -> c b)
-> (forall g. g -> c g) -> Binding s a -> c (Binding s a))
-> (forall (c :: * -> *).
(forall b r. Data b => c (b -> r) -> c r)
-> (forall r. r -> c r) -> Constr -> c (Binding s a))
-> (Binding s a -> Constr)
-> (Binding s a -> DataType)
-> (forall (t :: * -> *) (c :: * -> *).
Typeable t =>
(forall d. Data d => c (t d)) -> Maybe (c (Binding s a)))
-> (forall (t :: * -> * -> *) (c :: * -> *).
Typeable t =>
(forall d e. (Data d, Data e) => c (t d e))
-> Maybe (c (Binding s a)))
-> ((forall b. Data b => b -> b) -> Binding s a -> Binding s a)
-> (forall r r'.
(r -> r' -> r)
-> r -> (forall d. Data d => d -> r') -> Binding s a -> r)
-> (forall r r'.
(r' -> r -> r)
-> r -> (forall d. Data d => d -> r') -> Binding s a -> r)
-> (forall u. (forall d. Data d => d -> u) -> Binding s a -> [u])
-> (forall u.
Int -> (forall d. Data d => d -> u) -> Binding s a -> u)
-> (forall (m :: * -> *).
Monad m =>
(forall d. Data d => d -> m d) -> Binding s a -> m (Binding s a))
-> (forall (m :: * -> *).
MonadPlus m =>
(forall d. Data d => d -> m d) -> Binding s a -> m (Binding s a))
-> (forall (m :: * -> *).
MonadPlus m =>
(forall d. Data d => d -> m d) -> Binding s a -> m (Binding s a))
-> Data (Binding s a)
Binding s a -> Constr
Binding s a -> DataType
(forall b. Data b => b -> b) -> Binding s a -> Binding s a
(forall d b. Data d => c (d -> b) -> d -> c b)
-> (forall g. g -> c g) -> Binding s a -> c (Binding s a)
(forall b r. Data b => c (b -> r) -> c r)
-> (forall r. r -> c r) -> Constr -> c (Binding s a)
(forall d e. (Data d, Data e) => c (t d e))
-> Maybe (c (Binding s a))
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) -> Binding s a -> u
forall u. (forall d. Data d => d -> u) -> Binding s a -> [u]
forall s a. (Data s, Data a) => Typeable (Binding s a)
forall s a. (Data s, Data a) => Binding s a -> Constr
forall s a. (Data s, Data a) => Binding s a -> DataType
forall s a.
(Data s, Data a) =>
(forall b. Data b => b -> b) -> Binding s a -> Binding s a
forall s a u.
(Data s, Data a) =>
Int -> (forall d. Data d => d -> u) -> Binding s a -> u
forall s a u.
(Data s, Data a) =>
(forall d. Data d => d -> u) -> Binding s a -> [u]
forall s a r r'.
(Data s, Data a) =>
(r -> r' -> r)
-> r -> (forall d. Data d => d -> r') -> Binding s a -> r
forall s a r r'.
(Data s, Data a) =>
(r' -> r -> r)
-> r -> (forall d. Data d => d -> r') -> Binding s a -> r
forall s a (m :: * -> *).
(Data s, Data a, Monad m) =>
(forall d. Data d => d -> m d) -> Binding s a -> m (Binding s a)
forall s a (m :: * -> *).
(Data s, Data a, MonadPlus m) =>
(forall d. Data d => d -> m d) -> Binding s a -> m (Binding s a)
forall s a (c :: * -> *).
(Data s, Data a) =>
(forall b r. Data b => c (b -> r) -> c r)
-> (forall r. r -> c r) -> Constr -> c (Binding s a)
forall s a (c :: * -> *).
(Data s, Data a) =>
(forall d b. Data d => c (d -> b) -> d -> c b)
-> (forall g. g -> c g) -> Binding s a -> c (Binding s a)
forall s a (t :: * -> *) (c :: * -> *).
(Data s, Data a, Typeable t) =>
(forall d. Data d => c (t d)) -> Maybe (c (Binding s a))
forall s a (t :: * -> * -> *) (c :: * -> *).
(Data s, Data a, Typeable t) =>
(forall d e. (Data d, Data e) => c (t d e))
-> Maybe (c (Binding s a))
forall r r'.
(r -> r' -> r)
-> r -> (forall d. Data d => d -> r') -> Binding s a -> r
forall r r'.
(r' -> r -> r)
-> r -> (forall d. Data d => d -> r') -> Binding s a -> r
forall (m :: * -> *).
Monad m =>
(forall d. Data d => d -> m d) -> Binding s a -> m (Binding s a)
forall (m :: * -> *).
MonadPlus m =>
(forall d. Data d => d -> m d) -> Binding s a -> m (Binding s a)
forall (c :: * -> *).
(forall b r. Data b => c (b -> r) -> c r)
-> (forall r. r -> c r) -> Constr -> c (Binding s a)
forall (c :: * -> *).
(forall d b. Data d => c (d -> b) -> d -> c b)
-> (forall g. g -> c g) -> Binding s a -> c (Binding s a)
forall (t :: * -> *) (c :: * -> *).
Typeable t =>
(forall d. Data d => c (t d)) -> Maybe (c (Binding s a))
forall (t :: * -> * -> *) (c :: * -> *).
Typeable t =>
(forall d e. (Data d, Data e) => c (t d e))
-> Maybe (c (Binding s a))
$cBinding :: Constr
$tBinding :: DataType
gmapMo :: (forall d. Data d => d -> m d) -> Binding s a -> m (Binding s a)
$cgmapMo :: forall s a (m :: * -> *).
(Data s, Data a, MonadPlus m) =>
(forall d. Data d => d -> m d) -> Binding s a -> m (Binding s a)
gmapMp :: (forall d. Data d => d -> m d) -> Binding s a -> m (Binding s a)
$cgmapMp :: forall s a (m :: * -> *).
(Data s, Data a, MonadPlus m) =>
(forall d. Data d => d -> m d) -> Binding s a -> m (Binding s a)
gmapM :: (forall d. Data d => d -> m d) -> Binding s a -> m (Binding s a)
$cgmapM :: forall s a (m :: * -> *).
(Data s, Data a, Monad m) =>
(forall d. Data d => d -> m d) -> Binding s a -> m (Binding s a)
gmapQi :: Int -> (forall d. Data d => d -> u) -> Binding s a -> u
$cgmapQi :: forall s a u.
(Data s, Data a) =>
Int -> (forall d. Data d => d -> u) -> Binding s a -> u
gmapQ :: (forall d. Data d => d -> u) -> Binding s a -> [u]
$cgmapQ :: forall s a u.
(Data s, Data a) =>
(forall d. Data d => d -> u) -> Binding s a -> [u]
gmapQr :: (r' -> r -> r)
-> r -> (forall d. Data d => d -> r') -> Binding s a -> r
$cgmapQr :: forall s a r r'.
(Data s, Data a) =>
(r' -> r -> r)
-> r -> (forall d. Data d => d -> r') -> Binding s a -> r
gmapQl :: (r -> r' -> r)
-> r -> (forall d. Data d => d -> r') -> Binding s a -> r
$cgmapQl :: forall s a r r'.
(Data s, Data a) =>
(r -> r' -> r)
-> r -> (forall d. Data d => d -> r') -> Binding s a -> r
gmapT :: (forall b. Data b => b -> b) -> Binding s a -> Binding s a
$cgmapT :: forall s a.
(Data s, Data a) =>
(forall b. Data b => b -> b) -> Binding s a -> Binding s a
dataCast2 :: (forall d e. (Data d, Data e) => c (t d e))
-> Maybe (c (Binding s a))
$cdataCast2 :: forall s a (t :: * -> * -> *) (c :: * -> *).
(Data s, Data a, Typeable t) =>
(forall d e. (Data d, Data e) => c (t d e))
-> Maybe (c (Binding s a))
dataCast1 :: (forall d. Data d => c (t d)) -> Maybe (c (Binding s a))
$cdataCast1 :: forall s a (t :: * -> *) (c :: * -> *).
(Data s, Data a, Typeable t) =>
(forall d. Data d => c (t d)) -> Maybe (c (Binding s a))
dataTypeOf :: Binding s a -> DataType
$cdataTypeOf :: forall s a. (Data s, Data a) => Binding s a -> DataType
toConstr :: Binding s a -> Constr
$ctoConstr :: forall s a. (Data s, Data a) => Binding s a -> Constr
gunfold :: (forall b r. Data b => c (b -> r) -> c r)
-> (forall r. r -> c r) -> Constr -> c (Binding s a)
$cgunfold :: forall s a (c :: * -> *).
(Data s, Data a) =>
(forall b r. Data b => c (b -> r) -> c r)
-> (forall r. r -> c r) -> Constr -> c (Binding s a)
gfoldl :: (forall d b. Data d => c (d -> b) -> d -> c b)
-> (forall g. g -> c g) -> Binding s a -> c (Binding s a)
$cgfoldl :: forall s a (c :: * -> *).
(Data s, Data a) =>
(forall d b. Data d => c (d -> b) -> d -> c b)
-> (forall g. g -> c g) -> Binding s a -> c (Binding s a)
$cp1Data :: forall s a. (Data s, Data a) => Typeable (Binding s a)
Data, Binding s a -> Binding s a -> Bool
(Binding s a -> Binding s a -> Bool)
-> (Binding s a -> Binding s a -> Bool) -> Eq (Binding s a)
forall a. (a -> a -> Bool) -> (a -> a -> Bool) -> Eq a
forall s a. (Eq s, Eq a) => Binding s a -> Binding s a -> Bool
/= :: Binding s a -> Binding s a -> Bool
$c/= :: forall s a. (Eq s, Eq a) => Binding s a -> Binding s a -> Bool
== :: Binding s a -> Binding s a -> Bool
$c== :: forall s a. (Eq s, Eq a) => Binding s a -> Binding s a -> Bool
Eq, Binding s a -> Bool
(a -> m) -> Binding s a -> m
(a -> b -> b) -> b -> Binding s a -> b
(forall m. Monoid m => Binding s m -> m)
-> (forall m a. Monoid m => (a -> m) -> Binding s a -> m)
-> (forall m a. Monoid m => (a -> m) -> Binding s a -> m)
-> (forall a b. (a -> b -> b) -> b -> Binding s a -> b)
-> (forall a b. (a -> b -> b) -> b -> Binding s a -> b)
-> (forall b a. (b -> a -> b) -> b -> Binding s a -> b)
-> (forall b a. (b -> a -> b) -> b -> Binding s a -> b)
-> (forall a. (a -> a -> a) -> Binding s a -> a)
-> (forall a. (a -> a -> a) -> Binding s a -> a)
-> (forall a. Binding s a -> [a])
-> (forall a. Binding s a -> Bool)
-> (forall a. Binding s a -> Int)
-> (forall a. Eq a => a -> Binding s a -> Bool)
-> (forall a. Ord a => Binding s a -> a)
-> (forall a. Ord a => Binding s a -> a)
-> (forall a. Num a => Binding s a -> a)
-> (forall a. Num a => Binding s a -> a)
-> Foldable (Binding s)
forall a. Eq a => a -> Binding s a -> Bool
forall a. Num a => Binding s a -> a
forall a. Ord a => Binding s a -> a
forall m. Monoid m => Binding s m -> m
forall a. Binding s a -> Bool
forall a. Binding s a -> Int
forall a. Binding s a -> [a]
forall a. (a -> a -> a) -> Binding s a -> a
forall s a. Eq a => a -> Binding s a -> Bool
forall s a. Num a => Binding s a -> a
forall s a. Ord a => Binding s a -> a
forall m a. Monoid m => (a -> m) -> Binding s a -> m
forall s m. Monoid m => Binding s m -> m
forall s a. Binding s a -> Bool
forall s a. Binding s a -> Int
forall s a. Binding s a -> [a]
forall b a. (b -> a -> b) -> b -> Binding s a -> b
forall a b. (a -> b -> b) -> b -> Binding s a -> b
forall s a. (a -> a -> a) -> Binding s a -> a
forall s m a. Monoid m => (a -> m) -> Binding s a -> m
forall s b a. (b -> a -> b) -> b -> Binding s a -> b
forall s a b. (a -> b -> b) -> b -> Binding s a -> b
forall (t :: * -> *).
(forall m. Monoid m => t m -> m)
-> (forall m a. Monoid m => (a -> m) -> t a -> m)
-> (forall m a. Monoid m => (a -> m) -> t a -> m)
-> (forall a b. (a -> b -> b) -> b -> t a -> b)
-> (forall a b. (a -> b -> b) -> b -> t a -> b)
-> (forall b a. (b -> a -> b) -> b -> t a -> b)
-> (forall b a. (b -> a -> b) -> b -> t a -> b)
-> (forall a. (a -> a -> a) -> t a -> a)
-> (forall a. (a -> a -> a) -> t a -> a)
-> (forall a. t a -> [a])
-> (forall a. t a -> Bool)
-> (forall a. t a -> Int)
-> (forall a. Eq a => a -> t a -> Bool)
-> (forall a. Ord a => t a -> a)
-> (forall a. Ord a => t a -> a)
-> (forall a. Num a => t a -> a)
-> (forall a. Num a => t a -> a)
-> Foldable t
product :: Binding s a -> a
$cproduct :: forall s a. Num a => Binding s a -> a
sum :: Binding s a -> a
$csum :: forall s a. Num a => Binding s a -> a
minimum :: Binding s a -> a
$cminimum :: forall s a. Ord a => Binding s a -> a
maximum :: Binding s a -> a
$cmaximum :: forall s a. Ord a => Binding s a -> a
elem :: a -> Binding s a -> Bool
$celem :: forall s a. Eq a => a -> Binding s a -> Bool
length :: Binding s a -> Int
$clength :: forall s a. Binding s a -> Int
null :: Binding s a -> Bool
$cnull :: forall s a. Binding s a -> Bool
toList :: Binding s a -> [a]
$ctoList :: forall s a. Binding s a -> [a]
foldl1 :: (a -> a -> a) -> Binding s a -> a
$cfoldl1 :: forall s a. (a -> a -> a) -> Binding s a -> a
foldr1 :: (a -> a -> a) -> Binding s a -> a
$cfoldr1 :: forall s a. (a -> a -> a) -> Binding s a -> a
foldl' :: (b -> a -> b) -> b -> Binding s a -> b
$cfoldl' :: forall s b a. (b -> a -> b) -> b -> Binding s a -> b
foldl :: (b -> a -> b) -> b -> Binding s a -> b
$cfoldl :: forall s b a. (b -> a -> b) -> b -> Binding s a -> b
foldr' :: (a -> b -> b) -> b -> Binding s a -> b
$cfoldr' :: forall s a b. (a -> b -> b) -> b -> Binding s a -> b
foldr :: (a -> b -> b) -> b -> Binding s a -> b
$cfoldr :: forall s a b. (a -> b -> b) -> b -> Binding s a -> b
foldMap' :: (a -> m) -> Binding s a -> m
$cfoldMap' :: forall s m a. Monoid m => (a -> m) -> Binding s a -> m
foldMap :: (a -> m) -> Binding s a -> m
$cfoldMap :: forall s m a. Monoid m => (a -> m) -> Binding s a -> m
fold :: Binding s m -> m
$cfold :: forall s m. Monoid m => Binding s m -> m
Foldable, a -> Binding s b -> Binding s a
(a -> b) -> Binding s a -> Binding s b
(forall a b. (a -> b) -> Binding s a -> Binding s b)
-> (forall a b. a -> Binding s b -> Binding s a)
-> Functor (Binding s)
forall a b. a -> Binding s b -> Binding s a
forall a b. (a -> b) -> Binding s a -> Binding s b
forall s a b. a -> Binding s b -> Binding s a
forall s a b. (a -> b) -> Binding s a -> Binding s b
forall (f :: * -> *).
(forall a b. (a -> b) -> f a -> f b)
-> (forall a b. a -> f b -> f a) -> Functor f
<$ :: a -> Binding s b -> Binding s a
$c<$ :: forall s a b. a -> Binding s b -> Binding s a
fmap :: (a -> b) -> Binding s a -> Binding s b
$cfmap :: forall s a b. (a -> b) -> Binding s a -> Binding s b
Functor, (forall x. Binding s a -> Rep (Binding s a) x)
-> (forall x. Rep (Binding s a) x -> Binding s a)
-> Generic (Binding s a)
forall x. Rep (Binding s a) x -> Binding s a
forall x. Binding s a -> Rep (Binding s a) x
forall a.
(forall x. a -> Rep a x) -> (forall x. Rep a x -> a) -> Generic a
forall s a x. Rep (Binding s a) x -> Binding s a
forall s a x. Binding s a -> Rep (Binding s a) x
$cto :: forall s a x. Rep (Binding s a) x -> Binding s a
$cfrom :: forall s a x. Binding s a -> Rep (Binding s a) x
Generic, Binding s a -> ()
(Binding s a -> ()) -> NFData (Binding s a)
forall a. (a -> ()) -> NFData a
forall s a. (NFData s, NFData a) => Binding s a -> ()
rnf :: Binding s a -> ()
$crnf :: forall s a. (NFData s, NFData a) => Binding s a -> ()
NFData, Eq (Binding s a)
Eq (Binding s a) =>
(Binding s a -> Binding s a -> Ordering)
-> (Binding s a -> Binding s a -> Bool)
-> (Binding s a -> Binding s a -> Bool)
-> (Binding s a -> Binding s a -> Bool)
-> (Binding s a -> Binding s a -> Bool)
-> (Binding s a -> Binding s a -> Binding s a)
-> (Binding s a -> Binding s a -> Binding s a)
-> Ord (Binding s a)
Binding s a -> Binding s a -> Bool
Binding s a -> Binding s a -> Ordering
Binding s a -> Binding s a -> Binding s a
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 s a. (Ord s, Ord a) => Eq (Binding s a)
forall s a. (Ord s, Ord a) => Binding s a -> Binding s a -> Bool
forall s a.
(Ord s, Ord a) =>
Binding s a -> Binding s a -> Ordering
forall s a.
(Ord s, Ord a) =>
Binding s a -> Binding s a -> Binding s a
min :: Binding s a -> Binding s a -> Binding s a
$cmin :: forall s a.
(Ord s, Ord a) =>
Binding s a -> Binding s a -> Binding s a
max :: Binding s a -> Binding s a -> Binding s a
$cmax :: forall s a.
(Ord s, Ord a) =>
Binding s a -> Binding s a -> Binding s a
>= :: Binding s a -> Binding s a -> Bool
$c>= :: forall s a. (Ord s, Ord a) => Binding s a -> Binding s a -> Bool
> :: Binding s a -> Binding s a -> Bool
$c> :: forall s a. (Ord s, Ord a) => Binding s a -> Binding s a -> Bool
<= :: Binding s a -> Binding s a -> Bool
$c<= :: forall s a. (Ord s, Ord a) => Binding s a -> Binding s a -> Bool
< :: Binding s a -> Binding s a -> Bool
$c< :: forall s a. (Ord s, Ord a) => Binding s a -> Binding s a -> Bool
compare :: Binding s a -> Binding s a -> Ordering
$ccompare :: forall s a.
(Ord s, Ord a) =>
Binding s a -> Binding s a -> Ordering
$cp1Ord :: forall s a. (Ord s, Ord a) => Eq (Binding s a)
Ord, Int -> Binding s a -> ShowS
[Binding s a] -> ShowS
Binding s a -> String
(Int -> Binding s a -> ShowS)
-> (Binding s a -> String)
-> ([Binding s a] -> ShowS)
-> Show (Binding s a)
forall a.
(Int -> a -> ShowS) -> (a -> String) -> ([a] -> ShowS) -> Show a
forall s a. (Show s, Show a) => Int -> Binding s a -> ShowS
forall s a. (Show s, Show a) => [Binding s a] -> ShowS
forall s a. (Show s, Show a) => Binding s a -> String
showList :: [Binding s a] -> ShowS
$cshowList :: forall s a. (Show s, Show a) => [Binding s a] -> ShowS
show :: Binding s a -> String
$cshow :: forall s a. (Show s, Show a) => Binding s a -> String
showsPrec :: Int -> Binding s a -> ShowS
$cshowsPrec :: forall s a. (Show s, Show a) => Int -> Binding s a -> ShowS
Show, Functor (Binding s)
Foldable (Binding s)
(Functor (Binding s), Foldable (Binding s)) =>
(forall (f :: * -> *) a b.
Applicative f =>
(a -> f b) -> Binding s a -> f (Binding s b))
-> (forall (f :: * -> *) a.
Applicative f =>
Binding s (f a) -> f (Binding s a))
-> (forall (m :: * -> *) a b.
Monad m =>
(a -> m b) -> Binding s a -> m (Binding s b))
-> (forall (m :: * -> *) a.
Monad m =>
Binding s (m a) -> m (Binding s a))
-> Traversable (Binding s)
(a -> f b) -> Binding s a -> f (Binding s b)
forall s. Functor (Binding s)
forall s. Foldable (Binding s)
forall s (m :: * -> *) a.
Monad m =>
Binding s (m a) -> m (Binding s a)
forall s (f :: * -> *) a.
Applicative f =>
Binding s (f a) -> f (Binding s a)
forall s (m :: * -> *) a b.
Monad m =>
(a -> m b) -> Binding s a -> m (Binding s b)
forall s (f :: * -> *) a b.
Applicative f =>
(a -> f b) -> Binding s a -> f (Binding s b)
forall (t :: * -> *).
(Functor t, Foldable t) =>
(forall (f :: * -> *) a b.
Applicative f =>
(a -> f b) -> t a -> f (t b))
-> (forall (f :: * -> *) a. Applicative f => t (f a) -> f (t a))
-> (forall (m :: * -> *) a b.
Monad m =>
(a -> m b) -> t a -> m (t b))
-> (forall (m :: * -> *) a. Monad m => t (m a) -> m (t a))
-> Traversable t
forall (m :: * -> *) a.
Monad m =>
Binding s (m a) -> m (Binding s a)
forall (f :: * -> *) a.
Applicative f =>
Binding s (f a) -> f (Binding s a)
forall (m :: * -> *) a b.
Monad m =>
(a -> m b) -> Binding s a -> m (Binding s b)
forall (f :: * -> *) a b.
Applicative f =>
(a -> f b) -> Binding s a -> f (Binding s b)
sequence :: Binding s (m a) -> m (Binding s a)
$csequence :: forall s (m :: * -> *) a.
Monad m =>
Binding s (m a) -> m (Binding s a)
mapM :: (a -> m b) -> Binding s a -> m (Binding s b)
$cmapM :: forall s (m :: * -> *) a b.
Monad m =>
(a -> m b) -> Binding s a -> m (Binding s b)
sequenceA :: Binding s (f a) -> f (Binding s a)
$csequenceA :: forall s (f :: * -> *) a.
Applicative f =>
Binding s (f a) -> f (Binding s a)
traverse :: (a -> f b) -> Binding s a -> f (Binding s b)
$ctraverse :: forall s (f :: * -> *) a b.
Applicative f =>
(a -> f b) -> Binding s a -> f (Binding s b)
$cp2Traversable :: forall s. Foldable (Binding s)
$cp1Traversable :: forall s. Functor (Binding s)
Traversable)
instance Bifunctor Binding where
first :: (a -> b) -> Binding a c -> Binding b c
first k :: a -> b
k (Binding src0 :: Maybe a
src0 a :: Text
a src1 :: Maybe a
src1 b :: Maybe (Maybe a, Expr a c)
b src2 :: Maybe a
src2 c :: Expr a c
c) =
Maybe b
-> Text
-> Maybe b
-> Maybe (Maybe b, Expr b c)
-> Maybe b
-> Expr b c
-> Binding b c
forall s a.
Maybe s
-> Text
-> Maybe s
-> Maybe (Maybe s, Expr s a)
-> Maybe s
-> Expr s a
-> Binding s a
Binding ((a -> b) -> Maybe a -> Maybe b
forall (f :: * -> *) a b. Functor f => (a -> b) -> f a -> f b
fmap a -> b
k Maybe a
src0) Text
a ((a -> b) -> Maybe a -> Maybe b
forall (f :: * -> *) a b. Functor f => (a -> b) -> f a -> f b
fmap a -> b
k Maybe a
src1) (((Maybe a, Expr a c) -> (Maybe b, Expr b c))
-> Maybe (Maybe a, Expr a c) -> Maybe (Maybe b, Expr b c)
forall (f :: * -> *) a b. Functor f => (a -> b) -> f a -> f b
fmap (Maybe a, Expr a c) -> (Maybe b, Expr b c)
forall (f :: * -> *) (p :: * -> * -> *) c.
(Functor f, Bifunctor p) =>
(f a, p a c) -> (f b, p b c)
adapt0 Maybe (Maybe a, Expr a c)
b) ((a -> b) -> Maybe a -> Maybe b
forall (f :: * -> *) a b. Functor f => (a -> b) -> f a -> f b
fmap a -> b
k Maybe a
src2) ((a -> b) -> Expr a c -> Expr b c
forall (p :: * -> * -> *) a b c.
Bifunctor p =>
(a -> b) -> p a c -> p b c
first a -> b
k Expr a c
c)
where
adapt0 :: (f a, p a c) -> (f b, p b c)
adapt0 (src3 :: f a
src3, d :: p a c
d) = ((a -> b) -> f a -> f b
forall (f :: * -> *) a b. Functor f => (a -> b) -> f a -> f b
fmap a -> b
k f a
src3, (a -> b) -> p a c -> p b c
forall (p :: * -> * -> *) a b c.
Bifunctor p =>
(a -> b) -> p a c -> p b c
first a -> b
k p a c
d)
second :: (b -> c) -> Binding a b -> Binding a c
second = (b -> c) -> Binding a b -> Binding a c
forall (f :: * -> *) a b. Functor f => (a -> b) -> f a -> f b
fmap
makeBinding :: Text -> Expr s a -> Binding s a
makeBinding :: Text -> Expr s a -> Binding s a
makeBinding name :: Text
name = Maybe s
-> Text
-> Maybe s
-> Maybe (Maybe s, Expr s a)
-> Maybe s
-> Expr s a
-> Binding s a
forall s a.
Maybe s
-> Text
-> Maybe s
-> Maybe (Maybe s, Expr s a)
-> Maybe s
-> Expr s a
-> Binding s a
Binding Maybe s
forall a. Maybe a
Nothing Text
name Maybe s
forall a. Maybe a
Nothing Maybe (Maybe s, Expr s a)
forall a. Maybe a
Nothing Maybe s
forall a. Maybe a
Nothing
newtype DhallDouble = DhallDouble { DhallDouble -> Double
getDhallDouble :: Double }
deriving (Int -> DhallDouble -> ShowS
[DhallDouble] -> ShowS
DhallDouble -> String
(Int -> DhallDouble -> ShowS)
-> (DhallDouble -> String)
-> ([DhallDouble] -> ShowS)
-> Show DhallDouble
forall a.
(Int -> a -> ShowS) -> (a -> String) -> ([a] -> ShowS) -> Show a
showList :: [DhallDouble] -> ShowS
$cshowList :: [DhallDouble] -> ShowS
show :: DhallDouble -> String
$cshow :: DhallDouble -> String
showsPrec :: Int -> DhallDouble -> ShowS
$cshowsPrec :: Int -> DhallDouble -> ShowS
Show, Typeable DhallDouble
Constr
DataType
Typeable DhallDouble =>
(forall (c :: * -> *).
(forall d b. Data d => c (d -> b) -> d -> c b)
-> (forall g. g -> c g) -> DhallDouble -> c DhallDouble)
-> (forall (c :: * -> *).
(forall b r. Data b => c (b -> r) -> c r)
-> (forall r. r -> c r) -> Constr -> c DhallDouble)
-> (DhallDouble -> Constr)
-> (DhallDouble -> DataType)
-> (forall (t :: * -> *) (c :: * -> *).
Typeable t =>
(forall d. Data d => c (t d)) -> Maybe (c DhallDouble))
-> (forall (t :: * -> * -> *) (c :: * -> *).
Typeable t =>
(forall d e. (Data d, Data e) => c (t d e))
-> Maybe (c DhallDouble))
-> ((forall b. Data b => b -> b) -> DhallDouble -> DhallDouble)
-> (forall r r'.
(r -> r' -> r)
-> r -> (forall d. Data d => d -> r') -> DhallDouble -> r)
-> (forall r r'.
(r' -> r -> r)
-> r -> (forall d. Data d => d -> r') -> DhallDouble -> r)
-> (forall u. (forall d. Data d => d -> u) -> DhallDouble -> [u])
-> (forall u.
Int -> (forall d. Data d => d -> u) -> DhallDouble -> u)
-> (forall (m :: * -> *).
Monad m =>
(forall d. Data d => d -> m d) -> DhallDouble -> m DhallDouble)
-> (forall (m :: * -> *).
MonadPlus m =>
(forall d. Data d => d -> m d) -> DhallDouble -> m DhallDouble)
-> (forall (m :: * -> *).
MonadPlus m =>
(forall d. Data d => d -> m d) -> DhallDouble -> m DhallDouble)
-> Data DhallDouble
DhallDouble -> Constr
DhallDouble -> DataType
(forall b. Data b => b -> b) -> DhallDouble -> DhallDouble
(forall d b. Data d => c (d -> b) -> d -> c b)
-> (forall g. g -> c g) -> DhallDouble -> c DhallDouble
(forall b r. Data b => c (b -> r) -> c r)
-> (forall r. r -> c r) -> Constr -> c DhallDouble
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) -> DhallDouble -> u
forall u. (forall d. Data d => d -> u) -> DhallDouble -> [u]
forall r r'.
(r -> r' -> r)
-> r -> (forall d. Data d => d -> r') -> DhallDouble -> r
forall r r'.
(r' -> r -> r)
-> r -> (forall d. Data d => d -> r') -> DhallDouble -> r
forall (m :: * -> *).
Monad m =>
(forall d. Data d => d -> m d) -> DhallDouble -> m DhallDouble
forall (m :: * -> *).
MonadPlus m =>
(forall d. Data d => d -> m d) -> DhallDouble -> m DhallDouble
forall (c :: * -> *).
(forall b r. Data b => c (b -> r) -> c r)
-> (forall r. r -> c r) -> Constr -> c DhallDouble
forall (c :: * -> *).
(forall d b. Data d => c (d -> b) -> d -> c b)
-> (forall g. g -> c g) -> DhallDouble -> c DhallDouble
forall (t :: * -> *) (c :: * -> *).
Typeable t =>
(forall d. Data d => c (t d)) -> Maybe (c DhallDouble)
forall (t :: * -> * -> *) (c :: * -> *).
Typeable t =>
(forall d e. (Data d, Data e) => c (t d e))
-> Maybe (c DhallDouble)
$cDhallDouble :: Constr
$tDhallDouble :: DataType
gmapMo :: (forall d. Data d => d -> m d) -> DhallDouble -> m DhallDouble
$cgmapMo :: forall (m :: * -> *).
MonadPlus m =>
(forall d. Data d => d -> m d) -> DhallDouble -> m DhallDouble
gmapMp :: (forall d. Data d => d -> m d) -> DhallDouble -> m DhallDouble
$cgmapMp :: forall (m :: * -> *).
MonadPlus m =>
(forall d. Data d => d -> m d) -> DhallDouble -> m DhallDouble
gmapM :: (forall d. Data d => d -> m d) -> DhallDouble -> m DhallDouble
$cgmapM :: forall (m :: * -> *).
Monad m =>
(forall d. Data d => d -> m d) -> DhallDouble -> m DhallDouble
gmapQi :: Int -> (forall d. Data d => d -> u) -> DhallDouble -> u
$cgmapQi :: forall u. Int -> (forall d. Data d => d -> u) -> DhallDouble -> u
gmapQ :: (forall d. Data d => d -> u) -> DhallDouble -> [u]
$cgmapQ :: forall u. (forall d. Data d => d -> u) -> DhallDouble -> [u]
gmapQr :: (r' -> r -> r)
-> r -> (forall d. Data d => d -> r') -> DhallDouble -> r
$cgmapQr :: forall r r'.
(r' -> r -> r)
-> r -> (forall d. Data d => d -> r') -> DhallDouble -> r
gmapQl :: (r -> r' -> r)
-> r -> (forall d. Data d => d -> r') -> DhallDouble -> r
$cgmapQl :: forall r r'.
(r -> r' -> r)
-> r -> (forall d. Data d => d -> r') -> DhallDouble -> r
gmapT :: (forall b. Data b => b -> b) -> DhallDouble -> DhallDouble
$cgmapT :: (forall b. Data b => b -> b) -> DhallDouble -> DhallDouble
dataCast2 :: (forall d e. (Data d, Data e) => c (t d e))
-> Maybe (c DhallDouble)
$cdataCast2 :: forall (t :: * -> * -> *) (c :: * -> *).
Typeable t =>
(forall d e. (Data d, Data e) => c (t d e))
-> Maybe (c DhallDouble)
dataCast1 :: (forall d. Data d => c (t d)) -> Maybe (c DhallDouble)
$cdataCast1 :: forall (t :: * -> *) (c :: * -> *).
Typeable t =>
(forall d. Data d => c (t d)) -> Maybe (c DhallDouble)
dataTypeOf :: DhallDouble -> DataType
$cdataTypeOf :: DhallDouble -> DataType
toConstr :: DhallDouble -> Constr
$ctoConstr :: DhallDouble -> Constr
gunfold :: (forall b r. Data b => c (b -> r) -> c r)
-> (forall r. r -> c r) -> Constr -> c DhallDouble
$cgunfold :: forall (c :: * -> *).
(forall b r. Data b => c (b -> r) -> c r)
-> (forall r. r -> c r) -> Constr -> c DhallDouble
gfoldl :: (forall d b. Data d => c (d -> b) -> d -> c b)
-> (forall g. g -> c g) -> DhallDouble -> c DhallDouble
$cgfoldl :: forall (c :: * -> *).
(forall d b. Data d => c (d -> b) -> d -> c b)
-> (forall g. g -> c g) -> DhallDouble -> c DhallDouble
$cp1Data :: Typeable DhallDouble
Data, DhallDouble -> ()
(DhallDouble -> ()) -> NFData DhallDouble
forall a. (a -> ()) -> NFData a
rnf :: DhallDouble -> ()
$crnf :: DhallDouble -> ()
NFData, (forall x. DhallDouble -> Rep DhallDouble x)
-> (forall x. Rep DhallDouble x -> DhallDouble)
-> Generic DhallDouble
forall x. Rep DhallDouble x -> DhallDouble
forall x. DhallDouble -> Rep DhallDouble x
forall a.
(forall x. a -> Rep a x) -> (forall x. Rep a x -> a) -> Generic a
$cto :: forall x. Rep DhallDouble x -> DhallDouble
$cfrom :: forall x. DhallDouble -> Rep DhallDouble x
Generic)
instance Eq DhallDouble where
DhallDouble a :: Double
a == :: DhallDouble -> DhallDouble -> Bool
== DhallDouble b :: Double
b
| Double -> Bool
forall a. RealFloat a => a -> Bool
isNaN Double
a Bool -> Bool -> Bool
&& Double -> Bool
forall a. RealFloat a => a -> Bool
isNaN Double
b = Bool
True
| Double -> Bool
forall a. RealFloat a => a -> Bool
isNegativeZero Double
a Bool -> Bool -> Bool
forall a. Bits a => a -> a -> a
`xor` Double -> Bool
forall a. RealFloat a => a -> Bool
isNegativeZero Double
b = Bool
False
| Bool
otherwise = Double
a Double -> Double -> Bool
forall a. Eq a => a -> a -> Bool
== Double
b
instance Ord DhallDouble where
compare :: DhallDouble -> DhallDouble -> Ordering
compare a :: DhallDouble
a@(DhallDouble a' :: Double
a') b :: DhallDouble
b@(DhallDouble b' :: Double
b') =
if DhallDouble
a DhallDouble -> DhallDouble -> Bool
forall a. Eq a => a -> a -> Bool
== DhallDouble
b
then Ordering
EQ
else Double -> Double -> Ordering
forall a. Ord a => a -> a -> Ordering
compare Double
a' Double
b'
data Chunks s a = Chunks [(Text, Expr s a)] Text
deriving (a -> Chunks s b -> Chunks s a
(a -> b) -> Chunks s a -> Chunks s b
(forall a b. (a -> b) -> Chunks s a -> Chunks s b)
-> (forall a b. a -> Chunks s b -> Chunks s a)
-> Functor (Chunks s)
forall a b. a -> Chunks s b -> Chunks s a
forall a b. (a -> b) -> Chunks s a -> Chunks s b
forall s a b. a -> Chunks s b -> Chunks s a
forall s a b. (a -> b) -> Chunks s a -> Chunks s b
forall (f :: * -> *).
(forall a b. (a -> b) -> f a -> f b)
-> (forall a b. a -> f b -> f a) -> Functor f
<$ :: a -> Chunks s b -> Chunks s a
$c<$ :: forall s a b. a -> Chunks s b -> Chunks s a
fmap :: (a -> b) -> Chunks s a -> Chunks s b
$cfmap :: forall s a b. (a -> b) -> Chunks s a -> Chunks s b
Functor, Chunks s a -> Bool
(a -> m) -> Chunks s a -> m
(a -> b -> b) -> b -> Chunks s a -> b
(forall m. Monoid m => Chunks s m -> m)
-> (forall m a. Monoid m => (a -> m) -> Chunks s a -> m)
-> (forall m a. Monoid m => (a -> m) -> Chunks s a -> m)
-> (forall a b. (a -> b -> b) -> b -> Chunks s a -> b)
-> (forall a b. (a -> b -> b) -> b -> Chunks s a -> b)
-> (forall b a. (b -> a -> b) -> b -> Chunks s a -> b)
-> (forall b a. (b -> a -> b) -> b -> Chunks s a -> b)
-> (forall a. (a -> a -> a) -> Chunks s a -> a)
-> (forall a. (a -> a -> a) -> Chunks s a -> a)
-> (forall a. Chunks s a -> [a])
-> (forall a. Chunks s a -> Bool)
-> (forall a. Chunks s a -> Int)
-> (forall a. Eq a => a -> Chunks s a -> Bool)
-> (forall a. Ord a => Chunks s a -> a)
-> (forall a. Ord a => Chunks s a -> a)
-> (forall a. Num a => Chunks s a -> a)
-> (forall a. Num a => Chunks s a -> a)
-> Foldable (Chunks s)
forall a. Eq a => a -> Chunks s a -> Bool
forall a. Num a => Chunks s a -> a
forall a. Ord a => Chunks s a -> a
forall m. Monoid m => Chunks s m -> m
forall a. Chunks s a -> Bool
forall a. Chunks s a -> Int
forall a. Chunks s a -> [a]
forall a. (a -> a -> a) -> Chunks s a -> a
forall s a. Eq a => a -> Chunks s a -> Bool
forall s a. Num a => Chunks s a -> a
forall s a. Ord a => Chunks s a -> a
forall m a. Monoid m => (a -> m) -> Chunks s a -> m
forall s m. Monoid m => Chunks s m -> m
forall s a. Chunks s a -> Bool
forall s a. Chunks s a -> Int
forall s a. Chunks s a -> [a]
forall b a. (b -> a -> b) -> b -> Chunks s a -> b
forall a b. (a -> b -> b) -> b -> Chunks s a -> b
forall s a. (a -> a -> a) -> Chunks s a -> a
forall s m a. Monoid m => (a -> m) -> Chunks s a -> m
forall s b a. (b -> a -> b) -> b -> Chunks s a -> b
forall s a b. (a -> b -> b) -> b -> Chunks s a -> b
forall (t :: * -> *).
(forall m. Monoid m => t m -> m)
-> (forall m a. Monoid m => (a -> m) -> t a -> m)
-> (forall m a. Monoid m => (a -> m) -> t a -> m)
-> (forall a b. (a -> b -> b) -> b -> t a -> b)
-> (forall a b. (a -> b -> b) -> b -> t a -> b)
-> (forall b a. (b -> a -> b) -> b -> t a -> b)
-> (forall b a. (b -> a -> b) -> b -> t a -> b)
-> (forall a. (a -> a -> a) -> t a -> a)
-> (forall a. (a -> a -> a) -> t a -> a)
-> (forall a. t a -> [a])
-> (forall a. t a -> Bool)
-> (forall a. t a -> Int)
-> (forall a. Eq a => a -> t a -> Bool)
-> (forall a. Ord a => t a -> a)
-> (forall a. Ord a => t a -> a)
-> (forall a. Num a => t a -> a)
-> (forall a. Num a => t a -> a)
-> Foldable t
product :: Chunks s a -> a
$cproduct :: forall s a. Num a => Chunks s a -> a
sum :: Chunks s a -> a
$csum :: forall s a. Num a => Chunks s a -> a
minimum :: Chunks s a -> a
$cminimum :: forall s a. Ord a => Chunks s a -> a
maximum :: Chunks s a -> a
$cmaximum :: forall s a. Ord a => Chunks s a -> a
elem :: a -> Chunks s a -> Bool
$celem :: forall s a. Eq a => a -> Chunks s a -> Bool
length :: Chunks s a -> Int
$clength :: forall s a. Chunks s a -> Int
null :: Chunks s a -> Bool
$cnull :: forall s a. Chunks s a -> Bool
toList :: Chunks s a -> [a]
$ctoList :: forall s a. Chunks s a -> [a]
foldl1 :: (a -> a -> a) -> Chunks s a -> a
$cfoldl1 :: forall s a. (a -> a -> a) -> Chunks s a -> a
foldr1 :: (a -> a -> a) -> Chunks s a -> a
$cfoldr1 :: forall s a. (a -> a -> a) -> Chunks s a -> a
foldl' :: (b -> a -> b) -> b -> Chunks s a -> b
$cfoldl' :: forall s b a. (b -> a -> b) -> b -> Chunks s a -> b
foldl :: (b -> a -> b) -> b -> Chunks s a -> b
$cfoldl :: forall s b a. (b -> a -> b) -> b -> Chunks s a -> b
foldr' :: (a -> b -> b) -> b -> Chunks s a -> b
$cfoldr' :: forall s a b. (a -> b -> b) -> b -> Chunks s a -> b
foldr :: (a -> b -> b) -> b -> Chunks s a -> b
$cfoldr :: forall s a b. (a -> b -> b) -> b -> Chunks s a -> b
foldMap' :: (a -> m) -> Chunks s a -> m
$cfoldMap' :: forall s m a. Monoid m => (a -> m) -> Chunks s a -> m
foldMap :: (a -> m) -> Chunks s a -> m
$cfoldMap :: forall s m a. Monoid m => (a -> m) -> Chunks s a -> m
fold :: Chunks s m -> m
$cfold :: forall s m. Monoid m => Chunks s m -> m
Foldable, (forall x. Chunks s a -> Rep (Chunks s a) x)
-> (forall x. Rep (Chunks s a) x -> Chunks s a)
-> Generic (Chunks s a)
forall x. Rep (Chunks s a) x -> Chunks s a
forall x. Chunks s a -> Rep (Chunks s a) x
forall a.
(forall x. a -> Rep a x) -> (forall x. Rep a x -> a) -> Generic a
forall s a x. Rep (Chunks s a) x -> Chunks s a
forall s a x. Chunks s a -> Rep (Chunks s a) x
$cto :: forall s a x. Rep (Chunks s a) x -> Chunks s a
$cfrom :: forall s a x. Chunks s a -> Rep (Chunks s a) x
Generic, Functor (Chunks s)
Foldable (Chunks s)
(Functor (Chunks s), Foldable (Chunks s)) =>
(forall (f :: * -> *) a b.
Applicative f =>
(a -> f b) -> Chunks s a -> f (Chunks s b))
-> (forall (f :: * -> *) a.
Applicative f =>
Chunks s (f a) -> f (Chunks s a))
-> (forall (m :: * -> *) a b.
Monad m =>
(a -> m b) -> Chunks s a -> m (Chunks s b))
-> (forall (m :: * -> *) a.
Monad m =>
Chunks s (m a) -> m (Chunks s a))
-> Traversable (Chunks s)
(a -> f b) -> Chunks s a -> f (Chunks s b)
forall s. Functor (Chunks s)
forall s. Foldable (Chunks s)
forall s (m :: * -> *) a.
Monad m =>
Chunks s (m a) -> m (Chunks s a)
forall s (f :: * -> *) a.
Applicative f =>
Chunks s (f a) -> f (Chunks s a)
forall s (m :: * -> *) a b.
Monad m =>
(a -> m b) -> Chunks s a -> m (Chunks s b)
forall s (f :: * -> *) a b.
Applicative f =>
(a -> f b) -> Chunks s a -> f (Chunks s b)
forall (t :: * -> *).
(Functor t, Foldable t) =>
(forall (f :: * -> *) a b.
Applicative f =>
(a -> f b) -> t a -> f (t b))
-> (forall (f :: * -> *) a. Applicative f => t (f a) -> f (t a))
-> (forall (m :: * -> *) a b.
Monad m =>
(a -> m b) -> t a -> m (t b))
-> (forall (m :: * -> *) a. Monad m => t (m a) -> m (t a))
-> Traversable t
forall (m :: * -> *) a. Monad m => Chunks s (m a) -> m (Chunks s a)
forall (f :: * -> *) a.
Applicative f =>
Chunks s (f a) -> f (Chunks s a)
forall (m :: * -> *) a b.
Monad m =>
(a -> m b) -> Chunks s a -> m (Chunks s b)
forall (f :: * -> *) a b.
Applicative f =>
(a -> f b) -> Chunks s a -> f (Chunks s b)
sequence :: Chunks s (m a) -> m (Chunks s a)
$csequence :: forall s (m :: * -> *) a.
Monad m =>
Chunks s (m a) -> m (Chunks s a)
mapM :: (a -> m b) -> Chunks s a -> m (Chunks s b)
$cmapM :: forall s (m :: * -> *) a b.
Monad m =>
(a -> m b) -> Chunks s a -> m (Chunks s b)
sequenceA :: Chunks s (f a) -> f (Chunks s a)
$csequenceA :: forall s (f :: * -> *) a.
Applicative f =>
Chunks s (f a) -> f (Chunks s a)
traverse :: (a -> f b) -> Chunks s a -> f (Chunks s b)
$ctraverse :: forall s (f :: * -> *) a b.
Applicative f =>
(a -> f b) -> Chunks s a -> f (Chunks s b)
$cp2Traversable :: forall s. Foldable (Chunks s)
$cp1Traversable :: forall s. Functor (Chunks s)
Traversable, Int -> Chunks s a -> ShowS
[Chunks s a] -> ShowS
Chunks s a -> String
(Int -> Chunks s a -> ShowS)
-> (Chunks s a -> String)
-> ([Chunks s a] -> ShowS)
-> Show (Chunks s a)
forall a.
(Int -> a -> ShowS) -> (a -> String) -> ([a] -> ShowS) -> Show a
forall s a. (Show s, Show a) => Int -> Chunks s a -> ShowS
forall s a. (Show s, Show a) => [Chunks s a] -> ShowS
forall s a. (Show s, Show a) => Chunks s a -> String
showList :: [Chunks s a] -> ShowS
$cshowList :: forall s a. (Show s, Show a) => [Chunks s a] -> ShowS
show :: Chunks s a -> String
$cshow :: forall s a. (Show s, Show a) => Chunks s a -> String
showsPrec :: Int -> Chunks s a -> ShowS
$cshowsPrec :: forall s a. (Show s, Show a) => Int -> Chunks s a -> ShowS
Show, Chunks s a -> Chunks s a -> Bool
(Chunks s a -> Chunks s a -> Bool)
-> (Chunks s a -> Chunks s a -> Bool) -> Eq (Chunks s a)
forall a. (a -> a -> Bool) -> (a -> a -> Bool) -> Eq a
forall s a. (Eq s, Eq a) => Chunks s a -> Chunks s a -> Bool
/= :: Chunks s a -> Chunks s a -> Bool
$c/= :: forall s a. (Eq s, Eq a) => Chunks s a -> Chunks s a -> Bool
== :: Chunks s a -> Chunks s a -> Bool
$c== :: forall s a. (Eq s, Eq a) => Chunks s a -> Chunks s a -> Bool
Eq, Eq (Chunks s a)
Eq (Chunks s a) =>
(Chunks s a -> Chunks s a -> Ordering)
-> (Chunks s a -> Chunks s a -> Bool)
-> (Chunks s a -> Chunks s a -> Bool)
-> (Chunks s a -> Chunks s a -> Bool)
-> (Chunks s a -> Chunks s a -> Bool)
-> (Chunks s a -> Chunks s a -> Chunks s a)
-> (Chunks s a -> Chunks s a -> Chunks s a)
-> Ord (Chunks s a)
Chunks s a -> Chunks s a -> Bool
Chunks s a -> Chunks s a -> Ordering
Chunks s a -> Chunks s a -> Chunks s a
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 s a. (Ord s, Ord a) => Eq (Chunks s a)
forall s a. (Ord s, Ord a) => Chunks s a -> Chunks s a -> Bool
forall s a. (Ord s, Ord a) => Chunks s a -> Chunks s a -> Ordering
forall s a.
(Ord s, Ord a) =>
Chunks s a -> Chunks s a -> Chunks s a
min :: Chunks s a -> Chunks s a -> Chunks s a
$cmin :: forall s a.
(Ord s, Ord a) =>
Chunks s a -> Chunks s a -> Chunks s a
max :: Chunks s a -> Chunks s a -> Chunks s a
$cmax :: forall s a.
(Ord s, Ord a) =>
Chunks s a -> Chunks s a -> Chunks s a
>= :: Chunks s a -> Chunks s a -> Bool
$c>= :: forall s a. (Ord s, Ord a) => Chunks s a -> Chunks s a -> Bool
> :: Chunks s a -> Chunks s a -> Bool
$c> :: forall s a. (Ord s, Ord a) => Chunks s a -> Chunks s a -> Bool
<= :: Chunks s a -> Chunks s a -> Bool
$c<= :: forall s a. (Ord s, Ord a) => Chunks s a -> Chunks s a -> Bool
< :: Chunks s a -> Chunks s a -> Bool
$c< :: forall s a. (Ord s, Ord a) => Chunks s a -> Chunks s a -> Bool
compare :: Chunks s a -> Chunks s a -> Ordering
$ccompare :: forall s a. (Ord s, Ord a) => Chunks s a -> Chunks s a -> Ordering
$cp1Ord :: forall s a. (Ord s, Ord a) => Eq (Chunks s a)
Ord, Typeable (Chunks s a)
Constr
DataType
Typeable (Chunks s a) =>
(forall (c :: * -> *).
(forall d b. Data d => c (d -> b) -> d -> c b)
-> (forall g. g -> c g) -> Chunks s a -> c (Chunks s a))
-> (forall (c :: * -> *).
(forall b r. Data b => c (b -> r) -> c r)
-> (forall r. r -> c r) -> Constr -> c (Chunks s a))
-> (Chunks s a -> Constr)
-> (Chunks s a -> DataType)
-> (forall (t :: * -> *) (c :: * -> *).
Typeable t =>
(forall d. Data d => c (t d)) -> Maybe (c (Chunks s a)))
-> (forall (t :: * -> * -> *) (c :: * -> *).
Typeable t =>
(forall d e. (Data d, Data e) => c (t d e))
-> Maybe (c (Chunks s a)))
-> ((forall b. Data b => b -> b) -> Chunks s a -> Chunks s a)
-> (forall r r'.
(r -> r' -> r)
-> r -> (forall d. Data d => d -> r') -> Chunks s a -> r)
-> (forall r r'.
(r' -> r -> r)
-> r -> (forall d. Data d => d -> r') -> Chunks s a -> r)
-> (forall u. (forall d. Data d => d -> u) -> Chunks s a -> [u])
-> (forall u.
Int -> (forall d. Data d => d -> u) -> Chunks s a -> u)
-> (forall (m :: * -> *).
Monad m =>
(forall d. Data d => d -> m d) -> Chunks s a -> m (Chunks s a))
-> (forall (m :: * -> *).
MonadPlus m =>
(forall d. Data d => d -> m d) -> Chunks s a -> m (Chunks s a))
-> (forall (m :: * -> *).
MonadPlus m =>
(forall d. Data d => d -> m d) -> Chunks s a -> m (Chunks s a))
-> Data (Chunks s a)
Chunks s a -> Constr
Chunks s a -> DataType
(forall b. Data b => b -> b) -> Chunks s a -> Chunks s a
(forall d b. Data d => c (d -> b) -> d -> c b)
-> (forall g. g -> c g) -> Chunks s a -> c (Chunks s a)
(forall b r. Data b => c (b -> r) -> c r)
-> (forall r. r -> c r) -> Constr -> c (Chunks s a)
(forall d e. (Data d, Data e) => c (t d e))
-> Maybe (c (Chunks s a))
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) -> Chunks s a -> u
forall u. (forall d. Data d => d -> u) -> Chunks s a -> [u]
forall s a. (Data s, Data a) => Typeable (Chunks s a)
forall s a. (Data s, Data a) => Chunks s a -> Constr
forall s a. (Data s, Data a) => Chunks s a -> DataType
forall s a.
(Data s, Data a) =>
(forall b. Data b => b -> b) -> Chunks s a -> Chunks s a
forall s a u.
(Data s, Data a) =>
Int -> (forall d. Data d => d -> u) -> Chunks s a -> u
forall s a u.
(Data s, Data a) =>
(forall d. Data d => d -> u) -> Chunks s a -> [u]
forall s a r r'.
(Data s, Data a) =>
(r -> r' -> r)
-> r -> (forall d. Data d => d -> r') -> Chunks s a -> r
forall s a r r'.
(Data s, Data a) =>
(r' -> r -> r)
-> r -> (forall d. Data d => d -> r') -> Chunks s a -> r
forall s a (m :: * -> *).
(Data s, Data a, Monad m) =>
(forall d. Data d => d -> m d) -> Chunks s a -> m (Chunks s a)
forall s a (m :: * -> *).
(Data s, Data a, MonadPlus m) =>
(forall d. Data d => d -> m d) -> Chunks s a -> m (Chunks s a)
forall s a (c :: * -> *).
(Data s, Data a) =>
(forall b r. Data b => c (b -> r) -> c r)
-> (forall r. r -> c r) -> Constr -> c (Chunks s a)
forall s a (c :: * -> *).
(Data s, Data a) =>
(forall d b. Data d => c (d -> b) -> d -> c b)
-> (forall g. g -> c g) -> Chunks s a -> c (Chunks s a)
forall s a (t :: * -> *) (c :: * -> *).
(Data s, Data a, Typeable t) =>
(forall d. Data d => c (t d)) -> Maybe (c (Chunks s a))
forall s a (t :: * -> * -> *) (c :: * -> *).
(Data s, Data a, Typeable t) =>
(forall d e. (Data d, Data e) => c (t d e))
-> Maybe (c (Chunks s a))
forall r r'.
(r -> r' -> r)
-> r -> (forall d. Data d => d -> r') -> Chunks s a -> r
forall r r'.
(r' -> r -> r)
-> r -> (forall d. Data d => d -> r') -> Chunks s a -> r
forall (m :: * -> *).
Monad m =>
(forall d. Data d => d -> m d) -> Chunks s a -> m (Chunks s a)
forall (m :: * -> *).
MonadPlus m =>
(forall d. Data d => d -> m d) -> Chunks s a -> m (Chunks s a)
forall (c :: * -> *).
(forall b r. Data b => c (b -> r) -> c r)
-> (forall r. r -> c r) -> Constr -> c (Chunks s a)
forall (c :: * -> *).
(forall d b. Data d => c (d -> b) -> d -> c b)
-> (forall g. g -> c g) -> Chunks s a -> c (Chunks s a)
forall (t :: * -> *) (c :: * -> *).
Typeable t =>
(forall d. Data d => c (t d)) -> Maybe (c (Chunks s a))
forall (t :: * -> * -> *) (c :: * -> *).
Typeable t =>
(forall d e. (Data d, Data e) => c (t d e))
-> Maybe (c (Chunks s a))
$cChunks :: Constr
$tChunks :: DataType
gmapMo :: (forall d. Data d => d -> m d) -> Chunks s a -> m (Chunks s a)
$cgmapMo :: forall s a (m :: * -> *).
(Data s, Data a, MonadPlus m) =>
(forall d. Data d => d -> m d) -> Chunks s a -> m (Chunks s a)
gmapMp :: (forall d. Data d => d -> m d) -> Chunks s a -> m (Chunks s a)
$cgmapMp :: forall s a (m :: * -> *).
(Data s, Data a, MonadPlus m) =>
(forall d. Data d => d -> m d) -> Chunks s a -> m (Chunks s a)
gmapM :: (forall d. Data d => d -> m d) -> Chunks s a -> m (Chunks s a)
$cgmapM :: forall s a (m :: * -> *).
(Data s, Data a, Monad m) =>
(forall d. Data d => d -> m d) -> Chunks s a -> m (Chunks s a)
gmapQi :: Int -> (forall d. Data d => d -> u) -> Chunks s a -> u
$cgmapQi :: forall s a u.
(Data s, Data a) =>
Int -> (forall d. Data d => d -> u) -> Chunks s a -> u
gmapQ :: (forall d. Data d => d -> u) -> Chunks s a -> [u]
$cgmapQ :: forall s a u.
(Data s, Data a) =>
(forall d. Data d => d -> u) -> Chunks s a -> [u]
gmapQr :: (r' -> r -> r)
-> r -> (forall d. Data d => d -> r') -> Chunks s a -> r
$cgmapQr :: forall s a r r'.
(Data s, Data a) =>
(r' -> r -> r)
-> r -> (forall d. Data d => d -> r') -> Chunks s a -> r
gmapQl :: (r -> r' -> r)
-> r -> (forall d. Data d => d -> r') -> Chunks s a -> r
$cgmapQl :: forall s a r r'.
(Data s, Data a) =>
(r -> r' -> r)
-> r -> (forall d. Data d => d -> r') -> Chunks s a -> r
gmapT :: (forall b. Data b => b -> b) -> Chunks s a -> Chunks s a
$cgmapT :: forall s a.
(Data s, Data a) =>
(forall b. Data b => b -> b) -> Chunks s a -> Chunks s a
dataCast2 :: (forall d e. (Data d, Data e) => c (t d e))
-> Maybe (c (Chunks s a))
$cdataCast2 :: forall s a (t :: * -> * -> *) (c :: * -> *).
(Data s, Data a, Typeable t) =>
(forall d e. (Data d, Data e) => c (t d e))
-> Maybe (c (Chunks s a))
dataCast1 :: (forall d. Data d => c (t d)) -> Maybe (c (Chunks s a))
$cdataCast1 :: forall s a (t :: * -> *) (c :: * -> *).
(Data s, Data a, Typeable t) =>
(forall d. Data d => c (t d)) -> Maybe (c (Chunks s a))
dataTypeOf :: Chunks s a -> DataType
$cdataTypeOf :: forall s a. (Data s, Data a) => Chunks s a -> DataType
toConstr :: Chunks s a -> Constr
$ctoConstr :: forall s a. (Data s, Data a) => Chunks s a -> Constr
gunfold :: (forall b r. Data b => c (b -> r) -> c r)
-> (forall r. r -> c r) -> Constr -> c (Chunks s a)
$cgunfold :: forall s a (c :: * -> *).
(Data s, Data a) =>
(forall b r. Data b => c (b -> r) -> c r)
-> (forall r. r -> c r) -> Constr -> c (Chunks s a)
gfoldl :: (forall d b. Data d => c (d -> b) -> d -> c b)
-> (forall g. g -> c g) -> Chunks s a -> c (Chunks s a)
$cgfoldl :: forall s a (c :: * -> *).
(Data s, Data a) =>
(forall d b. Data d => c (d -> b) -> d -> c b)
-> (forall g. g -> c g) -> Chunks s a -> c (Chunks s a)
$cp1Data :: forall s a. (Data s, Data a) => Typeable (Chunks s a)
Data, Chunks s a -> ()
(Chunks s a -> ()) -> NFData (Chunks s a)
forall a. (a -> ()) -> NFData a
forall s a. (NFData s, NFData a) => Chunks s a -> ()
rnf :: Chunks s a -> ()
$crnf :: forall s a. (NFData s, NFData a) => Chunks s a -> ()
NFData)
instance (Lift s, Lift a, Data s, Data a) => Lift (Chunks s a) where
lift :: Chunks s a -> Q Exp
lift = Chunks s a -> Q Exp
forall a. Data a => a -> Q Exp
Syntax.liftData
instance Data.Semigroup.Semigroup (Chunks s a) where
Chunks xysL :: [(Text, Expr s a)]
xysL zL :: Text
zL <> :: Chunks s a -> Chunks s a -> Chunks s a
<> Chunks [] zR :: Text
zR =
[(Text, Expr s a)] -> Text -> Chunks s a
forall s a. [(Text, Expr s a)] -> Text -> Chunks s a
Chunks [(Text, Expr s a)]
xysL (Text
zL Text -> Text -> Text
forall a. Semigroup a => a -> a -> a
<> Text
zR)
Chunks xysL :: [(Text, Expr s a)]
xysL zL :: Text
zL <> Chunks ((x :: Text
x, y :: Expr s a
y):xysR :: [(Text, Expr s a)]
xysR) zR :: Text
zR =
[(Text, Expr s a)] -> Text -> Chunks s a
forall s a. [(Text, Expr s a)] -> Text -> Chunks s a
Chunks ([(Text, Expr s a)]
xysL [(Text, Expr s a)] -> [(Text, Expr s a)] -> [(Text, Expr s a)]
forall a. [a] -> [a] -> [a]
++ (Text
zL Text -> Text -> Text
forall a. Semigroup a => a -> a -> a
<> Text
x, Expr s a
y)(Text, Expr s a) -> [(Text, Expr s a)] -> [(Text, Expr s a)]
forall a. a -> [a] -> [a]
:[(Text, Expr s a)]
xysR) Text
zR
instance Monoid (Chunks s a) where
mempty :: Chunks s a
mempty = [(Text, Expr s a)] -> Text -> Chunks s a
forall s a. [(Text, Expr s a)] -> Text -> Chunks s a
Chunks [] Text
forall a. Monoid a => a
mempty
#if !(MIN_VERSION_base(4,11,0))
mappend = (<>)
#endif
instance IsString (Chunks s a) where
fromString :: String -> Chunks s a
fromString str :: String
str = [(Text, Expr s a)] -> Text -> Chunks s a
forall s a. [(Text, Expr s a)] -> Text -> Chunks s a
Chunks [] (String -> Text
forall a. IsString a => String -> a
fromString String
str)
data Expr s a
= Const Const
| Var Var
| Lam Text (Expr s a) (Expr s a)
| Pi Text (Expr s a) (Expr s a)
| App (Expr s a) (Expr s a)
| Let (Binding s a) (Expr s a)
| Annot (Expr s a) (Expr s a)
| Bool
| BoolLit Bool
| BoolAnd (Expr s a) (Expr s a)
| BoolOr (Expr s a) (Expr s a)
| BoolEQ (Expr s a) (Expr s a)
| BoolNE (Expr s a) (Expr s a)
| BoolIf (Expr s a) (Expr s a) (Expr s a)
| Natural
| NaturalLit Natural
| NaturalFold
| NaturalBuild
| NaturalIsZero
| NaturalEven
| NaturalOdd
| NaturalToInteger
| NaturalShow
| NaturalSubtract
| NaturalPlus (Expr s a) (Expr s a)
| NaturalTimes (Expr s a) (Expr s a)
| Integer
| IntegerLit Integer
| IntegerClamp
| IntegerNegate
| IntegerShow
| IntegerToDouble
| Double
| DoubleLit DhallDouble
| DoubleShow
| Text
| TextLit (Chunks s a)
| TextAppend (Expr s a) (Expr s a)
| TextShow
| List
| ListLit (Maybe (Expr s a)) (Seq (Expr s a))
| ListAppend (Expr s a) (Expr s a)
| ListBuild
| ListFold
| ListLength
| ListHead
| ListLast
| ListIndexed
| ListReverse
| Optional
| Some (Expr s a)
| None
| OptionalFold
| OptionalBuild
| Record (Map Text (Expr s a))
| RecordLit (Map Text (Expr s a))
| Union (Map Text (Maybe (Expr s a)))
| Combine (Maybe Text) (Expr s a) (Expr s a)
| CombineTypes (Expr s a) (Expr s a)
| Prefer (Expr s a) (Expr s a)
| RecordCompletion (Expr s a) (Expr s a)
| Merge (Expr s a) (Expr s a) (Maybe (Expr s a))
| ToMap (Expr s a) (Maybe (Expr s a))
| Field (Expr s a) Text
| Project (Expr s a) (Either (Set Text) (Expr s a))
| Assert (Expr s a)
| Equivalent (Expr s a) (Expr s a)
| Note s (Expr s a)
| ImportAlt (Expr s a) (Expr s a)
| Embed a
deriving (Expr s a -> Bool
(a -> m) -> Expr s a -> m
(a -> b -> b) -> b -> Expr s a -> b
(forall m. Monoid m => Expr s m -> m)
-> (forall m a. Monoid m => (a -> m) -> Expr s a -> m)
-> (forall m a. Monoid m => (a -> m) -> Expr s a -> m)
-> (forall a b. (a -> b -> b) -> b -> Expr s a -> b)
-> (forall a b. (a -> b -> b) -> b -> Expr s a -> b)
-> (forall b a. (b -> a -> b) -> b -> Expr s a -> b)
-> (forall b a. (b -> a -> b) -> b -> Expr s a -> b)
-> (forall a. (a -> a -> a) -> Expr s a -> a)
-> (forall a. (a -> a -> a) -> Expr s a -> a)
-> (forall a. Expr s a -> [a])
-> (forall a. Expr s a -> Bool)
-> (forall a. Expr s a -> Int)
-> (forall a. Eq a => a -> Expr s a -> Bool)
-> (forall a. Ord a => Expr s a -> a)
-> (forall a. Ord a => Expr s a -> a)
-> (forall a. Num a => Expr s a -> a)
-> (forall a. Num a => Expr s a -> a)
-> Foldable (Expr s)
forall a. Eq a => a -> Expr s a -> Bool
forall a. Num a => Expr s a -> a
forall a. Ord a => Expr s a -> a
forall m. Monoid m => Expr s m -> m
forall a. Expr s a -> Bool
forall a. Expr s a -> Int
forall a. Expr s a -> [a]
forall a. (a -> a -> a) -> Expr s a -> a
forall s a. Eq a => a -> Expr s a -> Bool
forall s a. Num a => Expr s a -> a
forall s a. Ord a => Expr s a -> a
forall m a. Monoid m => (a -> m) -> Expr s a -> m
forall s m. Monoid m => Expr s m -> m
forall s a. Expr s a -> Bool
forall s a. Expr s a -> Int
forall s a. Expr s a -> [a]
forall b a. (b -> a -> b) -> b -> Expr s a -> b
forall a b. (a -> b -> b) -> b -> Expr s a -> b
forall s a. (a -> a -> a) -> Expr s a -> a
forall s m a. Monoid m => (a -> m) -> Expr s a -> m
forall s b a. (b -> a -> b) -> b -> Expr s a -> b
forall s a b. (a -> b -> b) -> b -> Expr s a -> b
forall (t :: * -> *).
(forall m. Monoid m => t m -> m)
-> (forall m a. Monoid m => (a -> m) -> t a -> m)
-> (forall m a. Monoid m => (a -> m) -> t a -> m)
-> (forall a b. (a -> b -> b) -> b -> t a -> b)
-> (forall a b. (a -> b -> b) -> b -> t a -> b)
-> (forall b a. (b -> a -> b) -> b -> t a -> b)
-> (forall b a. (b -> a -> b) -> b -> t a -> b)
-> (forall a. (a -> a -> a) -> t a -> a)
-> (forall a. (a -> a -> a) -> t a -> a)
-> (forall a. t a -> [a])
-> (forall a. t a -> Bool)
-> (forall a. t a -> Int)
-> (forall a. Eq a => a -> t a -> Bool)
-> (forall a. Ord a => t a -> a)
-> (forall a. Ord a => t a -> a)
-> (forall a. Num a => t a -> a)
-> (forall a. Num a => t a -> a)
-> Foldable t
product :: Expr s a -> a
$cproduct :: forall s a. Num a => Expr s a -> a
sum :: Expr s a -> a
$csum :: forall s a. Num a => Expr s a -> a
minimum :: Expr s a -> a
$cminimum :: forall s a. Ord a => Expr s a -> a
maximum :: Expr s a -> a
$cmaximum :: forall s a. Ord a => Expr s a -> a
elem :: a -> Expr s a -> Bool
$celem :: forall s a. Eq a => a -> Expr s a -> Bool
length :: Expr s a -> Int
$clength :: forall s a. Expr s a -> Int
null :: Expr s a -> Bool
$cnull :: forall s a. Expr s a -> Bool
toList :: Expr s a -> [a]
$ctoList :: forall s a. Expr s a -> [a]
foldl1 :: (a -> a -> a) -> Expr s a -> a
$cfoldl1 :: forall s a. (a -> a -> a) -> Expr s a -> a
foldr1 :: (a -> a -> a) -> Expr s a -> a
$cfoldr1 :: forall s a. (a -> a -> a) -> Expr s a -> a
foldl' :: (b -> a -> b) -> b -> Expr s a -> b
$cfoldl' :: forall s b a. (b -> a -> b) -> b -> Expr s a -> b
foldl :: (b -> a -> b) -> b -> Expr s a -> b
$cfoldl :: forall s b a. (b -> a -> b) -> b -> Expr s a -> b
foldr' :: (a -> b -> b) -> b -> Expr s a -> b
$cfoldr' :: forall s a b. (a -> b -> b) -> b -> Expr s a -> b
foldr :: (a -> b -> b) -> b -> Expr s a -> b
$cfoldr :: forall s a b. (a -> b -> b) -> b -> Expr s a -> b
foldMap' :: (a -> m) -> Expr s a -> m
$cfoldMap' :: forall s m a. Monoid m => (a -> m) -> Expr s a -> m
foldMap :: (a -> m) -> Expr s a -> m
$cfoldMap :: forall s m a. Monoid m => (a -> m) -> Expr s a -> m
fold :: Expr s m -> m
$cfold :: forall s m. Monoid m => Expr s m -> m
Foldable, (forall x. Expr s a -> Rep (Expr s a) x)
-> (forall x. Rep (Expr s a) x -> Expr s a) -> Generic (Expr s a)
forall x. Rep (Expr s a) x -> Expr s a
forall x. Expr s a -> Rep (Expr s a) x
forall a.
(forall x. a -> Rep a x) -> (forall x. Rep a x -> a) -> Generic a
forall s a x. Rep (Expr s a) x -> Expr s a
forall s a x. Expr s a -> Rep (Expr s a) x
$cto :: forall s a x. Rep (Expr s a) x -> Expr s a
$cfrom :: forall s a x. Expr s a -> Rep (Expr s a) x
Generic, Functor (Expr s)
Foldable (Expr s)
(Functor (Expr s), Foldable (Expr s)) =>
(forall (f :: * -> *) a b.
Applicative f =>
(a -> f b) -> Expr s a -> f (Expr s b))
-> (forall (f :: * -> *) a.
Applicative f =>
Expr s (f a) -> f (Expr s a))
-> (forall (m :: * -> *) a b.
Monad m =>
(a -> m b) -> Expr s a -> m (Expr s b))
-> (forall (m :: * -> *) a.
Monad m =>
Expr s (m a) -> m (Expr s a))
-> Traversable (Expr s)
(a -> f b) -> Expr s a -> f (Expr s b)
forall s. Functor (Expr s)
forall s. Foldable (Expr s)
forall s (m :: * -> *) a. Monad m => Expr s (m a) -> m (Expr s a)
forall s (f :: * -> *) a.
Applicative f =>
Expr s (f a) -> f (Expr s a)
forall s (m :: * -> *) a b.
Monad m =>
(a -> m b) -> Expr s a -> m (Expr s b)
forall s (f :: * -> *) a b.
Applicative f =>
(a -> f b) -> Expr s a -> f (Expr s b)
forall (t :: * -> *).
(Functor t, Foldable t) =>
(forall (f :: * -> *) a b.
Applicative f =>
(a -> f b) -> t a -> f (t b))
-> (forall (f :: * -> *) a. Applicative f => t (f a) -> f (t a))
-> (forall (m :: * -> *) a b.
Monad m =>
(a -> m b) -> t a -> m (t b))
-> (forall (m :: * -> *) a. Monad m => t (m a) -> m (t a))
-> Traversable t
forall (m :: * -> *) a. Monad m => Expr s (m a) -> m (Expr s a)
forall (f :: * -> *) a.
Applicative f =>
Expr s (f a) -> f (Expr s a)
forall (m :: * -> *) a b.
Monad m =>
(a -> m b) -> Expr s a -> m (Expr s b)
forall (f :: * -> *) a b.
Applicative f =>
(a -> f b) -> Expr s a -> f (Expr s b)
sequence :: Expr s (m a) -> m (Expr s a)
$csequence :: forall s (m :: * -> *) a. Monad m => Expr s (m a) -> m (Expr s a)
mapM :: (a -> m b) -> Expr s a -> m (Expr s b)
$cmapM :: forall s (m :: * -> *) a b.
Monad m =>
(a -> m b) -> Expr s a -> m (Expr s b)
sequenceA :: Expr s (f a) -> f (Expr s a)
$csequenceA :: forall s (f :: * -> *) a.
Applicative f =>
Expr s (f a) -> f (Expr s a)
traverse :: (a -> f b) -> Expr s a -> f (Expr s b)
$ctraverse :: forall s (f :: * -> *) a b.
Applicative f =>
(a -> f b) -> Expr s a -> f (Expr s b)
$cp2Traversable :: forall s. Foldable (Expr s)
$cp1Traversable :: forall s. Functor (Expr s)
Traversable, Int -> Expr s a -> ShowS
[Expr s a] -> ShowS
Expr s a -> String
(Int -> Expr s a -> ShowS)
-> (Expr s a -> String) -> ([Expr s a] -> ShowS) -> Show (Expr s a)
forall a.
(Int -> a -> ShowS) -> (a -> String) -> ([a] -> ShowS) -> Show a
forall s a. (Show s, Show a) => Int -> Expr s a -> ShowS
forall s a. (Show s, Show a) => [Expr s a] -> ShowS
forall s a. (Show s, Show a) => Expr s a -> String
showList :: [Expr s a] -> ShowS
$cshowList :: forall s a. (Show s, Show a) => [Expr s a] -> ShowS
show :: Expr s a -> String
$cshow :: forall s a. (Show s, Show a) => Expr s a -> String
showsPrec :: Int -> Expr s a -> ShowS
$cshowsPrec :: forall s a. (Show s, Show a) => Int -> Expr s a -> ShowS
Show, Typeable (Expr s a)
Constr
DataType
Typeable (Expr s a) =>
(forall (c :: * -> *).
(forall d b. Data d => c (d -> b) -> d -> c b)
-> (forall g. g -> c g) -> Expr s a -> c (Expr s a))
-> (forall (c :: * -> *).
(forall b r. Data b => c (b -> r) -> c r)
-> (forall r. r -> c r) -> Constr -> c (Expr s a))
-> (Expr s a -> Constr)
-> (Expr s a -> DataType)
-> (forall (t :: * -> *) (c :: * -> *).
Typeable t =>
(forall d. Data d => c (t d)) -> Maybe (c (Expr s a)))
-> (forall (t :: * -> * -> *) (c :: * -> *).
Typeable t =>
(forall d e. (Data d, Data e) => c (t d e))
-> Maybe (c (Expr s a)))
-> ((forall b. Data b => b -> b) -> Expr s a -> Expr s a)
-> (forall r r'.
(r -> r' -> r)
-> r -> (forall d. Data d => d -> r') -> Expr s a -> r)
-> (forall r r'.
(r' -> r -> r)
-> r -> (forall d. Data d => d -> r') -> Expr s a -> r)
-> (forall u. (forall d. Data d => d -> u) -> Expr s a -> [u])
-> (forall u. Int -> (forall d. Data d => d -> u) -> Expr s a -> u)
-> (forall (m :: * -> *).
Monad m =>
(forall d. Data d => d -> m d) -> Expr s a -> m (Expr s a))
-> (forall (m :: * -> *).
MonadPlus m =>
(forall d. Data d => d -> m d) -> Expr s a -> m (Expr s a))
-> (forall (m :: * -> *).
MonadPlus m =>
(forall d. Data d => d -> m d) -> Expr s a -> m (Expr s a))
-> Data (Expr s a)
Expr s a -> Constr
Expr s a -> DataType
(forall b. Data b => b -> b) -> Expr s a -> Expr s a
(forall d b. Data d => c (d -> b) -> d -> c b)
-> (forall g. g -> c g) -> Expr s a -> c (Expr s a)
(forall b r. Data b => c (b -> r) -> c r)
-> (forall r. r -> c r) -> Constr -> c (Expr s a)
(forall d e. (Data d, Data e) => c (t d e)) -> Maybe (c (Expr s a))
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) -> Expr s a -> u
forall u. (forall d. Data d => d -> u) -> Expr s a -> [u]
forall s a. (Data s, Data a) => Typeable (Expr s a)
forall s a. (Data s, Data a) => Expr s a -> Constr
forall s a. (Data s, Data a) => Expr s a -> DataType
forall s a.
(Data s, Data a) =>
(forall b. Data b => b -> b) -> Expr s a -> Expr s a
forall s a u.
(Data s, Data a) =>
Int -> (forall d. Data d => d -> u) -> Expr s a -> u
forall s a u.
(Data s, Data a) =>
(forall d. Data d => d -> u) -> Expr s a -> [u]
forall s a r r'.
(Data s, Data a) =>
(r -> r' -> r)
-> r -> (forall d. Data d => d -> r') -> Expr s a -> r
forall s a r r'.
(Data s, Data a) =>
(r' -> r -> r)
-> r -> (forall d. Data d => d -> r') -> Expr s a -> r
forall s a (m :: * -> *).
(Data s, Data a, Monad m) =>
(forall d. Data d => d -> m d) -> Expr s a -> m (Expr s a)
forall s a (m :: * -> *).
(Data s, Data a, MonadPlus m) =>
(forall d. Data d => d -> m d) -> Expr s a -> m (Expr s a)
forall s a (c :: * -> *).
(Data s, Data a) =>
(forall b r. Data b => c (b -> r) -> c r)
-> (forall r. r -> c r) -> Constr -> c (Expr s a)
forall s a (c :: * -> *).
(Data s, Data a) =>
(forall d b. Data d => c (d -> b) -> d -> c b)
-> (forall g. g -> c g) -> Expr s a -> c (Expr s a)
forall s a (t :: * -> *) (c :: * -> *).
(Data s, Data a, Typeable t) =>
(forall d. Data d => c (t d)) -> Maybe (c (Expr s a))
forall s a (t :: * -> * -> *) (c :: * -> *).
(Data s, Data a, Typeable t) =>
(forall d e. (Data d, Data e) => c (t d e)) -> Maybe (c (Expr s a))
forall r r'.
(r -> r' -> r)
-> r -> (forall d. Data d => d -> r') -> Expr s a -> r
forall r r'.
(r' -> r -> r)
-> r -> (forall d. Data d => d -> r') -> Expr s a -> r
forall (m :: * -> *).
Monad m =>
(forall d. Data d => d -> m d) -> Expr s a -> m (Expr s a)
forall (m :: * -> *).
MonadPlus m =>
(forall d. Data d => d -> m d) -> Expr s a -> m (Expr s a)
forall (c :: * -> *).
(forall b r. Data b => c (b -> r) -> c r)
-> (forall r. r -> c r) -> Constr -> c (Expr s a)
forall (c :: * -> *).
(forall d b. Data d => c (d -> b) -> d -> c b)
-> (forall g. g -> c g) -> Expr s a -> c (Expr s a)
forall (t :: * -> *) (c :: * -> *).
Typeable t =>
(forall d. Data d => c (t d)) -> Maybe (c (Expr s a))
forall (t :: * -> * -> *) (c :: * -> *).
Typeable t =>
(forall d e. (Data d, Data e) => c (t d e)) -> Maybe (c (Expr s a))
$cEmbed :: Constr
$cImportAlt :: Constr
$cNote :: Constr
$cEquivalent :: Constr
$cAssert :: Constr
$cProject :: Constr
$cField :: Constr
$cToMap :: Constr
$cMerge :: Constr
$cRecordCompletion :: Constr
$cPrefer :: Constr
$cCombineTypes :: Constr
$cCombine :: Constr
$cUnion :: Constr
$cRecordLit :: Constr
$cRecord :: Constr
$cOptionalBuild :: Constr
$cOptionalFold :: Constr
$cNone :: Constr
$cSome :: Constr
$cOptional :: Constr
$cListReverse :: Constr
$cListIndexed :: Constr
$cListLast :: Constr
$cListHead :: Constr
$cListLength :: Constr
$cListFold :: Constr
$cListBuild :: Constr
$cListAppend :: Constr
$cListLit :: Constr
$cList :: Constr
$cTextShow :: Constr
$cTextAppend :: Constr
$cTextLit :: Constr
$cText :: Constr
$cDoubleShow :: Constr
$cDoubleLit :: Constr
$cDouble :: Constr
$cIntegerToDouble :: Constr
$cIntegerShow :: Constr
$cIntegerNegate :: Constr
$cIntegerClamp :: Constr
$cIntegerLit :: Constr
$cInteger :: Constr
$cNaturalTimes :: Constr
$cNaturalPlus :: Constr
$cNaturalSubtract :: Constr
$cNaturalShow :: Constr
$cNaturalToInteger :: Constr
$cNaturalOdd :: Constr
$cNaturalEven :: Constr
$cNaturalIsZero :: Constr
$cNaturalBuild :: Constr
$cNaturalFold :: Constr
$cNaturalLit :: Constr
$cNatural :: Constr
$cBoolIf :: Constr
$cBoolNE :: Constr
$cBoolEQ :: Constr
$cBoolOr :: Constr
$cBoolAnd :: Constr
$cBoolLit :: Constr
$cBool :: Constr
$cAnnot :: Constr
$cLet :: Constr
$cApp :: Constr
$cPi :: Constr
$cLam :: Constr
$cVar :: Constr
$cConst :: Constr
$tExpr :: DataType
gmapMo :: (forall d. Data d => d -> m d) -> Expr s a -> m (Expr s a)
$cgmapMo :: forall s a (m :: * -> *).
(Data s, Data a, MonadPlus m) =>
(forall d. Data d => d -> m d) -> Expr s a -> m (Expr s a)
gmapMp :: (forall d. Data d => d -> m d) -> Expr s a -> m (Expr s a)
$cgmapMp :: forall s a (m :: * -> *).
(Data s, Data a, MonadPlus m) =>
(forall d. Data d => d -> m d) -> Expr s a -> m (Expr s a)
gmapM :: (forall d. Data d => d -> m d) -> Expr s a -> m (Expr s a)
$cgmapM :: forall s a (m :: * -> *).
(Data s, Data a, Monad m) =>
(forall d. Data d => d -> m d) -> Expr s a -> m (Expr s a)
gmapQi :: Int -> (forall d. Data d => d -> u) -> Expr s a -> u
$cgmapQi :: forall s a u.
(Data s, Data a) =>
Int -> (forall d. Data d => d -> u) -> Expr s a -> u
gmapQ :: (forall d. Data d => d -> u) -> Expr s a -> [u]
$cgmapQ :: forall s a u.
(Data s, Data a) =>
(forall d. Data d => d -> u) -> Expr s a -> [u]
gmapQr :: (r' -> r -> r)
-> r -> (forall d. Data d => d -> r') -> Expr s a -> r
$cgmapQr :: forall s a r r'.
(Data s, Data a) =>
(r' -> r -> r)
-> r -> (forall d. Data d => d -> r') -> Expr s a -> r
gmapQl :: (r -> r' -> r)
-> r -> (forall d. Data d => d -> r') -> Expr s a -> r
$cgmapQl :: forall s a r r'.
(Data s, Data a) =>
(r -> r' -> r)
-> r -> (forall d. Data d => d -> r') -> Expr s a -> r
gmapT :: (forall b. Data b => b -> b) -> Expr s a -> Expr s a
$cgmapT :: forall s a.
(Data s, Data a) =>
(forall b. Data b => b -> b) -> Expr s a -> Expr s a
dataCast2 :: (forall d e. (Data d, Data e) => c (t d e)) -> Maybe (c (Expr s a))
$cdataCast2 :: forall s a (t :: * -> * -> *) (c :: * -> *).
(Data s, Data a, Typeable t) =>
(forall d e. (Data d, Data e) => c (t d e)) -> Maybe (c (Expr s a))
dataCast1 :: (forall d. Data d => c (t d)) -> Maybe (c (Expr s a))
$cdataCast1 :: forall s a (t :: * -> *) (c :: * -> *).
(Data s, Data a, Typeable t) =>
(forall d. Data d => c (t d)) -> Maybe (c (Expr s a))
dataTypeOf :: Expr s a -> DataType
$cdataTypeOf :: forall s a. (Data s, Data a) => Expr s a -> DataType
toConstr :: Expr s a -> Constr
$ctoConstr :: forall s a. (Data s, Data a) => Expr s a -> Constr
gunfold :: (forall b r. Data b => c (b -> r) -> c r)
-> (forall r. r -> c r) -> Constr -> c (Expr s a)
$cgunfold :: forall s a (c :: * -> *).
(Data s, Data a) =>
(forall b r. Data b => c (b -> r) -> c r)
-> (forall r. r -> c r) -> Constr -> c (Expr s a)
gfoldl :: (forall d b. Data d => c (d -> b) -> d -> c b)
-> (forall g. g -> c g) -> Expr s a -> c (Expr s a)
$cgfoldl :: forall s a (c :: * -> *).
(Data s, Data a) =>
(forall d b. Data d => c (d -> b) -> d -> c b)
-> (forall g. g -> c g) -> Expr s a -> c (Expr s a)
$cp1Data :: forall s a. (Data s, Data a) => Typeable (Expr s a)
Data, Expr s a -> ()
(Expr s a -> ()) -> NFData (Expr s a)
forall a. (a -> ()) -> NFData a
forall s a. (NFData s, NFData a) => Expr s a -> ()
rnf :: Expr s a -> ()
$crnf :: forall s a. (NFData s, NFData a) => Expr s a -> ()
NFData)
deriving instance (Eq s, Eq a) => Eq (Expr s a)
deriving instance (Ord s, Ord a) => Ord (Expr s a)
instance (Lift s, Lift a, Data s, Data a) => Lift (Expr s a) where
lift :: Expr s a -> Q Exp
lift = Expr s a -> Q Exp
forall a. Data a => a -> Q Exp
Syntax.liftData
instance Functor (Expr s) where
fmap :: (a -> b) -> Expr s a -> Expr s b
fmap _ (Const c :: Const
c) = Const -> Expr s b
forall s a. Const -> Expr s a
Const Const
c
fmap _ (Var v :: Var
v) = Var -> Expr s b
forall s a. Var -> Expr s a
Var Var
v
fmap f :: a -> b
f (Lam v :: Text
v e1 :: Expr s a
e1 e2 :: Expr s a
e2) = Text -> Expr s b -> Expr s b -> Expr s b
forall s a. Text -> Expr s a -> Expr s a -> Expr s a
Lam Text
v ((a -> b) -> Expr s a -> Expr s b
forall (f :: * -> *) a b. Functor f => (a -> b) -> f a -> f b
fmap a -> b
f Expr s a
e1) ((a -> b) -> Expr s a -> Expr s b
forall (f :: * -> *) a b. Functor f => (a -> b) -> f a -> f b
fmap a -> b
f Expr s a
e2)
fmap f :: a -> b
f (Pi v :: Text
v e1 :: Expr s a
e1 e2 :: Expr s a
e2) = Text -> Expr s b -> Expr s b -> Expr s b
forall s a. Text -> Expr s a -> Expr s a -> Expr s a
Pi Text
v ((a -> b) -> Expr s a -> Expr s b
forall (f :: * -> *) a b. Functor f => (a -> b) -> f a -> f b
fmap a -> b
f Expr s a
e1) ((a -> b) -> Expr s a -> Expr s b
forall (f :: * -> *) a b. Functor f => (a -> b) -> f a -> f b
fmap a -> b
f Expr s a
e2)
fmap f :: a -> b
f (App e1 :: Expr s a
e1 e2 :: Expr s a
e2) = Expr s b -> Expr s b -> Expr s b
forall s a. Expr s a -> Expr s a -> Expr s a
App ((a -> b) -> Expr s a -> Expr s b
forall (f :: * -> *) a b. Functor f => (a -> b) -> f a -> f b
fmap a -> b
f Expr s a
e1) ((a -> b) -> Expr s a -> Expr s b
forall (f :: * -> *) a b. Functor f => (a -> b) -> f a -> f b
fmap a -> b
f Expr s a
e2)
fmap f :: a -> b
f (Let b :: Binding s a
b e2 :: Expr s a
e2) = Binding s b -> Expr s b -> Expr s b
forall s a. Binding s a -> Expr s a -> Expr s a
Let ((a -> b) -> Binding s a -> Binding s b
forall (f :: * -> *) a b. Functor f => (a -> b) -> f a -> f b
fmap a -> b
f Binding s a
b) ((a -> b) -> Expr s a -> Expr s b
forall (f :: * -> *) a b. Functor f => (a -> b) -> f a -> f b
fmap a -> b
f Expr s a
e2)
fmap f :: a -> b
f (Annot e1 :: Expr s a
e1 e2 :: Expr s a
e2) = Expr s b -> Expr s b -> Expr s b
forall s a. Expr s a -> Expr s a -> Expr s a
Annot ((a -> b) -> Expr s a -> Expr s b
forall (f :: * -> *) a b. Functor f => (a -> b) -> f a -> f b
fmap a -> b
f Expr s a
e1) ((a -> b) -> Expr s a -> Expr s b
forall (f :: * -> *) a b. Functor f => (a -> b) -> f a -> f b
fmap a -> b
f Expr s a
e2)
fmap _ Bool = Expr s b
forall s a. Expr s a
Bool
fmap _ (BoolLit b :: Bool
b) = Bool -> Expr s b
forall s a. Bool -> Expr s a
BoolLit Bool
b
fmap f :: a -> b
f (BoolAnd e1 :: Expr s a
e1 e2 :: Expr s a
e2) = Expr s b -> Expr s b -> Expr s b
forall s a. Expr s a -> Expr s a -> Expr s a
BoolAnd ((a -> b) -> Expr s a -> Expr s b
forall (f :: * -> *) a b. Functor f => (a -> b) -> f a -> f b
fmap a -> b
f Expr s a
e1) ((a -> b) -> Expr s a -> Expr s b
forall (f :: * -> *) a b. Functor f => (a -> b) -> f a -> f b
fmap a -> b
f Expr s a
e2)
fmap f :: a -> b
f (BoolOr e1 :: Expr s a
e1 e2 :: Expr s a
e2) = Expr s b -> Expr s b -> Expr s b
forall s a. Expr s a -> Expr s a -> Expr s a
BoolOr ((a -> b) -> Expr s a -> Expr s b
forall (f :: * -> *) a b. Functor f => (a -> b) -> f a -> f b
fmap a -> b
f Expr s a
e1) ((a -> b) -> Expr s a -> Expr s b
forall (f :: * -> *) a b. Functor f => (a -> b) -> f a -> f b
fmap a -> b
f Expr s a
e2)
fmap f :: a -> b
f (BoolEQ e1 :: Expr s a
e1 e2 :: Expr s a
e2) = Expr s b -> Expr s b -> Expr s b
forall s a. Expr s a -> Expr s a -> Expr s a
BoolEQ ((a -> b) -> Expr s a -> Expr s b
forall (f :: * -> *) a b. Functor f => (a -> b) -> f a -> f b
fmap a -> b
f Expr s a
e1) ((a -> b) -> Expr s a -> Expr s b
forall (f :: * -> *) a b. Functor f => (a -> b) -> f a -> f b
fmap a -> b
f Expr s a
e2)
fmap f :: a -> b
f (BoolNE e1 :: Expr s a
e1 e2 :: Expr s a
e2) = Expr s b -> Expr s b -> Expr s b
forall s a. Expr s a -> Expr s a -> Expr s a
BoolNE ((a -> b) -> Expr s a -> Expr s b
forall (f :: * -> *) a b. Functor f => (a -> b) -> f a -> f b
fmap a -> b
f Expr s a
e1) ((a -> b) -> Expr s a -> Expr s b
forall (f :: * -> *) a b. Functor f => (a -> b) -> f a -> f b
fmap a -> b
f Expr s a
e2)
fmap f :: a -> b
f (BoolIf e1 :: Expr s a
e1 e2 :: Expr s a
e2 e3 :: Expr s a
e3) = Expr s b -> Expr s b -> Expr s b -> Expr s b
forall s a. Expr s a -> Expr s a -> Expr s a -> Expr s a
BoolIf ((a -> b) -> Expr s a -> Expr s b
forall (f :: * -> *) a b. Functor f => (a -> b) -> f a -> f b
fmap a -> b
f Expr s a
e1) ((a -> b) -> Expr s a -> Expr s b
forall (f :: * -> *) a b. Functor f => (a -> b) -> f a -> f b
fmap a -> b
f Expr s a
e2) ((a -> b) -> Expr s a -> Expr s b
forall (f :: * -> *) a b. Functor f => (a -> b) -> f a -> f b
fmap a -> b
f Expr s a
e3)
fmap _ Natural = Expr s b
forall s a. Expr s a
Natural
fmap _ (NaturalLit n :: Natural
n) = Natural -> Expr s b
forall s a. Natural -> Expr s a
NaturalLit Natural
n
fmap _ NaturalFold = Expr s b
forall s a. Expr s a
NaturalFold
fmap _ NaturalBuild = Expr s b
forall s a. Expr s a
NaturalBuild
fmap _ NaturalIsZero = Expr s b
forall s a. Expr s a
NaturalIsZero
fmap _ NaturalEven = Expr s b
forall s a. Expr s a
NaturalEven
fmap _ NaturalOdd = Expr s b
forall s a. Expr s a
NaturalOdd
fmap _ NaturalToInteger = Expr s b
forall s a. Expr s a
NaturalToInteger
fmap _ NaturalShow = Expr s b
forall s a. Expr s a
NaturalShow
fmap _ NaturalSubtract = Expr s b
forall s a. Expr s a
NaturalSubtract
fmap f :: a -> b
f (NaturalPlus e1 :: Expr s a
e1 e2 :: Expr s a
e2) = Expr s b -> Expr s b -> Expr s b
forall s a. Expr s a -> Expr s a -> Expr s a
NaturalPlus ((a -> b) -> Expr s a -> Expr s b
forall (f :: * -> *) a b. Functor f => (a -> b) -> f a -> f b
fmap a -> b
f Expr s a
e1) ((a -> b) -> Expr s a -> Expr s b
forall (f :: * -> *) a b. Functor f => (a -> b) -> f a -> f b
fmap a -> b
f Expr s a
e2)
fmap f :: a -> b
f (NaturalTimes e1 :: Expr s a
e1 e2 :: Expr s a
e2) = Expr s b -> Expr s b -> Expr s b
forall s a. Expr s a -> Expr s a -> Expr s a
NaturalTimes ((a -> b) -> Expr s a -> Expr s b
forall (f :: * -> *) a b. Functor f => (a -> b) -> f a -> f b
fmap a -> b
f Expr s a
e1) ((a -> b) -> Expr s a -> Expr s b
forall (f :: * -> *) a b. Functor f => (a -> b) -> f a -> f b
fmap a -> b
f Expr s a
e2)
fmap _ Integer = Expr s b
forall s a. Expr s a
Integer
fmap _ (IntegerLit i :: Integer
i) = Integer -> Expr s b
forall s a. Integer -> Expr s a
IntegerLit Integer
i
fmap _ IntegerClamp = Expr s b
forall s a. Expr s a
IntegerClamp
fmap _ IntegerNegate = Expr s b
forall s a. Expr s a
IntegerNegate
fmap _ IntegerShow = Expr s b
forall s a. Expr s a
IntegerShow
fmap _ IntegerToDouble = Expr s b
forall s a. Expr s a
IntegerToDouble
fmap _ Double = Expr s b
forall s a. Expr s a
Double
fmap _ (DoubleLit d :: DhallDouble
d) = DhallDouble -> Expr s b
forall s a. DhallDouble -> Expr s a
DoubleLit DhallDouble
d
fmap _ DoubleShow = Expr s b
forall s a. Expr s a
DoubleShow
fmap _ Text = Expr s b
forall s a. Expr s a
Text
fmap f :: a -> b
f (TextLit cs :: Chunks s a
cs) = Chunks s b -> Expr s b
forall s a. Chunks s a -> Expr s a
TextLit ((a -> b) -> Chunks s a -> Chunks s b
forall (f :: * -> *) a b. Functor f => (a -> b) -> f a -> f b
fmap a -> b
f Chunks s a
cs)
fmap f :: a -> b
f (TextAppend e1 :: Expr s a
e1 e2 :: Expr s a
e2) = Expr s b -> Expr s b -> Expr s b
forall s a. Expr s a -> Expr s a -> Expr s a
TextAppend ((a -> b) -> Expr s a -> Expr s b
forall (f :: * -> *) a b. Functor f => (a -> b) -> f a -> f b
fmap a -> b
f Expr s a
e1) ((a -> b) -> Expr s a -> Expr s b
forall (f :: * -> *) a b. Functor f => (a -> b) -> f a -> f b
fmap a -> b
f Expr s a
e2)
fmap _ TextShow = Expr s b
forall s a. Expr s a
TextShow
fmap _ List = Expr s b
forall s a. Expr s a
List
fmap f :: a -> b
f (ListLit maybeE :: Maybe (Expr s a)
maybeE seqE :: Seq (Expr s a)
seqE) = Maybe (Expr s b) -> Seq (Expr s b) -> Expr s b
forall s a. Maybe (Expr s a) -> Seq (Expr s a) -> Expr s a
ListLit ((Expr s a -> Expr s b) -> Maybe (Expr s a) -> Maybe (Expr s b)
forall (f :: * -> *) a b. Functor f => (a -> b) -> f a -> f b
fmap ((a -> b) -> Expr s a -> Expr s b
forall (f :: * -> *) a b. Functor f => (a -> b) -> f a -> f b
fmap a -> b
f) Maybe (Expr s a)
maybeE) ((Expr s a -> Expr s b) -> Seq (Expr s a) -> Seq (Expr s b)
forall (f :: * -> *) a b. Functor f => (a -> b) -> f a -> f b
fmap ((a -> b) -> Expr s a -> Expr s b
forall (f :: * -> *) a b. Functor f => (a -> b) -> f a -> f b
fmap a -> b
f) Seq (Expr s a)
seqE)
fmap f :: a -> b
f (ListAppend e1 :: Expr s a
e1 e2 :: Expr s a
e2) = Expr s b -> Expr s b -> Expr s b
forall s a. Expr s a -> Expr s a -> Expr s a
ListAppend ((a -> b) -> Expr s a -> Expr s b
forall (f :: * -> *) a b. Functor f => (a -> b) -> f a -> f b
fmap a -> b
f Expr s a
e1) ((a -> b) -> Expr s a -> Expr s b
forall (f :: * -> *) a b. Functor f => (a -> b) -> f a -> f b
fmap a -> b
f Expr s a
e2)
fmap _ ListBuild = Expr s b
forall s a. Expr s a
ListBuild
fmap _ ListFold = Expr s b
forall s a. Expr s a
ListFold
fmap _ ListLength = Expr s b
forall s a. Expr s a
ListLength
fmap _ ListHead = Expr s b
forall s a. Expr s a
ListHead
fmap _ ListLast = Expr s b
forall s a. Expr s a
ListLast
fmap _ ListIndexed = Expr s b
forall s a. Expr s a
ListIndexed
fmap _ ListReverse = Expr s b
forall s a. Expr s a
ListReverse
fmap _ Optional = Expr s b
forall s a. Expr s a
Optional
fmap f :: a -> b
f (Some e :: Expr s a
e) = Expr s b -> Expr s b
forall s a. Expr s a -> Expr s a
Some ((a -> b) -> Expr s a -> Expr s b
forall (f :: * -> *) a b. Functor f => (a -> b) -> f a -> f b
fmap a -> b
f Expr s a
e)
fmap _ None = Expr s b
forall s a. Expr s a
None
fmap _ OptionalFold = Expr s b
forall s a. Expr s a
OptionalFold
fmap _ OptionalBuild = Expr s b
forall s a. Expr s a
OptionalBuild
fmap f :: a -> b
f (Record r :: Map Text (Expr s a)
r) = Map Text (Expr s b) -> Expr s b
forall s a. Map Text (Expr s a) -> Expr s a
Record ((Expr s a -> Expr s b)
-> Map Text (Expr s a) -> Map Text (Expr s b)
forall (f :: * -> *) a b. Functor f => (a -> b) -> f a -> f b
fmap ((a -> b) -> Expr s a -> Expr s b
forall (f :: * -> *) a b. Functor f => (a -> b) -> f a -> f b
fmap a -> b
f) Map Text (Expr s a)
r)
fmap f :: a -> b
f (RecordLit r :: Map Text (Expr s a)
r) = Map Text (Expr s b) -> Expr s b
forall s a. Map Text (Expr s a) -> Expr s a
RecordLit ((Expr s a -> Expr s b)
-> Map Text (Expr s a) -> Map Text (Expr s b)
forall (f :: * -> *) a b. Functor f => (a -> b) -> f a -> f b
fmap ((a -> b) -> Expr s a -> Expr s b
forall (f :: * -> *) a b. Functor f => (a -> b) -> f a -> f b
fmap a -> b
f) Map Text (Expr s a)
r)
fmap f :: a -> b
f (Union u :: Map Text (Maybe (Expr s a))
u) = Map Text (Maybe (Expr s b)) -> Expr s b
forall s a. Map Text (Maybe (Expr s a)) -> Expr s a
Union ((Maybe (Expr s a) -> Maybe (Expr s b))
-> Map Text (Maybe (Expr s a)) -> Map Text (Maybe (Expr s b))
forall (f :: * -> *) a b. Functor f => (a -> b) -> f a -> f b
fmap ((Expr s a -> Expr s b) -> Maybe (Expr s a) -> Maybe (Expr s b)
forall (f :: * -> *) a b. Functor f => (a -> b) -> f a -> f b
fmap ((a -> b) -> Expr s a -> Expr s b
forall (f :: * -> *) a b. Functor f => (a -> b) -> f a -> f b
fmap a -> b
f)) Map Text (Maybe (Expr s a))
u)
fmap f :: a -> b
f (Combine m :: Maybe Text
m e1 :: Expr s a
e1 e2 :: Expr s a
e2) = Maybe Text -> Expr s b -> Expr s b -> Expr s b
forall s a. Maybe Text -> Expr s a -> Expr s a -> Expr s a
Combine Maybe Text
m ((a -> b) -> Expr s a -> Expr s b
forall (f :: * -> *) a b. Functor f => (a -> b) -> f a -> f b
fmap a -> b
f Expr s a
e1) ((a -> b) -> Expr s a -> Expr s b
forall (f :: * -> *) a b. Functor f => (a -> b) -> f a -> f b
fmap a -> b
f Expr s a
e2)
fmap f :: a -> b
f (CombineTypes e1 :: Expr s a
e1 e2 :: Expr s a
e2) = Expr s b -> Expr s b -> Expr s b
forall s a. Expr s a -> Expr s a -> Expr s a
CombineTypes ((a -> b) -> Expr s a -> Expr s b
forall (f :: * -> *) a b. Functor f => (a -> b) -> f a -> f b
fmap a -> b
f Expr s a
e1) ((a -> b) -> Expr s a -> Expr s b
forall (f :: * -> *) a b. Functor f => (a -> b) -> f a -> f b
fmap a -> b
f Expr s a
e2)
fmap f :: a -> b
f (Prefer e1 :: Expr s a
e1 e2 :: Expr s a
e2) = Expr s b -> Expr s b -> Expr s b
forall s a. Expr s a -> Expr s a -> Expr s a
Prefer ((a -> b) -> Expr s a -> Expr s b
forall (f :: * -> *) a b. Functor f => (a -> b) -> f a -> f b
fmap a -> b
f Expr s a
e1) ((a -> b) -> Expr s a -> Expr s b
forall (f :: * -> *) a b. Functor f => (a -> b) -> f a -> f b
fmap a -> b
f Expr s a
e2)
fmap f :: a -> b
f (RecordCompletion e1 :: Expr s a
e1 e2 :: Expr s a
e2) = Expr s b -> Expr s b -> Expr s b
forall s a. Expr s a -> Expr s a -> Expr s a
RecordCompletion ((a -> b) -> Expr s a -> Expr s b
forall (f :: * -> *) a b. Functor f => (a -> b) -> f a -> f b
fmap a -> b
f Expr s a
e1) ((a -> b) -> Expr s a -> Expr s b
forall (f :: * -> *) a b. Functor f => (a -> b) -> f a -> f b
fmap a -> b
f Expr s a
e2)
fmap f :: a -> b
f (Merge e1 :: Expr s a
e1 e2 :: Expr s a
e2 maybeE :: Maybe (Expr s a)
maybeE) = Expr s b -> Expr s b -> Maybe (Expr s b) -> Expr s b
forall s a. Expr s a -> Expr s a -> Maybe (Expr s a) -> Expr s a
Merge ((a -> b) -> Expr s a -> Expr s b
forall (f :: * -> *) a b. Functor f => (a -> b) -> f a -> f b
fmap a -> b
f Expr s a
e1) ((a -> b) -> Expr s a -> Expr s b
forall (f :: * -> *) a b. Functor f => (a -> b) -> f a -> f b
fmap a -> b
f Expr s a
e2) ((Expr s a -> Expr s b) -> Maybe (Expr s a) -> Maybe (Expr s b)
forall (f :: * -> *) a b. Functor f => (a -> b) -> f a -> f b
fmap ((a -> b) -> Expr s a -> Expr s b
forall (f :: * -> *) a b. Functor f => (a -> b) -> f a -> f b
fmap a -> b
f) Maybe (Expr s a)
maybeE)
fmap f :: a -> b
f (ToMap e :: Expr s a
e maybeE :: Maybe (Expr s a)
maybeE) = Expr s b -> Maybe (Expr s b) -> Expr s b
forall s a. Expr s a -> Maybe (Expr s a) -> Expr s a
ToMap ((a -> b) -> Expr s a -> Expr s b
forall (f :: * -> *) a b. Functor f => (a -> b) -> f a -> f b
fmap a -> b
f Expr s a
e) ((Expr s a -> Expr s b) -> Maybe (Expr s a) -> Maybe (Expr s b)
forall (f :: * -> *) a b. Functor f => (a -> b) -> f a -> f b
fmap ((a -> b) -> Expr s a -> Expr s b
forall (f :: * -> *) a b. Functor f => (a -> b) -> f a -> f b
fmap a -> b
f) Maybe (Expr s a)
maybeE)
fmap f :: a -> b
f (Field e1 :: Expr s a
e1 v :: Text
v) = Expr s b -> Text -> Expr s b
forall s a. Expr s a -> Text -> Expr s a
Field ((a -> b) -> Expr s a -> Expr s b
forall (f :: * -> *) a b. Functor f => (a -> b) -> f a -> f b
fmap a -> b
f Expr s a
e1) Text
v
fmap f :: a -> b
f (Project e1 :: Expr s a
e1 vs :: Either (Set Text) (Expr s a)
vs) = Expr s b -> Either (Set Text) (Expr s b) -> Expr s b
forall s a. Expr s a -> Either (Set Text) (Expr s a) -> Expr s a
Project ((a -> b) -> Expr s a -> Expr s b
forall (f :: * -> *) a b. Functor f => (a -> b) -> f a -> f b
fmap a -> b
f Expr s a
e1) ((Expr s a -> Expr s b)
-> Either (Set Text) (Expr s a) -> Either (Set Text) (Expr s b)
forall (f :: * -> *) a b. Functor f => (a -> b) -> f a -> f b
fmap ((a -> b) -> Expr s a -> Expr s b
forall (f :: * -> *) a b. Functor f => (a -> b) -> f a -> f b
fmap a -> b
f) Either (Set Text) (Expr s a)
vs)
fmap f :: a -> b
f (Assert t :: Expr s a
t) = Expr s b -> Expr s b
forall s a. Expr s a -> Expr s a
Assert ((a -> b) -> Expr s a -> Expr s b
forall (f :: * -> *) a b. Functor f => (a -> b) -> f a -> f b
fmap a -> b
f Expr s a
t)
fmap f :: a -> b
f (Equivalent e1 :: Expr s a
e1 e2 :: Expr s a
e2) = Expr s b -> Expr s b -> Expr s b
forall s a. Expr s a -> Expr s a -> Expr s a
Equivalent ((a -> b) -> Expr s a -> Expr s b
forall (f :: * -> *) a b. Functor f => (a -> b) -> f a -> f b
fmap a -> b
f Expr s a
e1) ((a -> b) -> Expr s a -> Expr s b
forall (f :: * -> *) a b. Functor f => (a -> b) -> f a -> f b
fmap a -> b
f Expr s a
e2)
fmap f :: a -> b
f (Note s :: s
s e1 :: Expr s a
e1) = s -> Expr s b -> Expr s b
forall s a. s -> Expr s a -> Expr s a
Note s
s ((a -> b) -> Expr s a -> Expr s b
forall (f :: * -> *) a b. Functor f => (a -> b) -> f a -> f b
fmap a -> b
f Expr s a
e1)
fmap f :: a -> b
f (ImportAlt e1 :: Expr s a
e1 e2 :: Expr s a
e2) = Expr s b -> Expr s b -> Expr s b
forall s a. Expr s a -> Expr s a -> Expr s a
ImportAlt ((a -> b) -> Expr s a -> Expr s b
forall (f :: * -> *) a b. Functor f => (a -> b) -> f a -> f b
fmap a -> b
f Expr s a
e1) ((a -> b) -> Expr s a -> Expr s b
forall (f :: * -> *) a b. Functor f => (a -> b) -> f a -> f b
fmap a -> b
f Expr s a
e2)
fmap f :: a -> b
f (Embed a :: a
a) = b -> Expr s b
forall s a. a -> Expr s a
Embed (a -> b
f a
a)
{-# INLINABLE fmap #-}
instance Applicative (Expr s) where
pure :: a -> Expr s a
pure = a -> Expr s a
forall s a. a -> Expr s a
Embed
<*> :: Expr s (a -> b) -> Expr s a -> Expr s b
(<*>) = Expr s (a -> b) -> Expr s a -> Expr s b
forall (m :: * -> *) a b. Monad m => m (a -> b) -> m a -> m b
Control.Monad.ap
instance Monad (Expr s) where
return :: a -> Expr s a
return = a -> Expr s a
forall (f :: * -> *) a. Applicative f => a -> f a
pure
Const a :: Const
a >>= :: Expr s a -> (a -> Expr s b) -> Expr s b
>>= _ = Const -> Expr s b
forall s a. Const -> Expr s a
Const Const
a
Var a :: Var
a >>= _ = Var -> Expr s b
forall s a. Var -> Expr s a
Var Var
a
Lam a :: Text
a b :: Expr s a
b c :: Expr s a
c >>= k :: a -> Expr s b
k = Text -> Expr s b -> Expr s b -> Expr s b
forall s a. Text -> Expr s a -> Expr s a -> Expr s a
Lam Text
a (Expr s a
b Expr s a -> (a -> Expr s b) -> Expr s b
forall (m :: * -> *) a b. Monad m => m a -> (a -> m b) -> m b
>>= a -> Expr s b
k) (Expr s a
c Expr s a -> (a -> Expr s b) -> Expr s b
forall (m :: * -> *) a b. Monad m => m a -> (a -> m b) -> m b
>>= a -> Expr s b
k)
Pi a :: Text
a b :: Expr s a
b c :: Expr s a
c >>= k :: a -> Expr s b
k = Text -> Expr s b -> Expr s b -> Expr s b
forall s a. Text -> Expr s a -> Expr s a -> Expr s a
Pi Text
a (Expr s a
b Expr s a -> (a -> Expr s b) -> Expr s b
forall (m :: * -> *) a b. Monad m => m a -> (a -> m b) -> m b
>>= a -> Expr s b
k) (Expr s a
c Expr s a -> (a -> Expr s b) -> Expr s b
forall (m :: * -> *) a b. Monad m => m a -> (a -> m b) -> m b
>>= a -> Expr s b
k)
App a :: Expr s a
a b :: Expr s a
b >>= k :: a -> Expr s b
k = Expr s b -> Expr s b -> Expr s b
forall s a. Expr s a -> Expr s a -> Expr s a
App (Expr s a
a Expr s a -> (a -> Expr s b) -> Expr s b
forall (m :: * -> *) a b. Monad m => m a -> (a -> m b) -> m b
>>= a -> Expr s b
k) (Expr s a
b Expr s a -> (a -> Expr s b) -> Expr s b
forall (m :: * -> *) a b. Monad m => m a -> (a -> m b) -> m b
>>= a -> Expr s b
k)
Let a :: Binding s a
a b :: Expr s a
b >>= k :: a -> Expr s b
k = Binding s b -> Expr s b -> Expr s b
forall s a. Binding s a -> Expr s a -> Expr s a
Let (Binding s a -> Binding s b
adapt0 Binding s a
a) (Expr s a
b Expr s a -> (a -> Expr s b) -> Expr s b
forall (m :: * -> *) a b. Monad m => m a -> (a -> m b) -> m b
>>= a -> Expr s b
k)
where
adapt0 :: Binding s a -> Binding s b
adapt0 (Binding src0 :: Maybe s
src0 c :: Text
c src1 :: Maybe s
src1 d :: Maybe (Maybe s, Expr s a)
d src2 :: Maybe s
src2 e :: Expr s a
e) =
Maybe s
-> Text
-> Maybe s
-> Maybe (Maybe s, Expr s b)
-> Maybe s
-> Expr s b
-> Binding s b
forall s a.
Maybe s
-> Text
-> Maybe s
-> Maybe (Maybe s, Expr s a)
-> Maybe s
-> Expr s a
-> Binding s a
Binding Maybe s
src0 Text
c Maybe s
src1 (((Maybe s, Expr s a) -> (Maybe s, Expr s b))
-> Maybe (Maybe s, Expr s a) -> Maybe (Maybe s, Expr s b)
forall (f :: * -> *) a b. Functor f => (a -> b) -> f a -> f b
fmap (Maybe s, Expr s a) -> (Maybe s, Expr s b)
forall a. (a, Expr s a) -> (a, Expr s b)
adapt1 Maybe (Maybe s, Expr s a)
d) Maybe s
src2 (Expr s a
e Expr s a -> (a -> Expr s b) -> Expr s b
forall (m :: * -> *) a b. Monad m => m a -> (a -> m b) -> m b
>>= a -> Expr s b
k)
adapt1 :: (a, Expr s a) -> (a, Expr s b)
adapt1 (src3 :: a
src3, f :: Expr s a
f) = (a
src3, Expr s a
f Expr s a -> (a -> Expr s b) -> Expr s b
forall (m :: * -> *) a b. Monad m => m a -> (a -> m b) -> m b
>>= a -> Expr s b
k)
Annot a :: Expr s a
a b :: Expr s a
b >>= k :: a -> Expr s b
k = Expr s b -> Expr s b -> Expr s b
forall s a. Expr s a -> Expr s a -> Expr s a
Annot (Expr s a
a Expr s a -> (a -> Expr s b) -> Expr s b
forall (m :: * -> *) a b. Monad m => m a -> (a -> m b) -> m b
>>= a -> Expr s b
k) (Expr s a
b Expr s a -> (a -> Expr s b) -> Expr s b
forall (m :: * -> *) a b. Monad m => m a -> (a -> m b) -> m b
>>= a -> Expr s b
k)
Bool >>= _ = Expr s b
forall s a. Expr s a
Bool
BoolLit a :: Bool
a >>= _ = Bool -> Expr s b
forall s a. Bool -> Expr s a
BoolLit Bool
a
BoolAnd a :: Expr s a
a b :: Expr s a
b >>= k :: a -> Expr s b
k = Expr s b -> Expr s b -> Expr s b
forall s a. Expr s a -> Expr s a -> Expr s a
BoolAnd (Expr s a
a Expr s a -> (a -> Expr s b) -> Expr s b
forall (m :: * -> *) a b. Monad m => m a -> (a -> m b) -> m b
>>= a -> Expr s b
k) (Expr s a
b Expr s a -> (a -> Expr s b) -> Expr s b
forall (m :: * -> *) a b. Monad m => m a -> (a -> m b) -> m b
>>= a -> Expr s b
k)
BoolOr a :: Expr s a
a b :: Expr s a
b >>= k :: a -> Expr s b
k = Expr s b -> Expr s b -> Expr s b
forall s a. Expr s a -> Expr s a -> Expr s a
BoolOr (Expr s a
a Expr s a -> (a -> Expr s b) -> Expr s b
forall (m :: * -> *) a b. Monad m => m a -> (a -> m b) -> m b
>>= a -> Expr s b
k) (Expr s a
b Expr s a -> (a -> Expr s b) -> Expr s b
forall (m :: * -> *) a b. Monad m => m a -> (a -> m b) -> m b
>>= a -> Expr s b
k)
BoolEQ a :: Expr s a
a b :: Expr s a
b >>= k :: a -> Expr s b
k = Expr s b -> Expr s b -> Expr s b
forall s a. Expr s a -> Expr s a -> Expr s a
BoolEQ (Expr s a
a Expr s a -> (a -> Expr s b) -> Expr s b
forall (m :: * -> *) a b. Monad m => m a -> (a -> m b) -> m b
>>= a -> Expr s b
k) (Expr s a
b Expr s a -> (a -> Expr s b) -> Expr s b
forall (m :: * -> *) a b. Monad m => m a -> (a -> m b) -> m b
>>= a -> Expr s b
k)
BoolNE a :: Expr s a
a b :: Expr s a
b >>= k :: a -> Expr s b
k = Expr s b -> Expr s b -> Expr s b
forall s a. Expr s a -> Expr s a -> Expr s a
BoolNE (Expr s a
a Expr s a -> (a -> Expr s b) -> Expr s b
forall (m :: * -> *) a b. Monad m => m a -> (a -> m b) -> m b
>>= a -> Expr s b
k) (Expr s a
b Expr s a -> (a -> Expr s b) -> Expr s b
forall (m :: * -> *) a b. Monad m => m a -> (a -> m b) -> m b
>>= a -> Expr s b
k)
BoolIf a :: Expr s a
a b :: Expr s a
b c :: Expr s a
c >>= k :: a -> Expr s b
k = Expr s b -> Expr s b -> Expr s b -> Expr s b
forall s a. Expr s a -> Expr s a -> Expr s a -> Expr s a
BoolIf (Expr s a
a Expr s a -> (a -> Expr s b) -> Expr s b
forall (m :: * -> *) a b. Monad m => m a -> (a -> m b) -> m b
>>= a -> Expr s b
k) (Expr s a
b Expr s a -> (a -> Expr s b) -> Expr s b
forall (m :: * -> *) a b. Monad m => m a -> (a -> m b) -> m b
>>= a -> Expr s b
k) (Expr s a
c Expr s a -> (a -> Expr s b) -> Expr s b
forall (m :: * -> *) a b. Monad m => m a -> (a -> m b) -> m b
>>= a -> Expr s b
k)
Natural >>= _ = Expr s b
forall s a. Expr s a
Natural
NaturalLit a :: Natural
a >>= _ = Natural -> Expr s b
forall s a. Natural -> Expr s a
NaturalLit Natural
a
NaturalFold >>= _ = Expr s b
forall s a. Expr s a
NaturalFold
NaturalBuild >>= _ = Expr s b
forall s a. Expr s a
NaturalBuild
NaturalIsZero >>= _ = Expr s b
forall s a. Expr s a
NaturalIsZero
NaturalEven >>= _ = Expr s b
forall s a. Expr s a
NaturalEven
NaturalOdd >>= _ = Expr s b
forall s a. Expr s a
NaturalOdd
NaturalToInteger >>= _ = Expr s b
forall s a. Expr s a
NaturalToInteger
NaturalShow >>= _ = Expr s b
forall s a. Expr s a
NaturalShow
NaturalSubtract >>= _ = Expr s b
forall s a. Expr s a
NaturalSubtract
NaturalPlus a :: Expr s a
a b :: Expr s a
b >>= k :: a -> Expr s b
k = Expr s b -> Expr s b -> Expr s b
forall s a. Expr s a -> Expr s a -> Expr s a
NaturalPlus (Expr s a
a Expr s a -> (a -> Expr s b) -> Expr s b
forall (m :: * -> *) a b. Monad m => m a -> (a -> m b) -> m b
>>= a -> Expr s b
k) (Expr s a
b Expr s a -> (a -> Expr s b) -> Expr s b
forall (m :: * -> *) a b. Monad m => m a -> (a -> m b) -> m b
>>= a -> Expr s b
k)
NaturalTimes a :: Expr s a
a b :: Expr s a
b >>= k :: a -> Expr s b
k = Expr s b -> Expr s b -> Expr s b
forall s a. Expr s a -> Expr s a -> Expr s a
NaturalTimes (Expr s a
a Expr s a -> (a -> Expr s b) -> Expr s b
forall (m :: * -> *) a b. Monad m => m a -> (a -> m b) -> m b
>>= a -> Expr s b
k) (Expr s a
b Expr s a -> (a -> Expr s b) -> Expr s b
forall (m :: * -> *) a b. Monad m => m a -> (a -> m b) -> m b
>>= a -> Expr s b
k)
Integer >>= _ = Expr s b
forall s a. Expr s a
Integer
IntegerLit a :: Integer
a >>= _ = Integer -> Expr s b
forall s a. Integer -> Expr s a
IntegerLit Integer
a
IntegerClamp >>= _ = Expr s b
forall s a. Expr s a
IntegerClamp
IntegerNegate >>= _ = Expr s b
forall s a. Expr s a
IntegerNegate
IntegerShow >>= _ = Expr s b
forall s a. Expr s a
IntegerShow
IntegerToDouble >>= _ = Expr s b
forall s a. Expr s a
IntegerToDouble
Double >>= _ = Expr s b
forall s a. Expr s a
Double
DoubleLit a :: DhallDouble
a >>= _ = DhallDouble -> Expr s b
forall s a. DhallDouble -> Expr s a
DoubleLit DhallDouble
a
DoubleShow >>= _ = Expr s b
forall s a. Expr s a
DoubleShow
Text >>= _ = Expr s b
forall s a. Expr s a
Text
TextLit (Chunks a :: [(Text, Expr s a)]
a b :: Text
b) >>= k :: a -> Expr s b
k = Chunks s b -> Expr s b
forall s a. Chunks s a -> Expr s a
TextLit ([(Text, Expr s b)] -> Text -> Chunks s b
forall s a. [(Text, Expr s a)] -> Text -> Chunks s a
Chunks (((Text, Expr s a) -> (Text, Expr s b))
-> [(Text, Expr s a)] -> [(Text, Expr s b)]
forall (f :: * -> *) a b. Functor f => (a -> b) -> f a -> f b
fmap ((Expr s a -> Expr s b) -> (Text, Expr s a) -> (Text, Expr s b)
forall (f :: * -> *) a b. Functor f => (a -> b) -> f a -> f b
fmap (Expr s a -> (a -> Expr s b) -> Expr s b
forall (m :: * -> *) a b. Monad m => m a -> (a -> m b) -> m b
>>= a -> Expr s b
k)) [(Text, Expr s a)]
a) Text
b)
TextAppend a :: Expr s a
a b :: Expr s a
b >>= k :: a -> Expr s b
k = Expr s b -> Expr s b -> Expr s b
forall s a. Expr s a -> Expr s a -> Expr s a
TextAppend (Expr s a
a Expr s a -> (a -> Expr s b) -> Expr s b
forall (m :: * -> *) a b. Monad m => m a -> (a -> m b) -> m b
>>= a -> Expr s b
k) (Expr s a
b Expr s a -> (a -> Expr s b) -> Expr s b
forall (m :: * -> *) a b. Monad m => m a -> (a -> m b) -> m b
>>= a -> Expr s b
k)
TextShow >>= _ = Expr s b
forall s a. Expr s a
TextShow
List >>= _ = Expr s b
forall s a. Expr s a
List
ListLit a :: Maybe (Expr s a)
a b :: Seq (Expr s a)
b >>= k :: a -> Expr s b
k = Maybe (Expr s b) -> Seq (Expr s b) -> Expr s b
forall s a. Maybe (Expr s a) -> Seq (Expr s a) -> Expr s a
ListLit ((Expr s a -> Expr s b) -> Maybe (Expr s a) -> Maybe (Expr s b)
forall (f :: * -> *) a b. Functor f => (a -> b) -> f a -> f b
fmap (Expr s a -> (a -> Expr s b) -> Expr s b
forall (m :: * -> *) a b. Monad m => m a -> (a -> m b) -> m b
>>= a -> Expr s b
k) Maybe (Expr s a)
a) ((Expr s a -> Expr s b) -> Seq (Expr s a) -> Seq (Expr s b)
forall (f :: * -> *) a b. Functor f => (a -> b) -> f a -> f b
fmap (Expr s a -> (a -> Expr s b) -> Expr s b
forall (m :: * -> *) a b. Monad m => m a -> (a -> m b) -> m b
>>= a -> Expr s b
k) Seq (Expr s a)
b)
ListAppend a :: Expr s a
a b :: Expr s a
b >>= k :: a -> Expr s b
k = Expr s b -> Expr s b -> Expr s b
forall s a. Expr s a -> Expr s a -> Expr s a
ListAppend (Expr s a
a Expr s a -> (a -> Expr s b) -> Expr s b
forall (m :: * -> *) a b. Monad m => m a -> (a -> m b) -> m b
>>= a -> Expr s b
k) (Expr s a
b Expr s a -> (a -> Expr s b) -> Expr s b
forall (m :: * -> *) a b. Monad m => m a -> (a -> m b) -> m b
>>= a -> Expr s b
k)
ListBuild >>= _ = Expr s b
forall s a. Expr s a
ListBuild
ListFold >>= _ = Expr s b
forall s a. Expr s a
ListFold
ListLength >>= _ = Expr s b
forall s a. Expr s a
ListLength
ListHead >>= _ = Expr s b
forall s a. Expr s a
ListHead
ListLast >>= _ = Expr s b
forall s a. Expr s a
ListLast
ListIndexed >>= _ = Expr s b
forall s a. Expr s a
ListIndexed
ListReverse >>= _ = Expr s b
forall s a. Expr s a
ListReverse
Optional >>= _ = Expr s b
forall s a. Expr s a
Optional
Some a :: Expr s a
a >>= k :: a -> Expr s b
k = Expr s b -> Expr s b
forall s a. Expr s a -> Expr s a
Some (Expr s a
a Expr s a -> (a -> Expr s b) -> Expr s b
forall (m :: * -> *) a b. Monad m => m a -> (a -> m b) -> m b
>>= a -> Expr s b
k)
None >>= _ = Expr s b
forall s a. Expr s a
None
OptionalFold >>= _ = Expr s b
forall s a. Expr s a
OptionalFold
OptionalBuild >>= _ = Expr s b
forall s a. Expr s a
OptionalBuild
Record a :: Map Text (Expr s a)
a >>= k :: a -> Expr s b
k = Map Text (Expr s b) -> Expr s b
forall s a. Map Text (Expr s a) -> Expr s a
Record ((Expr s a -> Expr s b)
-> Map Text (Expr s a) -> Map Text (Expr s b)
forall (f :: * -> *) a b. Functor f => (a -> b) -> f a -> f b
fmap (Expr s a -> (a -> Expr s b) -> Expr s b
forall (m :: * -> *) a b. Monad m => m a -> (a -> m b) -> m b
>>= a -> Expr s b
k) Map Text (Expr s a)
a)
RecordLit a :: Map Text (Expr s a)
a >>= k :: a -> Expr s b
k = Map Text (Expr s b) -> Expr s b
forall s a. Map Text (Expr s a) -> Expr s a
RecordLit ((Expr s a -> Expr s b)
-> Map Text (Expr s a) -> Map Text (Expr s b)
forall (f :: * -> *) a b. Functor f => (a -> b) -> f a -> f b
fmap (Expr s a -> (a -> Expr s b) -> Expr s b
forall (m :: * -> *) a b. Monad m => m a -> (a -> m b) -> m b
>>= a -> Expr s b
k) Map Text (Expr s a)
a)
Union a :: Map Text (Maybe (Expr s a))
a >>= k :: a -> Expr s b
k = Map Text (Maybe (Expr s b)) -> Expr s b
forall s a. Map Text (Maybe (Expr s a)) -> Expr s a
Union ((Maybe (Expr s a) -> Maybe (Expr s b))
-> Map Text (Maybe (Expr s a)) -> Map Text (Maybe (Expr s b))
forall (f :: * -> *) a b. Functor f => (a -> b) -> f a -> f b
fmap ((Expr s a -> Expr s b) -> Maybe (Expr s a) -> Maybe (Expr s b)
forall (f :: * -> *) a b. Functor f => (a -> b) -> f a -> f b
fmap (Expr s a -> (a -> Expr s b) -> Expr s b
forall (m :: * -> *) a b. Monad m => m a -> (a -> m b) -> m b
>>= a -> Expr s b
k)) Map Text (Maybe (Expr s a))
a)
Combine a :: Maybe Text
a b :: Expr s a
b c :: Expr s a
c >>= k :: a -> Expr s b
k = Maybe Text -> Expr s b -> Expr s b -> Expr s b
forall s a. Maybe Text -> Expr s a -> Expr s a -> Expr s a
Combine Maybe Text
a (Expr s a
b Expr s a -> (a -> Expr s b) -> Expr s b
forall (m :: * -> *) a b. Monad m => m a -> (a -> m b) -> m b
>>= a -> Expr s b
k) (Expr s a
c Expr s a -> (a -> Expr s b) -> Expr s b
forall (m :: * -> *) a b. Monad m => m a -> (a -> m b) -> m b
>>= a -> Expr s b
k)
CombineTypes a :: Expr s a
a b :: Expr s a
b >>= k :: a -> Expr s b
k = Expr s b -> Expr s b -> Expr s b
forall s a. Expr s a -> Expr s a -> Expr s a
CombineTypes (Expr s a
a Expr s a -> (a -> Expr s b) -> Expr s b
forall (m :: * -> *) a b. Monad m => m a -> (a -> m b) -> m b
>>= a -> Expr s b
k) (Expr s a
b Expr s a -> (a -> Expr s b) -> Expr s b
forall (m :: * -> *) a b. Monad m => m a -> (a -> m b) -> m b
>>= a -> Expr s b
k)
Prefer a :: Expr s a
a b :: Expr s a
b >>= k :: a -> Expr s b
k = Expr s b -> Expr s b -> Expr s b
forall s a. Expr s a -> Expr s a -> Expr s a
Prefer (Expr s a
a Expr s a -> (a -> Expr s b) -> Expr s b
forall (m :: * -> *) a b. Monad m => m a -> (a -> m b) -> m b
>>= a -> Expr s b
k) (Expr s a
b Expr s a -> (a -> Expr s b) -> Expr s b
forall (m :: * -> *) a b. Monad m => m a -> (a -> m b) -> m b
>>= a -> Expr s b
k)
RecordCompletion a :: Expr s a
a b :: Expr s a
b >>= k :: a -> Expr s b
k = Expr s b -> Expr s b -> Expr s b
forall s a. Expr s a -> Expr s a -> Expr s a
RecordCompletion (Expr s a
a Expr s a -> (a -> Expr s b) -> Expr s b
forall (m :: * -> *) a b. Monad m => m a -> (a -> m b) -> m b
>>= a -> Expr s b
k) (Expr s a
b Expr s a -> (a -> Expr s b) -> Expr s b
forall (m :: * -> *) a b. Monad m => m a -> (a -> m b) -> m b
>>= a -> Expr s b
k)
Merge a :: Expr s a
a b :: Expr s a
b c :: Maybe (Expr s a)
c >>= k :: a -> Expr s b
k = Expr s b -> Expr s b -> Maybe (Expr s b) -> Expr s b
forall s a. Expr s a -> Expr s a -> Maybe (Expr s a) -> Expr s a
Merge (Expr s a
a Expr s a -> (a -> Expr s b) -> Expr s b
forall (m :: * -> *) a b. Monad m => m a -> (a -> m b) -> m b
>>= a -> Expr s b
k) (Expr s a
b Expr s a -> (a -> Expr s b) -> Expr s b
forall (m :: * -> *) a b. Monad m => m a -> (a -> m b) -> m b
>>= a -> Expr s b
k) ((Expr s a -> Expr s b) -> Maybe (Expr s a) -> Maybe (Expr s b)
forall (f :: * -> *) a b. Functor f => (a -> b) -> f a -> f b
fmap (Expr s a -> (a -> Expr s b) -> Expr s b
forall (m :: * -> *) a b. Monad m => m a -> (a -> m b) -> m b
>>= a -> Expr s b
k) Maybe (Expr s a)
c)
ToMap a :: Expr s a
a b :: Maybe (Expr s a)
b >>= k :: a -> Expr s b
k = Expr s b -> Maybe (Expr s b) -> Expr s b
forall s a. Expr s a -> Maybe (Expr s a) -> Expr s a
ToMap (Expr s a
a Expr s a -> (a -> Expr s b) -> Expr s b
forall (m :: * -> *) a b. Monad m => m a -> (a -> m b) -> m b
>>= a -> Expr s b
k) ((Expr s a -> Expr s b) -> Maybe (Expr s a) -> Maybe (Expr s b)
forall (f :: * -> *) a b. Functor f => (a -> b) -> f a -> f b
fmap (Expr s a -> (a -> Expr s b) -> Expr s b
forall (m :: * -> *) a b. Monad m => m a -> (a -> m b) -> m b
>>= a -> Expr s b
k) Maybe (Expr s a)
b)
Field a :: Expr s a
a b :: Text
b >>= k :: a -> Expr s b
k = Expr s b -> Text -> Expr s b
forall s a. Expr s a -> Text -> Expr s a
Field (Expr s a
a Expr s a -> (a -> Expr s b) -> Expr s b
forall (m :: * -> *) a b. Monad m => m a -> (a -> m b) -> m b
>>= a -> Expr s b
k) Text
b
Project a :: Expr s a
a b :: Either (Set Text) (Expr s a)
b >>= k :: a -> Expr s b
k = Expr s b -> Either (Set Text) (Expr s b) -> Expr s b
forall s a. Expr s a -> Either (Set Text) (Expr s a) -> Expr s a
Project (Expr s a
a Expr s a -> (a -> Expr s b) -> Expr s b
forall (m :: * -> *) a b. Monad m => m a -> (a -> m b) -> m b
>>= a -> Expr s b
k) ((Expr s a -> Expr s b)
-> Either (Set Text) (Expr s a) -> Either (Set Text) (Expr s b)
forall (f :: * -> *) a b. Functor f => (a -> b) -> f a -> f b
fmap (Expr s a -> (a -> Expr s b) -> Expr s b
forall (m :: * -> *) a b. Monad m => m a -> (a -> m b) -> m b
>>= a -> Expr s b
k) Either (Set Text) (Expr s a)
b)
Assert a :: Expr s a
a >>= k :: a -> Expr s b
k = Expr s b -> Expr s b
forall s a. Expr s a -> Expr s a
Assert (Expr s a
a Expr s a -> (a -> Expr s b) -> Expr s b
forall (m :: * -> *) a b. Monad m => m a -> (a -> m b) -> m b
>>= a -> Expr s b
k)
Equivalent a :: Expr s a
a b :: Expr s a
b >>= k :: a -> Expr s b
k = Expr s b -> Expr s b -> Expr s b
forall s a. Expr s a -> Expr s a -> Expr s a
Equivalent (Expr s a
a Expr s a -> (a -> Expr s b) -> Expr s b
forall (m :: * -> *) a b. Monad m => m a -> (a -> m b) -> m b
>>= a -> Expr s b
k) (Expr s a
b Expr s a -> (a -> Expr s b) -> Expr s b
forall (m :: * -> *) a b. Monad m => m a -> (a -> m b) -> m b
>>= a -> Expr s b
k)
Note a :: s
a b :: Expr s a
b >>= k :: a -> Expr s b
k = s -> Expr s b -> Expr s b
forall s a. s -> Expr s a -> Expr s a
Note s
a (Expr s a
b Expr s a -> (a -> Expr s b) -> Expr s b
forall (m :: * -> *) a b. Monad m => m a -> (a -> m b) -> m b
>>= a -> Expr s b
k)
ImportAlt a :: Expr s a
a b :: Expr s a
b >>= k :: a -> Expr s b
k = Expr s b -> Expr s b -> Expr s b
forall s a. Expr s a -> Expr s a -> Expr s a
ImportAlt (Expr s a
a Expr s a -> (a -> Expr s b) -> Expr s b
forall (m :: * -> *) a b. Monad m => m a -> (a -> m b) -> m b
>>= a -> Expr s b
k) (Expr s a
b Expr s a -> (a -> Expr s b) -> Expr s b
forall (m :: * -> *) a b. Monad m => m a -> (a -> m b) -> m b
>>= a -> Expr s b
k)
Embed a :: a
a >>= k :: a -> Expr s b
k = a -> Expr s b
k a
a
instance Bifunctor Expr where
first :: (a -> b) -> Expr a c -> Expr b c
first _ (Const a :: Const
a ) = Const -> Expr b c
forall s a. Const -> Expr s a
Const Const
a
first _ (Var a :: Var
a ) = Var -> Expr b c
forall s a. Var -> Expr s a
Var Var
a
first k :: a -> b
k (Lam a :: Text
a b :: Expr a c
b c :: Expr a c
c ) = Text -> Expr b c -> Expr b c -> Expr b c
forall s a. Text -> Expr s a -> Expr s a -> Expr s a
Lam Text
a ((a -> b) -> Expr a c -> Expr b c
forall (p :: * -> * -> *) a b c.
Bifunctor p =>
(a -> b) -> p a c -> p b c
first a -> b
k Expr a c
b) ((a -> b) -> Expr a c -> Expr b c
forall (p :: * -> * -> *) a b c.
Bifunctor p =>
(a -> b) -> p a c -> p b c
first a -> b
k Expr a c
c)
first k :: a -> b
k (Pi a :: Text
a b :: Expr a c
b c :: Expr a c
c ) = Text -> Expr b c -> Expr b c -> Expr b c
forall s a. Text -> Expr s a -> Expr s a -> Expr s a
Pi Text
a ((a -> b) -> Expr a c -> Expr b c
forall (p :: * -> * -> *) a b c.
Bifunctor p =>
(a -> b) -> p a c -> p b c
first a -> b
k Expr a c
b) ((a -> b) -> Expr a c -> Expr b c
forall (p :: * -> * -> *) a b c.
Bifunctor p =>
(a -> b) -> p a c -> p b c
first a -> b
k Expr a c
c)
first k :: a -> b
k (App a :: Expr a c
a b :: Expr a c
b ) = Expr b c -> Expr b c -> Expr b c
forall s a. Expr s a -> Expr s a -> Expr s a
App ((a -> b) -> Expr a c -> Expr b c
forall (p :: * -> * -> *) a b c.
Bifunctor p =>
(a -> b) -> p a c -> p b c
first a -> b
k Expr a c
a) ((a -> b) -> Expr a c -> Expr b c
forall (p :: * -> * -> *) a b c.
Bifunctor p =>
(a -> b) -> p a c -> p b c
first a -> b
k Expr a c
b)
first k :: a -> b
k (Let a :: Binding a c
a b :: Expr a c
b ) = Binding b c -> Expr b c -> Expr b c
forall s a. Binding s a -> Expr s a -> Expr s a
Let ((a -> b) -> Binding a c -> Binding b c
forall (p :: * -> * -> *) a b c.
Bifunctor p =>
(a -> b) -> p a c -> p b c
first a -> b
k Binding a c
a) ((a -> b) -> Expr a c -> Expr b c
forall (p :: * -> * -> *) a b c.
Bifunctor p =>
(a -> b) -> p a c -> p b c
first a -> b
k Expr a c
b)
first k :: a -> b
k (Annot a :: Expr a c
a b :: Expr a c
b ) = Expr b c -> Expr b c -> Expr b c
forall s a. Expr s a -> Expr s a -> Expr s a
Annot ((a -> b) -> Expr a c -> Expr b c
forall (p :: * -> * -> *) a b c.
Bifunctor p =>
(a -> b) -> p a c -> p b c
first a -> b
k Expr a c
a) ((a -> b) -> Expr a c -> Expr b c
forall (p :: * -> * -> *) a b c.
Bifunctor p =>
(a -> b) -> p a c -> p b c
first a -> b
k Expr a c
b)
first _ Bool = Expr b c
forall s a. Expr s a
Bool
first _ (BoolLit a :: Bool
a ) = Bool -> Expr b c
forall s a. Bool -> Expr s a
BoolLit Bool
a
first k :: a -> b
k (BoolAnd a :: Expr a c
a b :: Expr a c
b ) = Expr b c -> Expr b c -> Expr b c
forall s a. Expr s a -> Expr s a -> Expr s a
BoolAnd ((a -> b) -> Expr a c -> Expr b c
forall (p :: * -> * -> *) a b c.
Bifunctor p =>
(a -> b) -> p a c -> p b c
first a -> b
k Expr a c
a) ((a -> b) -> Expr a c -> Expr b c
forall (p :: * -> * -> *) a b c.
Bifunctor p =>
(a -> b) -> p a c -> p b c
first a -> b
k Expr a c
b)
first k :: a -> b
k (BoolOr a :: Expr a c
a b :: Expr a c
b ) = Expr b c -> Expr b c -> Expr b c
forall s a. Expr s a -> Expr s a -> Expr s a
BoolOr ((a -> b) -> Expr a c -> Expr b c
forall (p :: * -> * -> *) a b c.
Bifunctor p =>
(a -> b) -> p a c -> p b c
first a -> b
k Expr a c
a) ((a -> b) -> Expr a c -> Expr b c
forall (p :: * -> * -> *) a b c.
Bifunctor p =>
(a -> b) -> p a c -> p b c
first a -> b
k Expr a c
b)
first k :: a -> b
k (BoolEQ a :: Expr a c
a b :: Expr a c
b ) = Expr b c -> Expr b c -> Expr b c
forall s a. Expr s a -> Expr s a -> Expr s a
BoolEQ ((a -> b) -> Expr a c -> Expr b c
forall (p :: * -> * -> *) a b c.
Bifunctor p =>
(a -> b) -> p a c -> p b c
first a -> b
k Expr a c
a) ((a -> b) -> Expr a c -> Expr b c
forall (p :: * -> * -> *) a b c.
Bifunctor p =>
(a -> b) -> p a c -> p b c
first a -> b
k Expr a c
b)
first k :: a -> b
k (BoolNE a :: Expr a c
a b :: Expr a c
b ) = Expr b c -> Expr b c -> Expr b c
forall s a. Expr s a -> Expr s a -> Expr s a
BoolNE ((a -> b) -> Expr a c -> Expr b c
forall (p :: * -> * -> *) a b c.
Bifunctor p =>
(a -> b) -> p a c -> p b c
first a -> b
k Expr a c
a) ((a -> b) -> Expr a c -> Expr b c
forall (p :: * -> * -> *) a b c.
Bifunctor p =>
(a -> b) -> p a c -> p b c
first a -> b
k Expr a c
b)
first k :: a -> b
k (BoolIf a :: Expr a c
a b :: Expr a c
b c :: Expr a c
c ) = Expr b c -> Expr b c -> Expr b c -> Expr b c
forall s a. Expr s a -> Expr s a -> Expr s a -> Expr s a
BoolIf ((a -> b) -> Expr a c -> Expr b c
forall (p :: * -> * -> *) a b c.
Bifunctor p =>
(a -> b) -> p a c -> p b c
first a -> b
k Expr a c
a) ((a -> b) -> Expr a c -> Expr b c
forall (p :: * -> * -> *) a b c.
Bifunctor p =>
(a -> b) -> p a c -> p b c
first a -> b
k Expr a c
b) ((a -> b) -> Expr a c -> Expr b c
forall (p :: * -> * -> *) a b c.
Bifunctor p =>
(a -> b) -> p a c -> p b c
first a -> b
k Expr a c
c)
first _ Natural = Expr b c
forall s a. Expr s a
Natural
first _ (NaturalLit a :: Natural
a ) = Natural -> Expr b c
forall s a. Natural -> Expr s a
NaturalLit Natural
a
first _ NaturalFold = Expr b c
forall s a. Expr s a
NaturalFold
first _ NaturalBuild = Expr b c
forall s a. Expr s a
NaturalBuild
first _ NaturalIsZero = Expr b c
forall s a. Expr s a
NaturalIsZero
first _ NaturalEven = Expr b c
forall s a. Expr s a
NaturalEven
first _ NaturalOdd = Expr b c
forall s a. Expr s a
NaturalOdd
first _ NaturalToInteger = Expr b c
forall s a. Expr s a
NaturalToInteger
first _ NaturalShow = Expr b c
forall s a. Expr s a
NaturalShow
first _ NaturalSubtract = Expr b c
forall s a. Expr s a
NaturalSubtract
first k :: a -> b
k (NaturalPlus a :: Expr a c
a b :: Expr a c
b ) = Expr b c -> Expr b c -> Expr b c
forall s a. Expr s a -> Expr s a -> Expr s a
NaturalPlus ((a -> b) -> Expr a c -> Expr b c
forall (p :: * -> * -> *) a b c.
Bifunctor p =>
(a -> b) -> p a c -> p b c
first a -> b
k Expr a c
a) ((a -> b) -> Expr a c -> Expr b c
forall (p :: * -> * -> *) a b c.
Bifunctor p =>
(a -> b) -> p a c -> p b c
first a -> b
k Expr a c
b)
first k :: a -> b
k (NaturalTimes a :: Expr a c
a b :: Expr a c
b ) = Expr b c -> Expr b c -> Expr b c
forall s a. Expr s a -> Expr s a -> Expr s a
NaturalTimes ((a -> b) -> Expr a c -> Expr b c
forall (p :: * -> * -> *) a b c.
Bifunctor p =>
(a -> b) -> p a c -> p b c
first a -> b
k Expr a c
a) ((a -> b) -> Expr a c -> Expr b c
forall (p :: * -> * -> *) a b c.
Bifunctor p =>
(a -> b) -> p a c -> p b c
first a -> b
k Expr a c
b)
first _ Integer = Expr b c
forall s a. Expr s a
Integer
first _ (IntegerLit a :: Integer
a ) = Integer -> Expr b c
forall s a. Integer -> Expr s a
IntegerLit Integer
a
first _ IntegerClamp = Expr b c
forall s a. Expr s a
IntegerClamp
first _ IntegerNegate = Expr b c
forall s a. Expr s a
IntegerNegate
first _ IntegerShow = Expr b c
forall s a. Expr s a
IntegerShow
first _ IntegerToDouble = Expr b c
forall s a. Expr s a
IntegerToDouble
first _ Double = Expr b c
forall s a. Expr s a
Double
first _ (DoubleLit a :: DhallDouble
a ) = DhallDouble -> Expr b c
forall s a. DhallDouble -> Expr s a
DoubleLit DhallDouble
a
first _ DoubleShow = Expr b c
forall s a. Expr s a
DoubleShow
first _ Text = Expr b c
forall s a. Expr s a
Text
first k :: a -> b
k (TextLit (Chunks a :: [(Text, Expr a c)]
a b :: Text
b)) = Chunks b c -> Expr b c
forall s a. Chunks s a -> Expr s a
TextLit ([(Text, Expr b c)] -> Text -> Chunks b c
forall s a. [(Text, Expr s a)] -> Text -> Chunks s a
Chunks (((Text, Expr a c) -> (Text, Expr b c))
-> [(Text, Expr a c)] -> [(Text, Expr b c)]
forall (f :: * -> *) a b. Functor f => (a -> b) -> f a -> f b
fmap ((Expr a c -> Expr b c) -> (Text, Expr a c) -> (Text, Expr b c)
forall (f :: * -> *) a b. Functor f => (a -> b) -> f a -> f b
fmap ((a -> b) -> Expr a c -> Expr b c
forall (p :: * -> * -> *) a b c.
Bifunctor p =>
(a -> b) -> p a c -> p b c
first a -> b
k)) [(Text, Expr a c)]
a) Text
b)
first k :: a -> b
k (TextAppend a :: Expr a c
a b :: Expr a c
b ) = Expr b c -> Expr b c -> Expr b c
forall s a. Expr s a -> Expr s a -> Expr s a
TextAppend ((a -> b) -> Expr a c -> Expr b c
forall (p :: * -> * -> *) a b c.
Bifunctor p =>
(a -> b) -> p a c -> p b c
first a -> b
k Expr a c
a) ((a -> b) -> Expr a c -> Expr b c
forall (p :: * -> * -> *) a b c.
Bifunctor p =>
(a -> b) -> p a c -> p b c
first a -> b
k Expr a c
b)
first _ TextShow = Expr b c
forall s a. Expr s a
TextShow
first _ List = Expr b c
forall s a. Expr s a
List
first k :: a -> b
k (ListLit a :: Maybe (Expr a c)
a b :: Seq (Expr a c)
b ) = Maybe (Expr b c) -> Seq (Expr b c) -> Expr b c
forall s a. Maybe (Expr s a) -> Seq (Expr s a) -> Expr s a
ListLit ((Expr a c -> Expr b c) -> Maybe (Expr a c) -> Maybe (Expr b c)
forall (f :: * -> *) a b. Functor f => (a -> b) -> f a -> f b
fmap ((a -> b) -> Expr a c -> Expr b c
forall (p :: * -> * -> *) a b c.
Bifunctor p =>
(a -> b) -> p a c -> p b c
first a -> b
k) Maybe (Expr a c)
a) ((Expr a c -> Expr b c) -> Seq (Expr a c) -> Seq (Expr b c)
forall (f :: * -> *) a b. Functor f => (a -> b) -> f a -> f b
fmap ((a -> b) -> Expr a c -> Expr b c
forall (p :: * -> * -> *) a b c.
Bifunctor p =>
(a -> b) -> p a c -> p b c
first a -> b
k) Seq (Expr a c)
b)
first k :: a -> b
k (ListAppend a :: Expr a c
a b :: Expr a c
b ) = Expr b c -> Expr b c -> Expr b c
forall s a. Expr s a -> Expr s a -> Expr s a
ListAppend ((a -> b) -> Expr a c -> Expr b c
forall (p :: * -> * -> *) a b c.
Bifunctor p =>
(a -> b) -> p a c -> p b c
first a -> b
k Expr a c
a) ((a -> b) -> Expr a c -> Expr b c
forall (p :: * -> * -> *) a b c.
Bifunctor p =>
(a -> b) -> p a c -> p b c
first a -> b
k Expr a c
b)
first _ ListBuild = Expr b c
forall s a. Expr s a
ListBuild
first _ ListFold = Expr b c
forall s a. Expr s a
ListFold
first _ ListLength = Expr b c
forall s a. Expr s a
ListLength
first _ ListHead = Expr b c
forall s a. Expr s a
ListHead
first _ ListLast = Expr b c
forall s a. Expr s a
ListLast
first _ ListIndexed = Expr b c
forall s a. Expr s a
ListIndexed
first _ ListReverse = Expr b c
forall s a. Expr s a
ListReverse
first _ Optional = Expr b c
forall s a. Expr s a
Optional
first k :: a -> b
k (Some a :: Expr a c
a ) = Expr b c -> Expr b c
forall s a. Expr s a -> Expr s a
Some ((a -> b) -> Expr a c -> Expr b c
forall (p :: * -> * -> *) a b c.
Bifunctor p =>
(a -> b) -> p a c -> p b c
first a -> b
k Expr a c
a)
first _ None = Expr b c
forall s a. Expr s a
None
first _ OptionalFold = Expr b c
forall s a. Expr s a
OptionalFold
first _ OptionalBuild = Expr b c
forall s a. Expr s a
OptionalBuild
first k :: a -> b
k (Record a :: Map Text (Expr a c)
a ) = Map Text (Expr b c) -> Expr b c
forall s a. Map Text (Expr s a) -> Expr s a
Record ((Expr a c -> Expr b c)
-> Map Text (Expr a c) -> Map Text (Expr b c)
forall (f :: * -> *) a b. Functor f => (a -> b) -> f a -> f b
fmap ((a -> b) -> Expr a c -> Expr b c
forall (p :: * -> * -> *) a b c.
Bifunctor p =>
(a -> b) -> p a c -> p b c
first a -> b
k) Map Text (Expr a c)
a)
first k :: a -> b
k (RecordLit a :: Map Text (Expr a c)
a ) = Map Text (Expr b c) -> Expr b c
forall s a. Map Text (Expr s a) -> Expr s a
RecordLit ((Expr a c -> Expr b c)
-> Map Text (Expr a c) -> Map Text (Expr b c)
forall (f :: * -> *) a b. Functor f => (a -> b) -> f a -> f b
fmap ((a -> b) -> Expr a c -> Expr b c
forall (p :: * -> * -> *) a b c.
Bifunctor p =>
(a -> b) -> p a c -> p b c
first a -> b
k) Map Text (Expr a c)
a)
first k :: a -> b
k (Union a :: Map Text (Maybe (Expr a c))
a ) = Map Text (Maybe (Expr b c)) -> Expr b c
forall s a. Map Text (Maybe (Expr s a)) -> Expr s a
Union ((Maybe (Expr a c) -> Maybe (Expr b c))
-> Map Text (Maybe (Expr a c)) -> Map Text (Maybe (Expr b c))
forall (f :: * -> *) a b. Functor f => (a -> b) -> f a -> f b
fmap ((Expr a c -> Expr b c) -> Maybe (Expr a c) -> Maybe (Expr b c)
forall (f :: * -> *) a b. Functor f => (a -> b) -> f a -> f b
fmap ((a -> b) -> Expr a c -> Expr b c
forall (p :: * -> * -> *) a b c.
Bifunctor p =>
(a -> b) -> p a c -> p b c
first a -> b
k)) Map Text (Maybe (Expr a c))
a)
first k :: a -> b
k (Combine a :: Maybe Text
a b :: Expr a c
b c :: Expr a c
c ) = Maybe Text -> Expr b c -> Expr b c -> Expr b c
forall s a. Maybe Text -> Expr s a -> Expr s a -> Expr s a
Combine Maybe Text
a ((a -> b) -> Expr a c -> Expr b c
forall (p :: * -> * -> *) a b c.
Bifunctor p =>
(a -> b) -> p a c -> p b c
first a -> b
k Expr a c
b) ((a -> b) -> Expr a c -> Expr b c
forall (p :: * -> * -> *) a b c.
Bifunctor p =>
(a -> b) -> p a c -> p b c
first a -> b
k Expr a c
c)
first k :: a -> b
k (CombineTypes a :: Expr a c
a b :: Expr a c
b ) = Expr b c -> Expr b c -> Expr b c
forall s a. Expr s a -> Expr s a -> Expr s a
CombineTypes ((a -> b) -> Expr a c -> Expr b c
forall (p :: * -> * -> *) a b c.
Bifunctor p =>
(a -> b) -> p a c -> p b c
first a -> b
k Expr a c
a) ((a -> b) -> Expr a c -> Expr b c
forall (p :: * -> * -> *) a b c.
Bifunctor p =>
(a -> b) -> p a c -> p b c
first a -> b
k Expr a c
b)
first k :: a -> b
k (Prefer a :: Expr a c
a b :: Expr a c
b ) = Expr b c -> Expr b c -> Expr b c
forall s a. Expr s a -> Expr s a -> Expr s a
Prefer ((a -> b) -> Expr a c -> Expr b c
forall (p :: * -> * -> *) a b c.
Bifunctor p =>
(a -> b) -> p a c -> p b c
first a -> b
k Expr a c
a) ((a -> b) -> Expr a c -> Expr b c
forall (p :: * -> * -> *) a b c.
Bifunctor p =>
(a -> b) -> p a c -> p b c
first a -> b
k Expr a c
b)
first k :: a -> b
k (RecordCompletion a :: Expr a c
a b :: Expr a c
b) = Expr b c -> Expr b c -> Expr b c
forall s a. Expr s a -> Expr s a -> Expr s a
RecordCompletion ((a -> b) -> Expr a c -> Expr b c
forall (p :: * -> * -> *) a b c.
Bifunctor p =>
(a -> b) -> p a c -> p b c
first a -> b
k Expr a c
a) ((a -> b) -> Expr a c -> Expr b c
forall (p :: * -> * -> *) a b c.
Bifunctor p =>
(a -> b) -> p a c -> p b c
first a -> b
k Expr a c
b)
first k :: a -> b
k (Merge a :: Expr a c
a b :: Expr a c
b c :: Maybe (Expr a c)
c ) = Expr b c -> Expr b c -> Maybe (Expr b c) -> Expr b c
forall s a. Expr s a -> Expr s a -> Maybe (Expr s a) -> Expr s a
Merge ((a -> b) -> Expr a c -> Expr b c
forall (p :: * -> * -> *) a b c.
Bifunctor p =>
(a -> b) -> p a c -> p b c
first a -> b
k Expr a c
a) ((a -> b) -> Expr a c -> Expr b c
forall (p :: * -> * -> *) a b c.
Bifunctor p =>
(a -> b) -> p a c -> p b c
first a -> b
k Expr a c
b) ((Expr a c -> Expr b c) -> Maybe (Expr a c) -> Maybe (Expr b c)
forall (f :: * -> *) a b. Functor f => (a -> b) -> f a -> f b
fmap ((a -> b) -> Expr a c -> Expr b c
forall (p :: * -> * -> *) a b c.
Bifunctor p =>
(a -> b) -> p a c -> p b c
first a -> b
k) Maybe (Expr a c)
c)
first k :: a -> b
k (ToMap a :: Expr a c
a b :: Maybe (Expr a c)
b ) = Expr b c -> Maybe (Expr b c) -> Expr b c
forall s a. Expr s a -> Maybe (Expr s a) -> Expr s a
ToMap ((a -> b) -> Expr a c -> Expr b c
forall (p :: * -> * -> *) a b c.
Bifunctor p =>
(a -> b) -> p a c -> p b c
first a -> b
k Expr a c
a) ((Expr a c -> Expr b c) -> Maybe (Expr a c) -> Maybe (Expr b c)
forall (f :: * -> *) a b. Functor f => (a -> b) -> f a -> f b
fmap ((a -> b) -> Expr a c -> Expr b c
forall (p :: * -> * -> *) a b c.
Bifunctor p =>
(a -> b) -> p a c -> p b c
first a -> b
k) Maybe (Expr a c)
b)
first k :: a -> b
k (Field a :: Expr a c
a b :: Text
b ) = Expr b c -> Text -> Expr b c
forall s a. Expr s a -> Text -> Expr s a
Field ((a -> b) -> Expr a c -> Expr b c
forall (p :: * -> * -> *) a b c.
Bifunctor p =>
(a -> b) -> p a c -> p b c
first a -> b
k Expr a c
a) Text
b
first k :: a -> b
k (Assert a :: Expr a c
a ) = Expr b c -> Expr b c
forall s a. Expr s a -> Expr s a
Assert ((a -> b) -> Expr a c -> Expr b c
forall (p :: * -> * -> *) a b c.
Bifunctor p =>
(a -> b) -> p a c -> p b c
first a -> b
k Expr a c
a)
first k :: a -> b
k (Equivalent a :: Expr a c
a b :: Expr a c
b ) = Expr b c -> Expr b c -> Expr b c
forall s a. Expr s a -> Expr s a -> Expr s a
Equivalent ((a -> b) -> Expr a c -> Expr b c
forall (p :: * -> * -> *) a b c.
Bifunctor p =>
(a -> b) -> p a c -> p b c
first a -> b
k Expr a c
a) ((a -> b) -> Expr a c -> Expr b c
forall (p :: * -> * -> *) a b c.
Bifunctor p =>
(a -> b) -> p a c -> p b c
first a -> b
k Expr a c
b)
first k :: a -> b
k (Project a :: Expr a c
a b :: Either (Set Text) (Expr a c)
b ) = Expr b c -> Either (Set Text) (Expr b c) -> Expr b c
forall s a. Expr s a -> Either (Set Text) (Expr s a) -> Expr s a
Project ((a -> b) -> Expr a c -> Expr b c
forall (p :: * -> * -> *) a b c.
Bifunctor p =>
(a -> b) -> p a c -> p b c
first a -> b
k Expr a c
a) ((Expr a c -> Expr b c)
-> Either (Set Text) (Expr a c) -> Either (Set Text) (Expr b c)
forall (f :: * -> *) a b. Functor f => (a -> b) -> f a -> f b
fmap ((a -> b) -> Expr a c -> Expr b c
forall (p :: * -> * -> *) a b c.
Bifunctor p =>
(a -> b) -> p a c -> p b c
first a -> b
k) Either (Set Text) (Expr a c)
b)
first k :: a -> b
k (Note a :: a
a b :: Expr a c
b ) = b -> Expr b c -> Expr b c
forall s a. s -> Expr s a -> Expr s a
Note (a -> b
k a
a) ((a -> b) -> Expr a c -> Expr b c
forall (p :: * -> * -> *) a b c.
Bifunctor p =>
(a -> b) -> p a c -> p b c
first a -> b
k Expr a c
b)
first k :: a -> b
k (ImportAlt a :: Expr a c
a b :: Expr a c
b ) = Expr b c -> Expr b c -> Expr b c
forall s a. Expr s a -> Expr s a -> Expr s a
ImportAlt ((a -> b) -> Expr a c -> Expr b c
forall (p :: * -> * -> *) a b c.
Bifunctor p =>
(a -> b) -> p a c -> p b c
first a -> b
k Expr a c
a) ((a -> b) -> Expr a c -> Expr b c
forall (p :: * -> * -> *) a b c.
Bifunctor p =>
(a -> b) -> p a c -> p b c
first a -> b
k Expr a c
b)
first _ (Embed a :: c
a ) = c -> Expr b c
forall s a. a -> Expr s a
Embed c
a
second :: (b -> c) -> Expr a b -> Expr a c
second = (b -> c) -> Expr a b -> Expr a c
forall (f :: * -> *) a b. Functor f => (a -> b) -> f a -> f b
fmap
instance IsString (Expr s a) where
fromString :: String -> Expr s a
fromString str :: String
str = Var -> Expr s a
forall s a. Var -> Expr s a
Var (String -> Var
forall a. IsString a => String -> a
fromString String
str)
instance Pretty a => Pretty (Expr s a) where
pretty :: Expr s a -> Doc ann
pretty = Doc Ann -> Doc ann
forall ann xxx. Doc ann -> Doc xxx
Pretty.unAnnotate (Doc Ann -> Doc ann)
-> (Expr s a -> Doc Ann) -> Expr s a -> Doc ann
forall b c a. (b -> c) -> (a -> b) -> a -> c
. Expr s a -> Doc Ann
forall a s. Pretty a => Expr s a -> Doc Ann
prettyExpr
multiLet :: Binding s a -> Expr s a -> MultiLet s a
multiLet :: Binding s a -> Expr s a -> MultiLet s a
multiLet b0 :: Binding s a
b0 = \case
Let b1 :: Binding s a
b1 e1 :: Expr s a
e1 ->
let MultiLet bs :: NonEmpty (Binding s a)
bs e :: Expr s a
e = Binding s a -> Expr s a -> MultiLet s a
forall s a. Binding s a -> Expr s a -> MultiLet s a
multiLet Binding s a
b1 Expr s a
e1
in NonEmpty (Binding s a) -> Expr s a -> MultiLet s a
forall s a. NonEmpty (Binding s a) -> Expr s a -> MultiLet s a
MultiLet (Binding s a -> NonEmpty (Binding s a) -> NonEmpty (Binding s a)
forall a. a -> NonEmpty a -> NonEmpty a
Data.List.NonEmpty.cons Binding s a
b0 NonEmpty (Binding s a)
bs) Expr s a
e
e :: Expr s a
e -> NonEmpty (Binding s a) -> Expr s a -> MultiLet s a
forall s a. NonEmpty (Binding s a) -> Expr s a -> MultiLet s a
MultiLet (Binding s a
b0 Binding s a -> [Binding s a] -> NonEmpty (Binding s a)
forall a. a -> [a] -> NonEmpty a
:| []) Expr s a
e
wrapInLets :: Foldable f => f (Binding s a) -> Expr s a -> Expr s a
wrapInLets :: f (Binding s a) -> Expr s a -> Expr s a
wrapInLets bs :: f (Binding s a)
bs e :: Expr s a
e = (Binding s a -> Expr s a -> Expr s a)
-> Expr s a -> f (Binding s a) -> Expr s a
forall (t :: * -> *) a b.
Foldable t =>
(a -> b -> b) -> b -> t a -> b
foldr Binding s a -> Expr s a -> Expr s a
forall s a. Binding s a -> Expr s a -> Expr s a
Let Expr s a
e f (Binding s a)
bs
data MultiLet s a = MultiLet (NonEmpty (Binding s a)) (Expr s a)
subExpressions :: Applicative f => (Expr s a -> f (Expr s a)) -> Expr s a -> f (Expr s a)
subExpressions :: (Expr s a -> f (Expr s a)) -> Expr s a -> f (Expr s a)
subExpressions _ (Const c :: Const
c) = Expr s a -> f (Expr s a)
forall (f :: * -> *) a. Applicative f => a -> f a
pure (Const -> Expr s a
forall s a. Const -> Expr s a
Const Const
c)
subExpressions _ (Var v :: Var
v) = Expr s a -> f (Expr s a)
forall (f :: * -> *) a. Applicative f => a -> f a
pure (Var -> Expr s a
forall s a. Var -> Expr s a
Var Var
v)
subExpressions f :: Expr s a -> f (Expr s a)
f (Lam a :: Text
a b :: Expr s a
b c :: Expr s a
c) = Text -> Expr s a -> Expr s a -> Expr s a
forall s a. Text -> Expr s a -> Expr s a -> Expr s a
Lam Text
a (Expr s a -> Expr s a -> Expr s a)
-> f (Expr s a) -> f (Expr s a -> Expr s a)
forall (f :: * -> *) a b. Functor f => (a -> b) -> f a -> f b
<$> Expr s a -> f (Expr s a)
f Expr s a
b f (Expr s a -> Expr s a) -> f (Expr s a) -> f (Expr s a)
forall (f :: * -> *) a b. Applicative f => f (a -> b) -> f a -> f b
<*> Expr s a -> f (Expr s a)
f Expr s a
c
subExpressions f :: Expr s a -> f (Expr s a)
f (Pi a :: Text
a b :: Expr s a
b c :: Expr s a
c) = Text -> Expr s a -> Expr s a -> Expr s a
forall s a. Text -> Expr s a -> Expr s a -> Expr s a
Pi Text
a (Expr s a -> Expr s a -> Expr s a)
-> f (Expr s a) -> f (Expr s a -> Expr s a)
forall (f :: * -> *) a b. Functor f => (a -> b) -> f a -> f b
<$> Expr s a -> f (Expr s a)
f Expr s a
b f (Expr s a -> Expr s a) -> f (Expr s a) -> f (Expr s a)
forall (f :: * -> *) a b. Applicative f => f (a -> b) -> f a -> f b
<*> Expr s a -> f (Expr s a)
f Expr s a
c
subExpressions f :: Expr s a -> f (Expr s a)
f (App a :: Expr s a
a b :: Expr s a
b) = Expr s a -> Expr s a -> Expr s a
forall s a. Expr s a -> Expr s a -> Expr s a
App (Expr s a -> Expr s a -> Expr s a)
-> f (Expr s a) -> f (Expr s a -> Expr s a)
forall (f :: * -> *) a b. Functor f => (a -> b) -> f a -> f b
<$> Expr s a -> f (Expr s a)
f Expr s a
a f (Expr s a -> Expr s a) -> f (Expr s a) -> f (Expr s a)
forall (f :: * -> *) a b. Applicative f => f (a -> b) -> f a -> f b
<*> Expr s a -> f (Expr s a)
f Expr s a
b
subExpressions f :: Expr s a -> f (Expr s a)
f (Let a :: Binding s a
a b :: Expr s a
b) = Binding s a -> Expr s a -> Expr s a
forall s a. Binding s a -> Expr s a -> Expr s a
Let (Binding s a -> Expr s a -> Expr s a)
-> f (Binding s a) -> f (Expr s a -> Expr s a)
forall (f :: * -> *) a b. Functor f => (a -> b) -> f a -> f b
<$> (Expr s a -> f (Expr s a)) -> Binding s a -> f (Binding s a)
forall (f :: * -> *) s a b.
Applicative f =>
(Expr s a -> f (Expr s b)) -> Binding s a -> f (Binding s b)
bindingExprs Expr s a -> f (Expr s a)
f Binding s a
a f (Expr s a -> Expr s a) -> f (Expr s a) -> f (Expr s a)
forall (f :: * -> *) a b. Applicative f => f (a -> b) -> f a -> f b
<*> Expr s a -> f (Expr s a)
f Expr s a
b
subExpressions f :: Expr s a -> f (Expr s a)
f (Annot a :: Expr s a
a b :: Expr s a
b) = Expr s a -> Expr s a -> Expr s a
forall s a. Expr s a -> Expr s a -> Expr s a
Annot (Expr s a -> Expr s a -> Expr s a)
-> f (Expr s a) -> f (Expr s a -> Expr s a)
forall (f :: * -> *) a b. Functor f => (a -> b) -> f a -> f b
<$> Expr s a -> f (Expr s a)
f Expr s a
a f (Expr s a -> Expr s a) -> f (Expr s a) -> f (Expr s a)
forall (f :: * -> *) a b. Applicative f => f (a -> b) -> f a -> f b
<*> Expr s a -> f (Expr s a)
f Expr s a
b
subExpressions _ Bool = Expr s a -> f (Expr s a)
forall (f :: * -> *) a. Applicative f => a -> f a
pure Expr s a
forall s a. Expr s a
Bool
subExpressions _ (BoolLit b :: Bool
b) = Expr s a -> f (Expr s a)
forall (f :: * -> *) a. Applicative f => a -> f a
pure (Bool -> Expr s a
forall s a. Bool -> Expr s a
BoolLit Bool
b)
subExpressions f :: Expr s a -> f (Expr s a)
f (BoolAnd a :: Expr s a
a b :: Expr s a
b) = Expr s a -> Expr s a -> Expr s a
forall s a. Expr s a -> Expr s a -> Expr s a
BoolAnd (Expr s a -> Expr s a -> Expr s a)
-> f (Expr s a) -> f (Expr s a -> Expr s a)
forall (f :: * -> *) a b. Functor f => (a -> b) -> f a -> f b
<$> Expr s a -> f (Expr s a)
f Expr s a
a f (Expr s a -> Expr s a) -> f (Expr s a) -> f (Expr s a)
forall (f :: * -> *) a b. Applicative f => f (a -> b) -> f a -> f b
<*> Expr s a -> f (Expr s a)
f Expr s a
b
subExpressions f :: Expr s a -> f (Expr s a)
f (BoolOr a :: Expr s a
a b :: Expr s a
b) = Expr s a -> Expr s a -> Expr s a
forall s a. Expr s a -> Expr s a -> Expr s a
BoolOr (Expr s a -> Expr s a -> Expr s a)
-> f (Expr s a) -> f (Expr s a -> Expr s a)
forall (f :: * -> *) a b. Functor f => (a -> b) -> f a -> f b
<$> Expr s a -> f (Expr s a)
f Expr s a
a f (Expr s a -> Expr s a) -> f (Expr s a) -> f (Expr s a)
forall (f :: * -> *) a b. Applicative f => f (a -> b) -> f a -> f b
<*> Expr s a -> f (Expr s a)
f Expr s a
b
subExpressions f :: Expr s a -> f (Expr s a)
f (BoolEQ a :: Expr s a
a b :: Expr s a
b) = Expr s a -> Expr s a -> Expr s a
forall s a. Expr s a -> Expr s a -> Expr s a
BoolEQ (Expr s a -> Expr s a -> Expr s a)
-> f (Expr s a) -> f (Expr s a -> Expr s a)
forall (f :: * -> *) a b. Functor f => (a -> b) -> f a -> f b
<$> Expr s a -> f (Expr s a)
f Expr s a
a f (Expr s a -> Expr s a) -> f (Expr s a) -> f (Expr s a)
forall (f :: * -> *) a b. Applicative f => f (a -> b) -> f a -> f b
<*> Expr s a -> f (Expr s a)
f Expr s a
b
subExpressions f :: Expr s a -> f (Expr s a)
f (BoolNE a :: Expr s a
a b :: Expr s a
b) = Expr s a -> Expr s a -> Expr s a
forall s a. Expr s a -> Expr s a -> Expr s a
BoolNE (Expr s a -> Expr s a -> Expr s a)
-> f (Expr s a) -> f (Expr s a -> Expr s a)
forall (f :: * -> *) a b. Functor f => (a -> b) -> f a -> f b
<$> Expr s a -> f (Expr s a)
f Expr s a
a f (Expr s a -> Expr s a) -> f (Expr s a) -> f (Expr s a)
forall (f :: * -> *) a b. Applicative f => f (a -> b) -> f a -> f b
<*> Expr s a -> f (Expr s a)
f Expr s a
b
subExpressions f :: Expr s a -> f (Expr s a)
f (BoolIf a :: Expr s a
a b :: Expr s a
b c :: Expr s a
c) = Expr s a -> Expr s a -> Expr s a -> Expr s a
forall s a. Expr s a -> Expr s a -> Expr s a -> Expr s a
BoolIf (Expr s a -> Expr s a -> Expr s a -> Expr s a)
-> f (Expr s a) -> f (Expr s a -> Expr s a -> Expr s a)
forall (f :: * -> *) a b. Functor f => (a -> b) -> f a -> f b
<$> Expr s a -> f (Expr s a)
f Expr s a
a f (Expr s a -> Expr s a -> Expr s a)
-> f (Expr s a) -> f (Expr s a -> Expr s a)
forall (f :: * -> *) a b. Applicative f => f (a -> b) -> f a -> f b
<*> Expr s a -> f (Expr s a)
f Expr s a
b f (Expr s a -> Expr s a) -> f (Expr s a) -> f (Expr s a)
forall (f :: * -> *) a b. Applicative f => f (a -> b) -> f a -> f b
<*> Expr s a -> f (Expr s a)
f Expr s a
c
subExpressions _ Natural = Expr s a -> f (Expr s a)
forall (f :: * -> *) a. Applicative f => a -> f a
pure Expr s a
forall s a. Expr s a
Natural
subExpressions _ (NaturalLit n :: Natural
n) = Expr s a -> f (Expr s a)
forall (f :: * -> *) a. Applicative f => a -> f a
pure (Natural -> Expr s a
forall s a. Natural -> Expr s a
NaturalLit Natural
n)
subExpressions _ NaturalFold = Expr s a -> f (Expr s a)
forall (f :: * -> *) a. Applicative f => a -> f a
pure Expr s a
forall s a. Expr s a
NaturalFold
subExpressions _ NaturalBuild = Expr s a -> f (Expr s a)
forall (f :: * -> *) a. Applicative f => a -> f a
pure Expr s a
forall s a. Expr s a
NaturalBuild
subExpressions _ NaturalIsZero = Expr s a -> f (Expr s a)
forall (f :: * -> *) a. Applicative f => a -> f a
pure Expr s a
forall s a. Expr s a
NaturalIsZero
subExpressions _ NaturalEven = Expr s a -> f (Expr s a)
forall (f :: * -> *) a. Applicative f => a -> f a
pure Expr s a
forall s a. Expr s a
NaturalEven
subExpressions _ NaturalOdd = Expr s a -> f (Expr s a)
forall (f :: * -> *) a. Applicative f => a -> f a
pure Expr s a
forall s a. Expr s a
NaturalOdd
subExpressions _ NaturalToInteger = Expr s a -> f (Expr s a)
forall (f :: * -> *) a. Applicative f => a -> f a
pure Expr s a
forall s a. Expr s a
NaturalToInteger
subExpressions _ NaturalShow = Expr s a -> f (Expr s a)
forall (f :: * -> *) a. Applicative f => a -> f a
pure Expr s a
forall s a. Expr s a
NaturalShow
subExpressions _ NaturalSubtract = Expr s a -> f (Expr s a)
forall (f :: * -> *) a. Applicative f => a -> f a
pure Expr s a
forall s a. Expr s a
NaturalSubtract
subExpressions f :: Expr s a -> f (Expr s a)
f (NaturalPlus a :: Expr s a
a b :: Expr s a
b) = Expr s a -> Expr s a -> Expr s a
forall s a. Expr s a -> Expr s a -> Expr s a
NaturalPlus (Expr s a -> Expr s a -> Expr s a)
-> f (Expr s a) -> f (Expr s a -> Expr s a)
forall (f :: * -> *) a b. Functor f => (a -> b) -> f a -> f b
<$> Expr s a -> f (Expr s a)
f Expr s a
a f (Expr s a -> Expr s a) -> f (Expr s a) -> f (Expr s a)
forall (f :: * -> *) a b. Applicative f => f (a -> b) -> f a -> f b
<*> Expr s a -> f (Expr s a)
f Expr s a
b
subExpressions f :: Expr s a -> f (Expr s a)
f (NaturalTimes a :: Expr s a
a b :: Expr s a
b) = Expr s a -> Expr s a -> Expr s a
forall s a. Expr s a -> Expr s a -> Expr s a
NaturalTimes (Expr s a -> Expr s a -> Expr s a)
-> f (Expr s a) -> f (Expr s a -> Expr s a)
forall (f :: * -> *) a b. Functor f => (a -> b) -> f a -> f b
<$> Expr s a -> f (Expr s a)
f Expr s a
a f (Expr s a -> Expr s a) -> f (Expr s a) -> f (Expr s a)
forall (f :: * -> *) a b. Applicative f => f (a -> b) -> f a -> f b
<*> Expr s a -> f (Expr s a)
f Expr s a
b
subExpressions _ Integer = Expr s a -> f (Expr s a)
forall (f :: * -> *) a. Applicative f => a -> f a
pure Expr s a
forall s a. Expr s a
Integer
subExpressions _ (IntegerLit n :: Integer
n) = Expr s a -> f (Expr s a)
forall (f :: * -> *) a. Applicative f => a -> f a
pure (Integer -> Expr s a
forall s a. Integer -> Expr s a
IntegerLit Integer
n)
subExpressions _ IntegerClamp = Expr s a -> f (Expr s a)
forall (f :: * -> *) a. Applicative f => a -> f a
pure Expr s a
forall s a. Expr s a
IntegerClamp
subExpressions _ IntegerNegate = Expr s a -> f (Expr s a)
forall (f :: * -> *) a. Applicative f => a -> f a
pure Expr s a
forall s a. Expr s a
IntegerNegate
subExpressions _ IntegerShow = Expr s a -> f (Expr s a)
forall (f :: * -> *) a. Applicative f => a -> f a
pure Expr s a
forall s a. Expr s a
IntegerShow
subExpressions _ IntegerToDouble = Expr s a -> f (Expr s a)
forall (f :: * -> *) a. Applicative f => a -> f a
pure Expr s a
forall s a. Expr s a
IntegerToDouble
subExpressions _ Double = Expr s a -> f (Expr s a)
forall (f :: * -> *) a. Applicative f => a -> f a
pure Expr s a
forall s a. Expr s a
Double
subExpressions _ (DoubleLit n :: DhallDouble
n) = Expr s a -> f (Expr s a)
forall (f :: * -> *) a. Applicative f => a -> f a
pure (DhallDouble -> Expr s a
forall s a. DhallDouble -> Expr s a
DoubleLit DhallDouble
n)
subExpressions _ DoubleShow = Expr s a -> f (Expr s a)
forall (f :: * -> *) a. Applicative f => a -> f a
pure Expr s a
forall s a. Expr s a
DoubleShow
subExpressions _ Text = Expr s a -> f (Expr s a)
forall (f :: * -> *) a. Applicative f => a -> f a
pure Expr s a
forall s a. Expr s a
Text
subExpressions f :: Expr s a -> f (Expr s a)
f (TextLit chunks :: Chunks s a
chunks) =
Chunks s a -> Expr s a
forall s a. Chunks s a -> Expr s a
TextLit (Chunks s a -> Expr s a) -> f (Chunks s a) -> f (Expr s a)
forall (f :: * -> *) a b. Functor f => (a -> b) -> f a -> f b
<$> (Expr s a -> f (Expr s a)) -> Chunks s a -> f (Chunks s a)
forall (f :: * -> *) s a t b.
Applicative f =>
(Expr s a -> f (Expr t b)) -> Chunks s a -> f (Chunks t b)
chunkExprs Expr s a -> f (Expr s a)
f Chunks s a
chunks
subExpressions f :: Expr s a -> f (Expr s a)
f (TextAppend a :: Expr s a
a b :: Expr s a
b) = Expr s a -> Expr s a -> Expr s a
forall s a. Expr s a -> Expr s a -> Expr s a
TextAppend (Expr s a -> Expr s a -> Expr s a)
-> f (Expr s a) -> f (Expr s a -> Expr s a)
forall (f :: * -> *) a b. Functor f => (a -> b) -> f a -> f b
<$> Expr s a -> f (Expr s a)
f Expr s a
a f (Expr s a -> Expr s a) -> f (Expr s a) -> f (Expr s a)
forall (f :: * -> *) a b. Applicative f => f (a -> b) -> f a -> f b
<*> Expr s a -> f (Expr s a)
f Expr s a
b
subExpressions _ TextShow = Expr s a -> f (Expr s a)
forall (f :: * -> *) a. Applicative f => a -> f a
pure Expr s a
forall s a. Expr s a
TextShow
subExpressions _ List = Expr s a -> f (Expr s a)
forall (f :: * -> *) a. Applicative f => a -> f a
pure Expr s a
forall s a. Expr s a
List
subExpressions f :: Expr s a -> f (Expr s a)
f (ListLit a :: Maybe (Expr s a)
a b :: Seq (Expr s a)
b) = Maybe (Expr s a) -> Seq (Expr s a) -> Expr s a
forall s a. Maybe (Expr s a) -> Seq (Expr s a) -> Expr s a
ListLit (Maybe (Expr s a) -> Seq (Expr s a) -> Expr s a)
-> f (Maybe (Expr s a)) -> f (Seq (Expr s a) -> Expr s a)
forall (f :: * -> *) a b. Functor f => (a -> b) -> f a -> f b
<$> (Expr s a -> f (Expr s a))
-> Maybe (Expr s a) -> f (Maybe (Expr s a))
forall (t :: * -> *) (f :: * -> *) a b.
(Traversable t, Applicative f) =>
(a -> f b) -> t a -> f (t b)
traverse Expr s a -> f (Expr s a)
f Maybe (Expr s a)
a f (Seq (Expr s a) -> Expr s a)
-> f (Seq (Expr s a)) -> f (Expr s a)
forall (f :: * -> *) a b. Applicative f => f (a -> b) -> f a -> f b
<*> (Expr s a -> f (Expr s a)) -> Seq (Expr s a) -> f (Seq (Expr s a))
forall (t :: * -> *) (f :: * -> *) a b.
(Traversable t, Applicative f) =>
(a -> f b) -> t a -> f (t b)
traverse Expr s a -> f (Expr s a)
f Seq (Expr s a)
b
subExpressions f :: Expr s a -> f (Expr s a)
f (ListAppend a :: Expr s a
a b :: Expr s a
b) = Expr s a -> Expr s a -> Expr s a
forall s a. Expr s a -> Expr s a -> Expr s a
ListAppend (Expr s a -> Expr s a -> Expr s a)
-> f (Expr s a) -> f (Expr s a -> Expr s a)
forall (f :: * -> *) a b. Functor f => (a -> b) -> f a -> f b
<$> Expr s a -> f (Expr s a)
f Expr s a
a f (Expr s a -> Expr s a) -> f (Expr s a) -> f (Expr s a)
forall (f :: * -> *) a b. Applicative f => f (a -> b) -> f a -> f b
<*> Expr s a -> f (Expr s a)
f Expr s a
b
subExpressions _ ListBuild = Expr s a -> f (Expr s a)
forall (f :: * -> *) a. Applicative f => a -> f a
pure Expr s a
forall s a. Expr s a
ListBuild
subExpressions _ ListFold = Expr s a -> f (Expr s a)
forall (f :: * -> *) a. Applicative f => a -> f a
pure Expr s a
forall s a. Expr s a
ListFold
subExpressions _ ListLength = Expr s a -> f (Expr s a)
forall (f :: * -> *) a. Applicative f => a -> f a
pure Expr s a
forall s a. Expr s a
ListLength
subExpressions _ ListHead = Expr s a -> f (Expr s a)
forall (f :: * -> *) a. Applicative f => a -> f a
pure Expr s a
forall s a. Expr s a
ListHead
subExpressions _ ListLast = Expr s a -> f (Expr s a)
forall (f :: * -> *) a. Applicative f => a -> f a
pure Expr s a
forall s a. Expr s a
ListLast
subExpressions _ ListIndexed = Expr s a -> f (Expr s a)
forall (f :: * -> *) a. Applicative f => a -> f a
pure Expr s a
forall s a. Expr s a
ListIndexed
subExpressions _ ListReverse = Expr s a -> f (Expr s a)
forall (f :: * -> *) a. Applicative f => a -> f a
pure Expr s a
forall s a. Expr s a
ListReverse
subExpressions _ Optional = Expr s a -> f (Expr s a)
forall (f :: * -> *) a. Applicative f => a -> f a
pure Expr s a
forall s a. Expr s a
Optional
subExpressions f :: Expr s a -> f (Expr s a)
f (Some a :: Expr s a
a) = Expr s a -> Expr s a
forall s a. Expr s a -> Expr s a
Some (Expr s a -> Expr s a) -> f (Expr s a) -> f (Expr s a)
forall (f :: * -> *) a b. Functor f => (a -> b) -> f a -> f b
<$> Expr s a -> f (Expr s a)
f Expr s a
a
subExpressions _ None = Expr s a -> f (Expr s a)
forall (f :: * -> *) a. Applicative f => a -> f a
pure Expr s a
forall s a. Expr s a
None
subExpressions _ OptionalFold = Expr s a -> f (Expr s a)
forall (f :: * -> *) a. Applicative f => a -> f a
pure Expr s a
forall s a. Expr s a
OptionalFold
subExpressions _ OptionalBuild = Expr s a -> f (Expr s a)
forall (f :: * -> *) a. Applicative f => a -> f a
pure Expr s a
forall s a. Expr s a
OptionalBuild
subExpressions f :: Expr s a -> f (Expr s a)
f (Record a :: Map Text (Expr s a)
a) = Map Text (Expr s a) -> Expr s a
forall s a. Map Text (Expr s a) -> Expr s a
Record (Map Text (Expr s a) -> Expr s a)
-> f (Map Text (Expr s a)) -> f (Expr s a)
forall (f :: * -> *) a b. Functor f => (a -> b) -> f a -> f b
<$> (Expr s a -> f (Expr s a))
-> Map Text (Expr s a) -> f (Map Text (Expr s a))
forall (t :: * -> *) (f :: * -> *) a b.
(Traversable t, Applicative f) =>
(a -> f b) -> t a -> f (t b)
traverse Expr s a -> f (Expr s a)
f Map Text (Expr s a)
a
subExpressions f :: Expr s a -> f (Expr s a)
f ( RecordLit a :: Map Text (Expr s a)
a ) = Map Text (Expr s a) -> Expr s a
forall s a. Map Text (Expr s a) -> Expr s a
RecordLit (Map Text (Expr s a) -> Expr s a)
-> f (Map Text (Expr s a)) -> f (Expr s a)
forall (f :: * -> *) a b. Functor f => (a -> b) -> f a -> f b
<$> (Expr s a -> f (Expr s a))
-> Map Text (Expr s a) -> f (Map Text (Expr s a))
forall (t :: * -> *) (f :: * -> *) a b.
(Traversable t, Applicative f) =>
(a -> f b) -> t a -> f (t b)
traverse Expr s a -> f (Expr s a)
f Map Text (Expr s a)
a
subExpressions f :: Expr s a -> f (Expr s a)
f (Union a :: Map Text (Maybe (Expr s a))
a) = Map Text (Maybe (Expr s a)) -> Expr s a
forall s a. Map Text (Maybe (Expr s a)) -> Expr s a
Union (Map Text (Maybe (Expr s a)) -> Expr s a)
-> f (Map Text (Maybe (Expr s a))) -> f (Expr s a)
forall (f :: * -> *) a b. Functor f => (a -> b) -> f a -> f b
<$> (Maybe (Expr s a) -> f (Maybe (Expr s a)))
-> Map Text (Maybe (Expr s a)) -> f (Map Text (Maybe (Expr s a)))
forall (t :: * -> *) (f :: * -> *) a b.
(Traversable t, Applicative f) =>
(a -> f b) -> t a -> f (t b)
traverse ((Expr s a -> f (Expr s a))
-> Maybe (Expr s a) -> f (Maybe (Expr s a))
forall (t :: * -> *) (f :: * -> *) a b.
(Traversable t, Applicative f) =>
(a -> f b) -> t a -> f (t b)
traverse Expr s a -> f (Expr s a)
f) Map Text (Maybe (Expr s a))
a
subExpressions f :: Expr s a -> f (Expr s a)
f (Combine a :: Maybe Text
a b :: Expr s a
b c :: Expr s a
c) = Maybe Text -> Expr s a -> Expr s a -> Expr s a
forall s a. Maybe Text -> Expr s a -> Expr s a -> Expr s a
Combine Maybe Text
a (Expr s a -> Expr s a -> Expr s a)
-> f (Expr s a) -> f (Expr s a -> Expr s a)
forall (f :: * -> *) a b. Functor f => (a -> b) -> f a -> f b
<$> Expr s a -> f (Expr s a)
f Expr s a
b f (Expr s a -> Expr s a) -> f (Expr s a) -> f (Expr s a)
forall (f :: * -> *) a b. Applicative f => f (a -> b) -> f a -> f b
<*> Expr s a -> f (Expr s a)
f Expr s a
c
subExpressions f :: Expr s a -> f (Expr s a)
f (CombineTypes a :: Expr s a
a b :: Expr s a
b) = Expr s a -> Expr s a -> Expr s a
forall s a. Expr s a -> Expr s a -> Expr s a
CombineTypes (Expr s a -> Expr s a -> Expr s a)
-> f (Expr s a) -> f (Expr s a -> Expr s a)
forall (f :: * -> *) a b. Functor f => (a -> b) -> f a -> f b
<$> Expr s a -> f (Expr s a)
f Expr s a
a f (Expr s a -> Expr s a) -> f (Expr s a) -> f (Expr s a)
forall (f :: * -> *) a b. Applicative f => f (a -> b) -> f a -> f b
<*> Expr s a -> f (Expr s a)
f Expr s a
b
subExpressions f :: Expr s a -> f (Expr s a)
f (Prefer a :: Expr s a
a b :: Expr s a
b) = Expr s a -> Expr s a -> Expr s a
forall s a. Expr s a -> Expr s a -> Expr s a
Prefer (Expr s a -> Expr s a -> Expr s a)
-> f (Expr s a) -> f (Expr s a -> Expr s a)
forall (f :: * -> *) a b. Functor f => (a -> b) -> f a -> f b
<$> Expr s a -> f (Expr s a)
f Expr s a
a f (Expr s a -> Expr s a) -> f (Expr s a) -> f (Expr s a)
forall (f :: * -> *) a b. Applicative f => f (a -> b) -> f a -> f b
<*> Expr s a -> f (Expr s a)
f Expr s a
b
subExpressions f :: Expr s a -> f (Expr s a)
f (RecordCompletion a :: Expr s a
a b :: Expr s a
b) = Expr s a -> Expr s a -> Expr s a
forall s a. Expr s a -> Expr s a -> Expr s a
RecordCompletion (Expr s a -> Expr s a -> Expr s a)
-> f (Expr s a) -> f (Expr s a -> Expr s a)
forall (f :: * -> *) a b. Functor f => (a -> b) -> f a -> f b
<$> Expr s a -> f (Expr s a)
f Expr s a
a f (Expr s a -> Expr s a) -> f (Expr s a) -> f (Expr s a)
forall (f :: * -> *) a b. Applicative f => f (a -> b) -> f a -> f b
<*> Expr s a -> f (Expr s a)
f Expr s a
b
subExpressions f :: Expr s a -> f (Expr s a)
f (Merge a :: Expr s a
a b :: Expr s a
b t :: Maybe (Expr s a)
t) = Expr s a -> Expr s a -> Maybe (Expr s a) -> Expr s a
forall s a. Expr s a -> Expr s a -> Maybe (Expr s a) -> Expr s a
Merge (Expr s a -> Expr s a -> Maybe (Expr s a) -> Expr s a)
-> f (Expr s a) -> f (Expr s a -> Maybe (Expr s a) -> Expr s a)
forall (f :: * -> *) a b. Functor f => (a -> b) -> f a -> f b
<$> Expr s a -> f (Expr s a)
f Expr s a
a f (Expr s a -> Maybe (Expr s a) -> Expr s a)
-> f (Expr s a) -> f (Maybe (Expr s a) -> Expr s a)
forall (f :: * -> *) a b. Applicative f => f (a -> b) -> f a -> f b
<*> Expr s a -> f (Expr s a)
f Expr s a
b f (Maybe (Expr s a) -> Expr s a)
-> f (Maybe (Expr s a)) -> f (Expr s a)
forall (f :: * -> *) a b. Applicative f => f (a -> b) -> f a -> f b
<*> (Expr s a -> f (Expr s a))
-> Maybe (Expr s a) -> f (Maybe (Expr s a))
forall (t :: * -> *) (f :: * -> *) a b.
(Traversable t, Applicative f) =>
(a -> f b) -> t a -> f (t b)
traverse Expr s a -> f (Expr s a)
f Maybe (Expr s a)
t
subExpressions f :: Expr s a -> f (Expr s a)
f (ToMap a :: Expr s a
a t :: Maybe (Expr s a)
t) = Expr s a -> Maybe (Expr s a) -> Expr s a
forall s a. Expr s a -> Maybe (Expr s a) -> Expr s a
ToMap (Expr s a -> Maybe (Expr s a) -> Expr s a)
-> f (Expr s a) -> f (Maybe (Expr s a) -> Expr s a)
forall (f :: * -> *) a b. Functor f => (a -> b) -> f a -> f b
<$> Expr s a -> f (Expr s a)
f Expr s a
a f (Maybe (Expr s a) -> Expr s a)
-> f (Maybe (Expr s a)) -> f (Expr s a)
forall (f :: * -> *) a b. Applicative f => f (a -> b) -> f a -> f b
<*> (Expr s a -> f (Expr s a))
-> Maybe (Expr s a) -> f (Maybe (Expr s a))
forall (t :: * -> *) (f :: * -> *) a b.
(Traversable t, Applicative f) =>
(a -> f b) -> t a -> f (t b)
traverse Expr s a -> f (Expr s a)
f Maybe (Expr s a)
t
subExpressions f :: Expr s a -> f (Expr s a)
f (Field a :: Expr s a
a b :: Text
b) = Expr s a -> Text -> Expr s a
forall s a. Expr s a -> Text -> Expr s a
Field (Expr s a -> Text -> Expr s a)
-> f (Expr s a) -> f (Text -> Expr s a)
forall (f :: * -> *) a b. Functor f => (a -> b) -> f a -> f b
<$> Expr s a -> f (Expr s a)
f Expr s a
a f (Text -> Expr s a) -> f Text -> f (Expr s a)
forall (f :: * -> *) a b. Applicative f => f (a -> b) -> f a -> f b
<*> Text -> f Text
forall (f :: * -> *) a. Applicative f => a -> f a
pure Text
b
subExpressions f :: Expr s a -> f (Expr s a)
f (Project a :: Expr s a
a b :: Either (Set Text) (Expr s a)
b) = Expr s a -> Either (Set Text) (Expr s a) -> Expr s a
forall s a. Expr s a -> Either (Set Text) (Expr s a) -> Expr s a
Project (Expr s a -> Either (Set Text) (Expr s a) -> Expr s a)
-> f (Expr s a) -> f (Either (Set Text) (Expr s a) -> Expr s a)
forall (f :: * -> *) a b. Functor f => (a -> b) -> f a -> f b
<$> Expr s a -> f (Expr s a)
f Expr s a
a f (Either (Set Text) (Expr s a) -> Expr s a)
-> f (Either (Set Text) (Expr s a)) -> f (Expr s a)
forall (f :: * -> *) a b. Applicative f => f (a -> b) -> f a -> f b
<*> (Expr s a -> f (Expr s a))
-> Either (Set Text) (Expr s a) -> f (Either (Set Text) (Expr s a))
forall (t :: * -> *) (f :: * -> *) a b.
(Traversable t, Applicative f) =>
(a -> f b) -> t a -> f (t b)
traverse Expr s a -> f (Expr s a)
f Either (Set Text) (Expr s a)
b
subExpressions f :: Expr s a -> f (Expr s a)
f (Assert a :: Expr s a
a) = Expr s a -> Expr s a
forall s a. Expr s a -> Expr s a
Assert (Expr s a -> Expr s a) -> f (Expr s a) -> f (Expr s a)
forall (f :: * -> *) a b. Functor f => (a -> b) -> f a -> f b
<$> Expr s a -> f (Expr s a)
f Expr s a
a
subExpressions f :: Expr s a -> f (Expr s a)
f (Equivalent a :: Expr s a
a b :: Expr s a
b) = Expr s a -> Expr s a -> Expr s a
forall s a. Expr s a -> Expr s a -> Expr s a
Equivalent (Expr s a -> Expr s a -> Expr s a)
-> f (Expr s a) -> f (Expr s a -> Expr s a)
forall (f :: * -> *) a b. Functor f => (a -> b) -> f a -> f b
<$> Expr s a -> f (Expr s a)
f Expr s a
a f (Expr s a -> Expr s a) -> f (Expr s a) -> f (Expr s a)
forall (f :: * -> *) a b. Applicative f => f (a -> b) -> f a -> f b
<*> Expr s a -> f (Expr s a)
f Expr s a
b
subExpressions f :: Expr s a -> f (Expr s a)
f (Note a :: s
a b :: Expr s a
b) = s -> Expr s a -> Expr s a
forall s a. s -> Expr s a -> Expr s a
Note s
a (Expr s a -> Expr s a) -> f (Expr s a) -> f (Expr s a)
forall (f :: * -> *) a b. Functor f => (a -> b) -> f a -> f b
<$> Expr s a -> f (Expr s a)
f Expr s a
b
subExpressions f :: Expr s a -> f (Expr s a)
f (ImportAlt l :: Expr s a
l r :: Expr s a
r) = Expr s a -> Expr s a -> Expr s a
forall s a. Expr s a -> Expr s a -> Expr s a
ImportAlt (Expr s a -> Expr s a -> Expr s a)
-> f (Expr s a) -> f (Expr s a -> Expr s a)
forall (f :: * -> *) a b. Functor f => (a -> b) -> f a -> f b
<$> Expr s a -> f (Expr s a)
f Expr s a
l f (Expr s a -> Expr s a) -> f (Expr s a) -> f (Expr s a)
forall (f :: * -> *) a b. Applicative f => f (a -> b) -> f a -> f b
<*> Expr s a -> f (Expr s a)
f Expr s a
r
subExpressions _ (Embed a :: a
a) = Expr s a -> f (Expr s a)
forall (f :: * -> *) a. Applicative f => a -> f a
pure (a -> Expr s a
forall s a. a -> Expr s a
Embed a
a)
bindingExprs
:: (Applicative f)
=> (Expr s a -> f (Expr s b))
-> Binding s a -> f (Binding s b)
bindingExprs :: (Expr s a -> f (Expr s b)) -> Binding s a -> f (Binding s b)
bindingExprs f :: Expr s a -> f (Expr s b)
f (Binding s0 :: Maybe s
s0 n :: Text
n s1 :: Maybe s
s1 t :: Maybe (Maybe s, Expr s a)
t s2 :: Maybe s
s2 v :: Expr s a
v) =
Maybe s
-> Text
-> Maybe s
-> Maybe (Maybe s, Expr s b)
-> Maybe s
-> Expr s b
-> Binding s b
forall s a.
Maybe s
-> Text
-> Maybe s
-> Maybe (Maybe s, Expr s a)
-> Maybe s
-> Expr s a
-> Binding s a
Binding
(Maybe s
-> Text
-> Maybe s
-> Maybe (Maybe s, Expr s b)
-> Maybe s
-> Expr s b
-> Binding s b)
-> f (Maybe s)
-> f (Text
-> Maybe s
-> Maybe (Maybe s, Expr s b)
-> Maybe s
-> Expr s b
-> Binding s b)
forall (f :: * -> *) a b. Functor f => (a -> b) -> f a -> f b
<$> Maybe s -> f (Maybe s)
forall (f :: * -> *) a. Applicative f => a -> f a
pure Maybe s
s0
f (Text
-> Maybe s
-> Maybe (Maybe s, Expr s b)
-> Maybe s
-> Expr s b
-> Binding s b)
-> f Text
-> f (Maybe s
-> Maybe (Maybe s, Expr s b) -> Maybe s -> Expr s b -> Binding s b)
forall (f :: * -> *) a b. Applicative f => f (a -> b) -> f a -> f b
<*> Text -> f Text
forall (f :: * -> *) a. Applicative f => a -> f a
pure Text
n
f (Maybe s
-> Maybe (Maybe s, Expr s b) -> Maybe s -> Expr s b -> Binding s b)
-> f (Maybe s)
-> f (Maybe (Maybe s, Expr s b)
-> Maybe s -> Expr s b -> Binding s b)
forall (f :: * -> *) a b. Applicative f => f (a -> b) -> f a -> f b
<*> Maybe s -> f (Maybe s)
forall (f :: * -> *) a. Applicative f => a -> f a
pure Maybe s
s1
f (Maybe (Maybe s, Expr s b) -> Maybe s -> Expr s b -> Binding s b)
-> f (Maybe (Maybe s, Expr s b))
-> f (Maybe s -> Expr s b -> Binding s b)
forall (f :: * -> *) a b. Applicative f => f (a -> b) -> f a -> f b
<*> ((Maybe s, Expr s a) -> f (Maybe s, Expr s b))
-> Maybe (Maybe s, Expr s a) -> f (Maybe (Maybe s, Expr s b))
forall (t :: * -> *) (f :: * -> *) a b.
(Traversable t, Applicative f) =>
(a -> f b) -> t a -> f (t b)
traverse ((Expr s a -> f (Expr s b))
-> (Maybe s, Expr s a) -> f (Maybe s, Expr s b)
forall (t :: * -> *) (f :: * -> *) a b.
(Traversable t, Applicative f) =>
(a -> f b) -> t a -> f (t b)
traverse Expr s a -> f (Expr s b)
f) Maybe (Maybe s, Expr s a)
t
f (Maybe s -> Expr s b -> Binding s b)
-> f (Maybe s) -> f (Expr s b -> Binding s b)
forall (f :: * -> *) a b. Applicative f => f (a -> b) -> f a -> f b
<*> Maybe s -> f (Maybe s)
forall (f :: * -> *) a. Applicative f => a -> f a
pure Maybe s
s2
f (Expr s b -> Binding s b) -> f (Expr s b) -> f (Binding s b)
forall (f :: * -> *) a b. Applicative f => f (a -> b) -> f a -> f b
<*> Expr s a -> f (Expr s b)
f Expr s a
v
chunkExprs
:: Applicative f
=> (Expr s a -> f (Expr t b))
-> Chunks s a -> f (Chunks t b)
chunkExprs :: (Expr s a -> f (Expr t b)) -> Chunks s a -> f (Chunks t b)
chunkExprs f :: Expr s a -> f (Expr t b)
f (Chunks chunks :: [(Text, Expr s a)]
chunks final :: Text
final) =
([(Text, Expr t b)] -> Text -> Chunks t b)
-> Text -> [(Text, Expr t b)] -> Chunks t b
forall a b c. (a -> b -> c) -> b -> a -> c
flip [(Text, Expr t b)] -> Text -> Chunks t b
forall s a. [(Text, Expr s a)] -> Text -> Chunks s a
Chunks Text
final ([(Text, Expr t b)] -> Chunks t b)
-> f [(Text, Expr t b)] -> f (Chunks t b)
forall (f :: * -> *) a b. Functor f => (a -> b) -> f a -> f b
<$> ((Text, Expr s a) -> f (Text, Expr t b))
-> [(Text, Expr s a)] -> f [(Text, Expr t b)]
forall (t :: * -> *) (f :: * -> *) a b.
(Traversable t, Applicative f) =>
(a -> f b) -> t a -> f (t b)
traverse ((Expr s a -> f (Expr t b))
-> (Text, Expr s a) -> f (Text, Expr t b)
forall (t :: * -> *) (f :: * -> *) a b.
(Traversable t, Applicative f) =>
(a -> f b) -> t a -> f (t b)
traverse Expr s a -> f (Expr t b)
f) [(Text, Expr s a)]
chunks
newtype Directory = Directory { Directory -> [Text]
components :: [Text] }
deriving (Directory -> Directory -> Bool
(Directory -> Directory -> Bool)
-> (Directory -> Directory -> Bool) -> Eq Directory
forall a. (a -> a -> Bool) -> (a -> a -> Bool) -> Eq a
/= :: Directory -> Directory -> Bool
$c/= :: Directory -> Directory -> Bool
== :: Directory -> Directory -> Bool
$c== :: Directory -> Directory -> Bool
Eq, (forall x. Directory -> Rep Directory x)
-> (forall x. Rep Directory x -> Directory) -> Generic Directory
forall x. Rep Directory x -> Directory
forall x. Directory -> Rep Directory x
forall a.
(forall x. a -> Rep a x) -> (forall x. Rep a x -> a) -> Generic a
$cto :: forall x. Rep Directory x -> Directory
$cfrom :: forall x. Directory -> Rep Directory x
Generic, Eq Directory
Eq Directory =>
(Directory -> Directory -> Ordering)
-> (Directory -> Directory -> Bool)
-> (Directory -> Directory -> Bool)
-> (Directory -> Directory -> Bool)
-> (Directory -> Directory -> Bool)
-> (Directory -> Directory -> Directory)
-> (Directory -> Directory -> Directory)
-> Ord Directory
Directory -> Directory -> Bool
Directory -> Directory -> Ordering
Directory -> Directory -> Directory
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 :: Directory -> Directory -> Directory
$cmin :: Directory -> Directory -> Directory
max :: Directory -> Directory -> Directory
$cmax :: Directory -> Directory -> Directory
>= :: Directory -> Directory -> Bool
$c>= :: Directory -> Directory -> Bool
> :: Directory -> Directory -> Bool
$c> :: Directory -> Directory -> Bool
<= :: Directory -> Directory -> Bool
$c<= :: Directory -> Directory -> Bool
< :: Directory -> Directory -> Bool
$c< :: Directory -> Directory -> Bool
compare :: Directory -> Directory -> Ordering
$ccompare :: Directory -> Directory -> Ordering
$cp1Ord :: Eq Directory
Ord, Int -> Directory -> ShowS
[Directory] -> ShowS
Directory -> String
(Int -> Directory -> ShowS)
-> (Directory -> String)
-> ([Directory] -> ShowS)
-> Show Directory
forall a.
(Int -> a -> ShowS) -> (a -> String) -> ([a] -> ShowS) -> Show a
showList :: [Directory] -> ShowS
$cshowList :: [Directory] -> ShowS
show :: Directory -> String
$cshow :: Directory -> String
showsPrec :: Int -> Directory -> ShowS
$cshowsPrec :: Int -> Directory -> ShowS
Show, Directory -> ()
(Directory -> ()) -> NFData Directory
forall a. (a -> ()) -> NFData a
rnf :: Directory -> ()
$crnf :: Directory -> ()
NFData)
instance Semigroup Directory where
Directory components₀ :: [Text]
components₀ <> :: Directory -> Directory -> Directory
<> Directory components₁ :: [Text]
components₁ =
[Text] -> Directory
Directory ([Text]
components₁ [Text] -> [Text] -> [Text]
forall a. Semigroup a => a -> a -> a
<> [Text]
components₀)
instance Pretty Directory where
pretty :: Directory -> Doc ann
pretty (Directory {..}) = (Text -> Doc ann) -> [Text] -> Doc ann
forall (t :: * -> *) m a.
(Foldable t, Monoid m) =>
(a -> m) -> t a -> m
foldMap Text -> Doc ann
forall ann. Text -> Doc ann
prettyPathComponent ([Text] -> [Text]
forall a. [a] -> [a]
reverse [Text]
components)
prettyPathComponent :: Text -> Doc ann
prettyPathComponent :: Text -> Doc ann
prettyPathComponent text :: Text
text
| (Char -> Bool) -> Text -> Bool
Data.Text.all Char -> Bool
pathCharacter Text
text =
"/" Doc ann -> Doc ann -> Doc ann
forall a. Semigroup a => a -> a -> a
<> Text -> Doc ann
forall a ann. Pretty a => a -> Doc ann
Pretty.pretty Text
text
| Bool
otherwise =
"/\"" Doc ann -> Doc ann -> Doc ann
forall a. Semigroup a => a -> a -> a
<> Text -> Doc ann
forall a ann. Pretty a => a -> Doc ann
Pretty.pretty Text
text Doc ann -> Doc ann -> Doc ann
forall a. Semigroup a => a -> a -> a
<> "\""
data File = File
{ File -> Directory
directory :: Directory
, File -> Text
file :: Text
} deriving (File -> File -> Bool
(File -> File -> Bool) -> (File -> File -> Bool) -> Eq File
forall a. (a -> a -> Bool) -> (a -> a -> Bool) -> Eq a
/= :: File -> File -> Bool
$c/= :: File -> File -> Bool
== :: File -> File -> Bool
$c== :: File -> File -> Bool
Eq, (forall x. File -> Rep File x)
-> (forall x. Rep File x -> File) -> Generic File
forall x. Rep File x -> File
forall x. File -> Rep File x
forall a.
(forall x. a -> Rep a x) -> (forall x. Rep a x -> a) -> Generic a
$cto :: forall x. Rep File x -> File
$cfrom :: forall x. File -> Rep File x
Generic, Eq File
Eq File =>
(File -> File -> Ordering)
-> (File -> File -> Bool)
-> (File -> File -> Bool)
-> (File -> File -> Bool)
-> (File -> File -> Bool)
-> (File -> File -> File)
-> (File -> File -> File)
-> Ord File
File -> File -> Bool
File -> File -> Ordering
File -> File -> File
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 :: File -> File -> File
$cmin :: File -> File -> File
max :: File -> File -> File
$cmax :: File -> File -> File
>= :: File -> File -> Bool
$c>= :: File -> File -> Bool
> :: File -> File -> Bool
$c> :: File -> File -> Bool
<= :: File -> File -> Bool
$c<= :: File -> File -> Bool
< :: File -> File -> Bool
$c< :: File -> File -> Bool
compare :: File -> File -> Ordering
$ccompare :: File -> File -> Ordering
$cp1Ord :: Eq File
Ord, Int -> File -> ShowS
[File] -> ShowS
File -> String
(Int -> File -> ShowS)
-> (File -> String) -> ([File] -> ShowS) -> Show File
forall a.
(Int -> a -> ShowS) -> (a -> String) -> ([a] -> ShowS) -> Show a
showList :: [File] -> ShowS
$cshowList :: [File] -> ShowS
show :: File -> String
$cshow :: File -> String
showsPrec :: Int -> File -> ShowS
$cshowsPrec :: Int -> File -> ShowS
Show, File -> ()
(File -> ()) -> NFData File
forall a. (a -> ()) -> NFData a
rnf :: File -> ()
$crnf :: File -> ()
NFData)
instance Pretty File where
pretty :: File -> Doc ann
pretty (File {..}) =
Directory -> Doc ann
forall a ann. Pretty a => a -> Doc ann
Pretty.pretty Directory
directory
Doc ann -> Doc ann -> Doc ann
forall a. Semigroup a => a -> a -> a
<> Text -> Doc ann
forall ann. Text -> Doc ann
prettyPathComponent Text
file
instance Semigroup File where
File directory₀ :: Directory
directory₀ _ <> :: File -> File -> File
<> File directory₁ :: Directory
directory₁ file :: Text
file =
Directory -> Text -> File
File (Directory
directory₀ Directory -> Directory -> Directory
forall a. Semigroup a => a -> a -> a
<> Directory
directory₁) Text
file
data FilePrefix
= Absolute
| Here
| Parent
| Home
deriving (FilePrefix -> FilePrefix -> Bool
(FilePrefix -> FilePrefix -> Bool)
-> (FilePrefix -> FilePrefix -> Bool) -> Eq FilePrefix
forall a. (a -> a -> Bool) -> (a -> a -> Bool) -> Eq a
/= :: FilePrefix -> FilePrefix -> Bool
$c/= :: FilePrefix -> FilePrefix -> Bool
== :: FilePrefix -> FilePrefix -> Bool
$c== :: FilePrefix -> FilePrefix -> Bool
Eq, (forall x. FilePrefix -> Rep FilePrefix x)
-> (forall x. Rep FilePrefix x -> FilePrefix) -> Generic FilePrefix
forall x. Rep FilePrefix x -> FilePrefix
forall x. FilePrefix -> Rep FilePrefix x
forall a.
(forall x. a -> Rep a x) -> (forall x. Rep a x -> a) -> Generic a
$cto :: forall x. Rep FilePrefix x -> FilePrefix
$cfrom :: forall x. FilePrefix -> Rep FilePrefix x
Generic, Eq FilePrefix
Eq FilePrefix =>
(FilePrefix -> FilePrefix -> Ordering)
-> (FilePrefix -> FilePrefix -> Bool)
-> (FilePrefix -> FilePrefix -> Bool)
-> (FilePrefix -> FilePrefix -> Bool)
-> (FilePrefix -> FilePrefix -> Bool)
-> (FilePrefix -> FilePrefix -> FilePrefix)
-> (FilePrefix -> FilePrefix -> FilePrefix)
-> Ord FilePrefix
FilePrefix -> FilePrefix -> Bool
FilePrefix -> FilePrefix -> Ordering
FilePrefix -> FilePrefix -> FilePrefix
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 :: FilePrefix -> FilePrefix -> FilePrefix
$cmin :: FilePrefix -> FilePrefix -> FilePrefix
max :: FilePrefix -> FilePrefix -> FilePrefix
$cmax :: FilePrefix -> FilePrefix -> FilePrefix
>= :: FilePrefix -> FilePrefix -> Bool
$c>= :: FilePrefix -> FilePrefix -> Bool
> :: FilePrefix -> FilePrefix -> Bool
$c> :: FilePrefix -> FilePrefix -> Bool
<= :: FilePrefix -> FilePrefix -> Bool
$c<= :: FilePrefix -> FilePrefix -> Bool
< :: FilePrefix -> FilePrefix -> Bool
$c< :: FilePrefix -> FilePrefix -> Bool
compare :: FilePrefix -> FilePrefix -> Ordering
$ccompare :: FilePrefix -> FilePrefix -> Ordering
$cp1Ord :: Eq FilePrefix
Ord, Int -> FilePrefix -> ShowS
[FilePrefix] -> ShowS
FilePrefix -> String
(Int -> FilePrefix -> ShowS)
-> (FilePrefix -> String)
-> ([FilePrefix] -> ShowS)
-> Show FilePrefix
forall a.
(Int -> a -> ShowS) -> (a -> String) -> ([a] -> ShowS) -> Show a
showList :: [FilePrefix] -> ShowS
$cshowList :: [FilePrefix] -> ShowS
show :: FilePrefix -> String
$cshow :: FilePrefix -> String
showsPrec :: Int -> FilePrefix -> ShowS
$cshowsPrec :: Int -> FilePrefix -> ShowS
Show, FilePrefix -> ()
(FilePrefix -> ()) -> NFData FilePrefix
forall a. (a -> ()) -> NFData a
rnf :: FilePrefix -> ()
$crnf :: FilePrefix -> ()
NFData)
instance Pretty FilePrefix where
pretty :: FilePrefix -> Doc ann
pretty Absolute = ""
pretty Here = "."
pretty Parent = ".."
pretty Home = "~"
data Scheme = HTTP | HTTPS deriving (Scheme -> Scheme -> Bool
(Scheme -> Scheme -> Bool)
-> (Scheme -> Scheme -> Bool) -> Eq Scheme
forall a. (a -> a -> Bool) -> (a -> a -> Bool) -> Eq a
/= :: Scheme -> Scheme -> Bool
$c/= :: Scheme -> Scheme -> Bool
== :: Scheme -> Scheme -> Bool
$c== :: Scheme -> Scheme -> Bool
Eq, (forall x. Scheme -> Rep Scheme x)
-> (forall x. Rep Scheme x -> Scheme) -> Generic Scheme
forall x. Rep Scheme x -> Scheme
forall x. Scheme -> Rep Scheme x
forall a.
(forall x. a -> Rep a x) -> (forall x. Rep a x -> a) -> Generic a
$cto :: forall x. Rep Scheme x -> Scheme
$cfrom :: forall x. Scheme -> Rep Scheme x
Generic, Eq Scheme
Eq Scheme =>
(Scheme -> Scheme -> Ordering)
-> (Scheme -> Scheme -> Bool)
-> (Scheme -> Scheme -> Bool)
-> (Scheme -> Scheme -> Bool)
-> (Scheme -> Scheme -> Bool)
-> (Scheme -> Scheme -> Scheme)
-> (Scheme -> Scheme -> Scheme)
-> Ord Scheme
Scheme -> Scheme -> Bool
Scheme -> Scheme -> Ordering
Scheme -> Scheme -> Scheme
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 :: Scheme -> Scheme -> Scheme
$cmin :: Scheme -> Scheme -> Scheme
max :: Scheme -> Scheme -> Scheme
$cmax :: Scheme -> Scheme -> Scheme
>= :: Scheme -> Scheme -> Bool
$c>= :: Scheme -> Scheme -> Bool
> :: Scheme -> Scheme -> Bool
$c> :: Scheme -> Scheme -> Bool
<= :: Scheme -> Scheme -> Bool
$c<= :: Scheme -> Scheme -> Bool
< :: Scheme -> Scheme -> Bool
$c< :: Scheme -> Scheme -> Bool
compare :: Scheme -> Scheme -> Ordering
$ccompare :: Scheme -> Scheme -> Ordering
$cp1Ord :: Eq Scheme
Ord, Int -> Scheme -> ShowS
[Scheme] -> ShowS
Scheme -> String
(Int -> Scheme -> ShowS)
-> (Scheme -> String) -> ([Scheme] -> ShowS) -> Show Scheme
forall a.
(Int -> a -> ShowS) -> (a -> String) -> ([a] -> ShowS) -> Show a
showList :: [Scheme] -> ShowS
$cshowList :: [Scheme] -> ShowS
show :: Scheme -> String
$cshow :: Scheme -> String
showsPrec :: Int -> Scheme -> ShowS
$cshowsPrec :: Int -> Scheme -> ShowS
Show, Scheme -> ()
(Scheme -> ()) -> NFData Scheme
forall a. (a -> ()) -> NFData a
rnf :: Scheme -> ()
$crnf :: Scheme -> ()
NFData)
data URL = URL
{ URL -> Scheme
scheme :: Scheme
, URL -> Text
authority :: Text
, URL -> File
path :: File
, URL -> Maybe Text
query :: Maybe Text
, :: Maybe (Expr Src Import)
} deriving (URL -> URL -> Bool
(URL -> URL -> Bool) -> (URL -> URL -> Bool) -> Eq URL
forall a. (a -> a -> Bool) -> (a -> a -> Bool) -> Eq a
/= :: URL -> URL -> Bool
$c/= :: URL -> URL -> Bool
== :: URL -> URL -> Bool
$c== :: URL -> URL -> Bool
Eq, (forall x. URL -> Rep URL x)
-> (forall x. Rep URL x -> URL) -> Generic URL
forall x. Rep URL x -> URL
forall x. URL -> Rep URL x
forall a.
(forall x. a -> Rep a x) -> (forall x. Rep a x -> a) -> Generic a
$cto :: forall x. Rep URL x -> URL
$cfrom :: forall x. URL -> Rep URL x
Generic, Eq URL
Eq URL =>
(URL -> URL -> Ordering)
-> (URL -> URL -> Bool)
-> (URL -> URL -> Bool)
-> (URL -> URL -> Bool)
-> (URL -> URL -> Bool)
-> (URL -> URL -> URL)
-> (URL -> URL -> URL)
-> Ord URL
URL -> URL -> Bool
URL -> URL -> Ordering
URL -> URL -> URL
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 :: URL -> URL -> URL
$cmin :: URL -> URL -> URL
max :: URL -> URL -> URL
$cmax :: URL -> URL -> URL
>= :: URL -> URL -> Bool
$c>= :: URL -> URL -> Bool
> :: URL -> URL -> Bool
$c> :: URL -> URL -> Bool
<= :: URL -> URL -> Bool
$c<= :: URL -> URL -> Bool
< :: URL -> URL -> Bool
$c< :: URL -> URL -> Bool
compare :: URL -> URL -> Ordering
$ccompare :: URL -> URL -> Ordering
$cp1Ord :: Eq URL
Ord, Int -> URL -> ShowS
[URL] -> ShowS
URL -> String
(Int -> URL -> ShowS)
-> (URL -> String) -> ([URL] -> ShowS) -> Show URL
forall a.
(Int -> a -> ShowS) -> (a -> String) -> ([a] -> ShowS) -> Show a
showList :: [URL] -> ShowS
$cshowList :: [URL] -> ShowS
show :: URL -> String
$cshow :: URL -> String
showsPrec :: Int -> URL -> ShowS
$cshowsPrec :: Int -> URL -> ShowS
Show, URL -> ()
(URL -> ()) -> NFData URL
forall a. (a -> ()) -> NFData a
rnf :: URL -> ()
$crnf :: URL -> ()
NFData)
instance Pretty URL where
pretty :: URL -> Doc ann
pretty (URL {..}) =
Doc ann
schemeDoc
Doc ann -> Doc ann -> Doc ann
forall a. Semigroup a => a -> a -> a
<> "://"
Doc ann -> Doc ann -> Doc ann
forall a. Semigroup a => a -> a -> a
<> Text -> Doc ann
forall a ann. Pretty a => a -> Doc ann
Pretty.pretty Text
authority
Doc ann -> Doc ann -> Doc ann
forall a. Semigroup a => a -> a -> a
<> Doc ann
forall ann. Doc ann
pathDoc
Doc ann -> Doc ann -> Doc ann
forall a. Semigroup a => a -> a -> a
<> Doc ann
forall ann. Doc ann
queryDoc
Doc ann -> Doc ann -> Doc ann
forall a. Semigroup a => a -> a -> a
<> (Expr Src Import -> Doc ann) -> Maybe (Expr Src Import) -> Doc ann
forall (t :: * -> *) m a.
(Foldable t, Monoid m) =>
(a -> m) -> t a -> m
foldMap Expr Src Import -> Doc ann
forall a ann. Pretty a => a -> Doc ann
prettyHeaders Maybe (Expr Src Import)
headers
where
prettyHeaders :: a -> Doc ann
prettyHeaders h :: a
h = " using " Doc ann -> Doc ann -> Doc ann
forall a. Semigroup a => a -> a -> a
<> a -> Doc ann
forall a ann. Pretty a => a -> Doc ann
Pretty.pretty a
h
File {..} = File
path
Directory {..} = Directory
directory
pathDoc :: Doc ann
pathDoc =
(Text -> Doc ann) -> [Text] -> Doc ann
forall (t :: * -> *) m a.
(Foldable t, Monoid m) =>
(a -> m) -> t a -> m
foldMap Text -> Doc ann
forall ann. Text -> Doc ann
prettyURIComponent ([Text] -> [Text]
forall a. [a] -> [a]
reverse [Text]
components)
Doc ann -> Doc ann -> Doc ann
forall a. Semigroup a => a -> a -> a
<> Text -> Doc ann
forall ann. Text -> Doc ann
prettyURIComponent Text
file
schemeDoc :: Doc ann
schemeDoc = case Scheme
scheme of
HTTP -> "http"
HTTPS -> "https"
queryDoc :: Doc ann
queryDoc = case Maybe Text
query of
Nothing -> ""
Just q :: Text
q -> "?" Doc ann -> Doc ann -> Doc ann
forall a. Semigroup a => a -> a -> a
<> Text -> Doc ann
forall a ann. Pretty a => a -> Doc ann
Pretty.pretty Text
q
prettyURIComponent :: Text -> Doc ann
prettyURIComponent :: Text -> Doc ann
prettyURIComponent text :: Text
text =
String -> Doc ann
forall a ann. Pretty a => a -> Doc ann
Pretty.pretty (String -> Doc ann) -> String -> Doc ann
forall a b. (a -> b) -> a -> b
$ ShowS
URI.normalizeCase ShowS -> ShowS
forall a b. (a -> b) -> a -> b
$ ShowS
URI.normalizeEscape ShowS -> ShowS
forall a b. (a -> b) -> a -> b
$ "/" String -> ShowS
forall a. Semigroup a => a -> a -> a
<> Text -> String
Data.Text.unpack Text
text
data ImportType
= Local FilePrefix File
| Remote URL
| Env Text
| Missing
deriving (ImportType -> ImportType -> Bool
(ImportType -> ImportType -> Bool)
-> (ImportType -> ImportType -> Bool) -> Eq ImportType
forall a. (a -> a -> Bool) -> (a -> a -> Bool) -> Eq a
/= :: ImportType -> ImportType -> Bool
$c/= :: ImportType -> ImportType -> Bool
== :: ImportType -> ImportType -> Bool
$c== :: ImportType -> ImportType -> Bool
Eq, (forall x. ImportType -> Rep ImportType x)
-> (forall x. Rep ImportType x -> ImportType) -> Generic ImportType
forall x. Rep ImportType x -> ImportType
forall x. ImportType -> Rep ImportType x
forall a.
(forall x. a -> Rep a x) -> (forall x. Rep a x -> a) -> Generic a
$cto :: forall x. Rep ImportType x -> ImportType
$cfrom :: forall x. ImportType -> Rep ImportType x
Generic, Eq ImportType
Eq ImportType =>
(ImportType -> ImportType -> Ordering)
-> (ImportType -> ImportType -> Bool)
-> (ImportType -> ImportType -> Bool)
-> (ImportType -> ImportType -> Bool)
-> (ImportType -> ImportType -> Bool)
-> (ImportType -> ImportType -> ImportType)
-> (ImportType -> ImportType -> ImportType)
-> Ord ImportType
ImportType -> ImportType -> Bool
ImportType -> ImportType -> Ordering
ImportType -> ImportType -> ImportType
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 :: ImportType -> ImportType -> ImportType
$cmin :: ImportType -> ImportType -> ImportType
max :: ImportType -> ImportType -> ImportType
$cmax :: ImportType -> ImportType -> ImportType
>= :: ImportType -> ImportType -> Bool
$c>= :: ImportType -> ImportType -> Bool
> :: ImportType -> ImportType -> Bool
$c> :: ImportType -> ImportType -> Bool
<= :: ImportType -> ImportType -> Bool
$c<= :: ImportType -> ImportType -> Bool
< :: ImportType -> ImportType -> Bool
$c< :: ImportType -> ImportType -> Bool
compare :: ImportType -> ImportType -> Ordering
$ccompare :: ImportType -> ImportType -> Ordering
$cp1Ord :: Eq ImportType
Ord, Int -> ImportType -> ShowS
[ImportType] -> ShowS
ImportType -> String
(Int -> ImportType -> ShowS)
-> (ImportType -> String)
-> ([ImportType] -> ShowS)
-> Show ImportType
forall a.
(Int -> a -> ShowS) -> (a -> String) -> ([a] -> ShowS) -> Show a
showList :: [ImportType] -> ShowS
$cshowList :: [ImportType] -> ShowS
show :: ImportType -> String
$cshow :: ImportType -> String
showsPrec :: Int -> ImportType -> ShowS
$cshowsPrec :: Int -> ImportType -> ShowS
Show, ImportType -> ()
(ImportType -> ()) -> NFData ImportType
forall a. (a -> ()) -> NFData a
rnf :: ImportType -> ()
$crnf :: ImportType -> ()
NFData)
parent :: File
parent :: File
parent = File :: Directory -> Text -> File
File { directory :: Directory
directory = Directory :: [Text] -> Directory
Directory { components :: [Text]
components = [ ".." ] }, file :: Text
file = "" }
instance Semigroup ImportType where
Local prefix :: FilePrefix
prefix file₀ :: File
file₀ <> :: ImportType -> ImportType -> ImportType
<> Local Here file₁ :: File
file₁ = FilePrefix -> File -> ImportType
Local FilePrefix
prefix (File
file₀ File -> File -> File
forall a. Semigroup a => a -> a -> a
<> File
file₁)
Remote (URL { path :: URL -> File
path = File
path₀, ..}) <> Local Here path₁ :: File
path₁ =
URL -> ImportType
Remote (URL :: Scheme
-> Text -> File -> Maybe Text -> Maybe (Expr Src Import) -> URL
URL { path :: File
path = File
path₀ File -> File -> File
forall a. Semigroup a => a -> a -> a
<> File
path₁, ..})
Local prefix :: FilePrefix
prefix file₀ :: File
file₀ <> Local Parent file₁ :: File
file₁ =
FilePrefix -> File -> ImportType
Local FilePrefix
prefix (File
file₀ File -> File -> File
forall a. Semigroup a => a -> a -> a
<> File
parent File -> File -> File
forall a. Semigroup a => a -> a -> a
<> File
file₁)
Remote (URL { path :: URL -> File
path = File
path₀, .. }) <> Local Parent path₁ :: File
path₁ =
URL -> ImportType
Remote (URL :: Scheme
-> Text -> File -> Maybe Text -> Maybe (Expr Src Import) -> URL
URL { path :: File
path = File
path₀ File -> File -> File
forall a. Semigroup a => a -> a -> a
<> File
parent File -> File -> File
forall a. Semigroup a => a -> a -> a
<> File
path₁, .. })
import₀ :: ImportType
import₀ <> Remote (URL { headers :: URL -> Maybe (Expr Src Import)
headers = Maybe (Expr Src Import)
headers₀, .. }) =
URL -> ImportType
Remote (URL :: Scheme
-> Text -> File -> Maybe Text -> Maybe (Expr Src Import) -> URL
URL { headers :: Maybe (Expr Src Import)
headers = Maybe (Expr Src Import)
headers₁, .. })
where
importHashed₀ :: Import
importHashed₀ = ImportHashed -> ImportMode -> Import
Import (Maybe SHA256Digest -> ImportType -> ImportHashed
ImportHashed Maybe SHA256Digest
forall a. Maybe a
Nothing ImportType
import₀) ImportMode
Code
headers₁ :: Maybe (Expr Src Import)
headers₁ = (Expr Src Import -> Expr Src Import)
-> Maybe (Expr Src Import) -> Maybe (Expr Src Import)
forall (f :: * -> *) a b. Functor f => (a -> b) -> f a -> f b
fmap ((Import -> Import) -> Expr Src Import -> Expr Src Import
forall (f :: * -> *) a b. Functor f => (a -> b) -> f a -> f b
fmap (Import
importHashed₀ Import -> Import -> Import
forall a. Semigroup a => a -> a -> a
<>)) Maybe (Expr Src Import)
headers₀
_ <> import₁ :: ImportType
import₁ =
ImportType
import₁
instance Pretty ImportType where
pretty :: ImportType -> Doc ann
pretty (Local prefix :: FilePrefix
prefix file :: File
file) =
FilePrefix -> Doc ann
forall a ann. Pretty a => a -> Doc ann
Pretty.pretty FilePrefix
prefix Doc ann -> Doc ann -> Doc ann
forall a. Semigroup a => a -> a -> a
<> File -> Doc ann
forall a ann. Pretty a => a -> Doc ann
Pretty.pretty File
file
pretty (Remote url :: URL
url) = URL -> Doc ann
forall a ann. Pretty a => a -> Doc ann
Pretty.pretty URL
url
pretty (Env env :: Text
env) = "env:" Doc ann -> Doc ann -> Doc ann
forall a. Semigroup a => a -> a -> a
<> Text -> Doc ann
forall ann. Text -> Doc ann
prettyEnvironmentVariable Text
env
pretty Missing = "missing"
data ImportMode = Code | RawText | Location
deriving (ImportMode -> ImportMode -> Bool
(ImportMode -> ImportMode -> Bool)
-> (ImportMode -> ImportMode -> Bool) -> Eq ImportMode
forall a. (a -> a -> Bool) -> (a -> a -> Bool) -> Eq a
/= :: ImportMode -> ImportMode -> Bool
$c/= :: ImportMode -> ImportMode -> Bool
== :: ImportMode -> ImportMode -> Bool
$c== :: ImportMode -> ImportMode -> Bool
Eq, (forall x. ImportMode -> Rep ImportMode x)
-> (forall x. Rep ImportMode x -> ImportMode) -> Generic ImportMode
forall x. Rep ImportMode x -> ImportMode
forall x. ImportMode -> Rep ImportMode x
forall a.
(forall x. a -> Rep a x) -> (forall x. Rep a x -> a) -> Generic a
$cto :: forall x. Rep ImportMode x -> ImportMode
$cfrom :: forall x. ImportMode -> Rep ImportMode x
Generic, Eq ImportMode
Eq ImportMode =>
(ImportMode -> ImportMode -> Ordering)
-> (ImportMode -> ImportMode -> Bool)
-> (ImportMode -> ImportMode -> Bool)
-> (ImportMode -> ImportMode -> Bool)
-> (ImportMode -> ImportMode -> Bool)
-> (ImportMode -> ImportMode -> ImportMode)
-> (ImportMode -> ImportMode -> ImportMode)
-> Ord ImportMode
ImportMode -> ImportMode -> Bool
ImportMode -> ImportMode -> Ordering
ImportMode -> ImportMode -> ImportMode
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 :: ImportMode -> ImportMode -> ImportMode
$cmin :: ImportMode -> ImportMode -> ImportMode
max :: ImportMode -> ImportMode -> ImportMode
$cmax :: ImportMode -> ImportMode -> ImportMode
>= :: ImportMode -> ImportMode -> Bool
$c>= :: ImportMode -> ImportMode -> Bool
> :: ImportMode -> ImportMode -> Bool
$c> :: ImportMode -> ImportMode -> Bool
<= :: ImportMode -> ImportMode -> Bool
$c<= :: ImportMode -> ImportMode -> Bool
< :: ImportMode -> ImportMode -> Bool
$c< :: ImportMode -> ImportMode -> Bool
compare :: ImportMode -> ImportMode -> Ordering
$ccompare :: ImportMode -> ImportMode -> Ordering
$cp1Ord :: Eq ImportMode
Ord, Int -> ImportMode -> ShowS
[ImportMode] -> ShowS
ImportMode -> String
(Int -> ImportMode -> ShowS)
-> (ImportMode -> String)
-> ([ImportMode] -> ShowS)
-> Show ImportMode
forall a.
(Int -> a -> ShowS) -> (a -> String) -> ([a] -> ShowS) -> Show a
showList :: [ImportMode] -> ShowS
$cshowList :: [ImportMode] -> ShowS
show :: ImportMode -> String
$cshow :: ImportMode -> String
showsPrec :: Int -> ImportMode -> ShowS
$cshowsPrec :: Int -> ImportMode -> ShowS
Show, ImportMode -> ()
(ImportMode -> ()) -> NFData ImportMode
forall a. (a -> ()) -> NFData a
rnf :: ImportMode -> ()
$crnf :: ImportMode -> ()
NFData)
data ImportHashed = ImportHashed
{ ImportHashed -> Maybe SHA256Digest
hash :: Maybe Dhall.Crypto.SHA256Digest
, ImportHashed -> ImportType
importType :: ImportType
} deriving (ImportHashed -> ImportHashed -> Bool
(ImportHashed -> ImportHashed -> Bool)
-> (ImportHashed -> ImportHashed -> Bool) -> Eq ImportHashed
forall a. (a -> a -> Bool) -> (a -> a -> Bool) -> Eq a
/= :: ImportHashed -> ImportHashed -> Bool
$c/= :: ImportHashed -> ImportHashed -> Bool
== :: ImportHashed -> ImportHashed -> Bool
$c== :: ImportHashed -> ImportHashed -> Bool
Eq, (forall x. ImportHashed -> Rep ImportHashed x)
-> (forall x. Rep ImportHashed x -> ImportHashed)
-> Generic ImportHashed
forall x. Rep ImportHashed x -> ImportHashed
forall x. ImportHashed -> Rep ImportHashed x
forall a.
(forall x. a -> Rep a x) -> (forall x. Rep a x -> a) -> Generic a
$cto :: forall x. Rep ImportHashed x -> ImportHashed
$cfrom :: forall x. ImportHashed -> Rep ImportHashed x
Generic, Eq ImportHashed
Eq ImportHashed =>
(ImportHashed -> ImportHashed -> Ordering)
-> (ImportHashed -> ImportHashed -> Bool)
-> (ImportHashed -> ImportHashed -> Bool)
-> (ImportHashed -> ImportHashed -> Bool)
-> (ImportHashed -> ImportHashed -> Bool)
-> (ImportHashed -> ImportHashed -> ImportHashed)
-> (ImportHashed -> ImportHashed -> ImportHashed)
-> Ord ImportHashed
ImportHashed -> ImportHashed -> Bool
ImportHashed -> ImportHashed -> Ordering
ImportHashed -> ImportHashed -> ImportHashed
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 :: ImportHashed -> ImportHashed -> ImportHashed
$cmin :: ImportHashed -> ImportHashed -> ImportHashed
max :: ImportHashed -> ImportHashed -> ImportHashed
$cmax :: ImportHashed -> ImportHashed -> ImportHashed
>= :: ImportHashed -> ImportHashed -> Bool
$c>= :: ImportHashed -> ImportHashed -> Bool
> :: ImportHashed -> ImportHashed -> Bool
$c> :: ImportHashed -> ImportHashed -> Bool
<= :: ImportHashed -> ImportHashed -> Bool
$c<= :: ImportHashed -> ImportHashed -> Bool
< :: ImportHashed -> ImportHashed -> Bool
$c< :: ImportHashed -> ImportHashed -> Bool
compare :: ImportHashed -> ImportHashed -> Ordering
$ccompare :: ImportHashed -> ImportHashed -> Ordering
$cp1Ord :: Eq ImportHashed
Ord, Int -> ImportHashed -> ShowS
[ImportHashed] -> ShowS
ImportHashed -> String
(Int -> ImportHashed -> ShowS)
-> (ImportHashed -> String)
-> ([ImportHashed] -> ShowS)
-> Show ImportHashed
forall a.
(Int -> a -> ShowS) -> (a -> String) -> ([a] -> ShowS) -> Show a
showList :: [ImportHashed] -> ShowS
$cshowList :: [ImportHashed] -> ShowS
show :: ImportHashed -> String
$cshow :: ImportHashed -> String
showsPrec :: Int -> ImportHashed -> ShowS
$cshowsPrec :: Int -> ImportHashed -> ShowS
Show, ImportHashed -> ()
(ImportHashed -> ()) -> NFData ImportHashed
forall a. (a -> ()) -> NFData a
rnf :: ImportHashed -> ()
$crnf :: ImportHashed -> ()
NFData)
instance Semigroup ImportHashed where
ImportHashed _ importType₀ :: ImportType
importType₀ <> :: ImportHashed -> ImportHashed -> ImportHashed
<> ImportHashed hash :: Maybe SHA256Digest
hash importType₁ :: ImportType
importType₁ =
Maybe SHA256Digest -> ImportType -> ImportHashed
ImportHashed Maybe SHA256Digest
hash (ImportType
importType₀ ImportType -> ImportType -> ImportType
forall a. Semigroup a => a -> a -> a
<> ImportType
importType₁)
instance Pretty ImportHashed where
pretty :: ImportHashed -> Doc ann
pretty (ImportHashed Nothing p :: ImportType
p) =
ImportType -> Doc ann
forall a ann. Pretty a => a -> Doc ann
Pretty.pretty ImportType
p
pretty (ImportHashed (Just h :: SHA256Digest
h) p :: ImportType
p) =
ImportType -> Doc ann
forall a ann. Pretty a => a -> Doc ann
Pretty.pretty ImportType
p Doc ann -> Doc ann -> Doc ann
forall a. Semigroup a => a -> a -> a
<> " sha256:" Doc ann -> Doc ann -> Doc ann
forall a. Semigroup a => a -> a -> a
<> String -> Doc ann
forall a ann. Pretty a => a -> Doc ann
Pretty.pretty (SHA256Digest -> String
forall a. Show a => a -> String
show SHA256Digest
h)
data Import = Import
{ Import -> ImportHashed
importHashed :: ImportHashed
, Import -> ImportMode
importMode :: ImportMode
} deriving (Import -> Import -> Bool
(Import -> Import -> Bool)
-> (Import -> Import -> Bool) -> Eq Import
forall a. (a -> a -> Bool) -> (a -> a -> Bool) -> Eq a
/= :: Import -> Import -> Bool
$c/= :: Import -> Import -> Bool
== :: Import -> Import -> Bool
$c== :: Import -> Import -> Bool
Eq, (forall x. Import -> Rep Import x)
-> (forall x. Rep Import x -> Import) -> Generic Import
forall x. Rep Import x -> Import
forall x. Import -> Rep Import x
forall a.
(forall x. a -> Rep a x) -> (forall x. Rep a x -> a) -> Generic a
$cto :: forall x. Rep Import x -> Import
$cfrom :: forall x. Import -> Rep Import x
Generic, Eq Import
Eq Import =>
(Import -> Import -> Ordering)
-> (Import -> Import -> Bool)
-> (Import -> Import -> Bool)
-> (Import -> Import -> Bool)
-> (Import -> Import -> Bool)
-> (Import -> Import -> Import)
-> (Import -> Import -> Import)
-> Ord Import
Import -> Import -> Bool
Import -> Import -> Ordering
Import -> Import -> Import
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 :: Import -> Import -> Import
$cmin :: Import -> Import -> Import
max :: Import -> Import -> Import
$cmax :: Import -> Import -> Import
>= :: Import -> Import -> Bool
$c>= :: Import -> Import -> Bool
> :: Import -> Import -> Bool
$c> :: Import -> Import -> Bool
<= :: Import -> Import -> Bool
$c<= :: Import -> Import -> Bool
< :: Import -> Import -> Bool
$c< :: Import -> Import -> Bool
compare :: Import -> Import -> Ordering
$ccompare :: Import -> Import -> Ordering
$cp1Ord :: Eq Import
Ord, Int -> Import -> ShowS
[Import] -> ShowS
Import -> String
(Int -> Import -> ShowS)
-> (Import -> String) -> ([Import] -> ShowS) -> Show Import
forall a.
(Int -> a -> ShowS) -> (a -> String) -> ([a] -> ShowS) -> Show a
showList :: [Import] -> ShowS
$cshowList :: [Import] -> ShowS
show :: Import -> String
$cshow :: Import -> String
showsPrec :: Int -> Import -> ShowS
$cshowsPrec :: Int -> Import -> ShowS
Show, Import -> ()
(Import -> ()) -> NFData Import
forall a. (a -> ()) -> NFData a
rnf :: Import -> ()
$crnf :: Import -> ()
NFData)
instance Semigroup Import where
Import importHashed₀ :: ImportHashed
importHashed₀ _ <> :: Import -> Import -> Import
<> Import importHashed₁ :: ImportHashed
importHashed₁ code :: ImportMode
code =
ImportHashed -> ImportMode -> Import
Import (ImportHashed
importHashed₀ ImportHashed -> ImportHashed -> ImportHashed
forall a. Semigroup a => a -> a -> a
<> ImportHashed
importHashed₁) ImportMode
code
instance Pretty Import where
pretty :: Import -> Doc ann
pretty (Import {..}) = ImportHashed -> Doc ann
forall a ann. Pretty a => a -> Doc ann
Pretty.pretty ImportHashed
importHashed Doc ann -> Doc ann -> Doc ann
forall a. Semigroup a => a -> a -> a
<> Text -> Doc ann
forall a ann. Pretty a => a -> Doc ann
Pretty.pretty Text
suffix
where
suffix :: Text
suffix :: Text
suffix = case ImportMode
importMode of
RawText -> " as Text"
Location -> " as Location"
Code -> ""
pathCharacter :: Char -> Bool
pathCharacter :: Char -> Bool
pathCharacter c :: Char
c =
'\x21' Char -> Char -> Bool
forall a. Eq a => a -> a -> Bool
== Char
c
Bool -> Bool -> Bool
|| ('\x24' Char -> Char -> Bool
forall a. Ord a => a -> a -> Bool
<= Char
c Bool -> Bool -> Bool
&& Char
c Char -> Char -> Bool
forall a. Ord a => a -> a -> Bool
<= '\x27')
Bool -> Bool -> Bool
|| ('\x2A' Char -> Char -> Bool
forall a. Ord a => a -> a -> Bool
<= Char
c Bool -> Bool -> Bool
&& Char
c Char -> Char -> Bool
forall a. Ord a => a -> a -> Bool
<= '\x2B')
Bool -> Bool -> Bool
|| ('\x2D' Char -> Char -> Bool
forall a. Ord a => a -> a -> Bool
<= Char
c Bool -> Bool -> Bool
&& Char
c Char -> Char -> Bool
forall a. Ord a => a -> a -> Bool
<= '\x2E')
Bool -> Bool -> Bool
|| ('\x30' Char -> Char -> Bool
forall a. Ord a => a -> a -> Bool
<= Char
c Bool -> Bool -> Bool
&& Char
c Char -> Char -> Bool
forall a. Ord a => a -> a -> Bool
<= '\x3B')
Bool -> Bool -> Bool
|| Char
c Char -> Char -> Bool
forall a. Eq a => a -> a -> Bool
== '\x3D'
Bool -> Bool -> Bool
|| ('\x40' Char -> Char -> Bool
forall a. Ord a => a -> a -> Bool
<= Char
c Bool -> Bool -> Bool
&& Char
c Char -> Char -> Bool
forall a. Ord a => a -> a -> Bool
<= '\x5A')
Bool -> Bool -> Bool
|| ('\x5E' Char -> Char -> Bool
forall a. Ord a => a -> a -> Bool
<= Char
c Bool -> Bool -> Bool
&& Char
c Char -> Char -> Bool
forall a. Ord a => a -> a -> Bool
<= '\x7A')
Bool -> Bool -> Bool
|| Char
c Char -> Char -> Bool
forall a. Eq a => a -> a -> Bool
== '\x7C'
Bool -> Bool -> Bool
|| Char
c Char -> Char -> Bool
forall a. Eq a => a -> a -> Bool
== '\x7E'
denote :: Expr s a -> Expr t a
denote :: Expr s a -> Expr t a
denote (Note _ b :: Expr s a
b ) = Expr s a -> Expr t a
forall s a t. Expr s a -> Expr t a
denote Expr s a
b
denote (Const a :: Const
a ) = Const -> Expr t a
forall s a. Const -> Expr s a
Const Const
a
denote (Var a :: Var
a ) = Var -> Expr t a
forall s a. Var -> Expr s a
Var Var
a
denote (Lam a :: Text
a b :: Expr s a
b c :: Expr s a
c ) = Text -> Expr t a -> Expr t a -> Expr t a
forall s a. Text -> Expr s a -> Expr s a -> Expr s a
Lam Text
a (Expr s a -> Expr t a
forall s a t. Expr s a -> Expr t a
denote Expr s a
b) (Expr s a -> Expr t a
forall s a t. Expr s a -> Expr t a
denote Expr s a
c)
denote (Pi a :: Text
a b :: Expr s a
b c :: Expr s a
c ) = Text -> Expr t a -> Expr t a -> Expr t a
forall s a. Text -> Expr s a -> Expr s a -> Expr s a
Pi Text
a (Expr s a -> Expr t a
forall s a t. Expr s a -> Expr t a
denote Expr s a
b) (Expr s a -> Expr t a
forall s a t. Expr s a -> Expr t a
denote Expr s a
c)
denote (App a :: Expr s a
a b :: Expr s a
b ) = Expr t a -> Expr t a -> Expr t a
forall s a. Expr s a -> Expr s a -> Expr s a
App (Expr s a -> Expr t a
forall s a t. Expr s a -> Expr t a
denote Expr s a
a) (Expr s a -> Expr t a
forall s a t. Expr s a -> Expr t a
denote Expr s a
b)
denote (Let a :: Binding s a
a b :: Expr s a
b ) = Binding t a -> Expr t a -> Expr t a
forall s a. Binding s a -> Expr s a -> Expr s a
Let (Binding s a -> Binding t a
forall s a s. Binding s a -> Binding s a
adapt0 Binding s a
a) (Expr s a -> Expr t a
forall s a t. Expr s a -> Expr t a
denote Expr s a
b)
where
adapt0 :: Binding s a -> Binding s a
adapt0 (Binding _ c :: Text
c _ d :: Maybe (Maybe s, Expr s a)
d _ e :: Expr s a
e) =
Maybe s
-> Text
-> Maybe s
-> Maybe (Maybe s, Expr s a)
-> Maybe s
-> Expr s a
-> Binding s a
forall s a.
Maybe s
-> Text
-> Maybe s
-> Maybe (Maybe s, Expr s a)
-> Maybe s
-> Expr s a
-> Binding s a
Binding Maybe s
forall a. Maybe a
Nothing Text
c Maybe s
forall a. Maybe a
Nothing (((Maybe s, Expr s a) -> (Maybe s, Expr s a))
-> Maybe (Maybe s, Expr s a) -> Maybe (Maybe s, Expr s a)
forall (f :: * -> *) a b. Functor f => (a -> b) -> f a -> f b
fmap (Maybe s, Expr s a) -> (Maybe s, Expr s a)
forall a s a a t. (a, Expr s a) -> (Maybe a, Expr t a)
adapt1 Maybe (Maybe s, Expr s a)
d) Maybe s
forall a. Maybe a
Nothing (Expr s a -> Expr s a
forall s a t. Expr s a -> Expr t a
denote Expr s a
e)
adapt1 :: (a, Expr s a) -> (Maybe a, Expr t a)
adapt1 (_, f :: Expr s a
f) = (Maybe a
forall a. Maybe a
Nothing, Expr s a -> Expr t a
forall s a t. Expr s a -> Expr t a
denote Expr s a
f)
denote (Annot a :: Expr s a
a b :: Expr s a
b ) = Expr t a -> Expr t a -> Expr t a
forall s a. Expr s a -> Expr s a -> Expr s a
Annot (Expr s a -> Expr t a
forall s a t. Expr s a -> Expr t a
denote Expr s a
a) (Expr s a -> Expr t a
forall s a t. Expr s a -> Expr t a
denote Expr s a
b)
denote Bool = Expr t a
forall s a. Expr s a
Bool
denote (BoolLit a :: Bool
a ) = Bool -> Expr t a
forall s a. Bool -> Expr s a
BoolLit Bool
a
denote (BoolAnd a :: Expr s a
a b :: Expr s a
b ) = Expr t a -> Expr t a -> Expr t a
forall s a. Expr s a -> Expr s a -> Expr s a
BoolAnd (Expr s a -> Expr t a
forall s a t. Expr s a -> Expr t a
denote Expr s a
a) (Expr s a -> Expr t a
forall s a t. Expr s a -> Expr t a
denote Expr s a
b)
denote (BoolOr a :: Expr s a
a b :: Expr s a
b ) = Expr t a -> Expr t a -> Expr t a
forall s a. Expr s a -> Expr s a -> Expr s a
BoolOr (Expr s a -> Expr t a
forall s a t. Expr s a -> Expr t a
denote Expr s a
a) (Expr s a -> Expr t a
forall s a t. Expr s a -> Expr t a
denote Expr s a
b)
denote (BoolEQ a :: Expr s a
a b :: Expr s a
b ) = Expr t a -> Expr t a -> Expr t a
forall s a. Expr s a -> Expr s a -> Expr s a
BoolEQ (Expr s a -> Expr t a
forall s a t. Expr s a -> Expr t a
denote Expr s a
a) (Expr s a -> Expr t a
forall s a t. Expr s a -> Expr t a
denote Expr s a
b)
denote (BoolNE a :: Expr s a
a b :: Expr s a
b ) = Expr t a -> Expr t a -> Expr t a
forall s a. Expr s a -> Expr s a -> Expr s a
BoolNE (Expr s a -> Expr t a
forall s a t. Expr s a -> Expr t a
denote Expr s a
a) (Expr s a -> Expr t a
forall s a t. Expr s a -> Expr t a
denote Expr s a
b)
denote (BoolIf a :: Expr s a
a b :: Expr s a
b c :: Expr s a
c ) = Expr t a -> Expr t a -> Expr t a -> Expr t a
forall s a. Expr s a -> Expr s a -> Expr s a -> Expr s a
BoolIf (Expr s a -> Expr t a
forall s a t. Expr s a -> Expr t a
denote Expr s a
a) (Expr s a -> Expr t a
forall s a t. Expr s a -> Expr t a
denote Expr s a
b) (Expr s a -> Expr t a
forall s a t. Expr s a -> Expr t a
denote Expr s a
c)
denote Natural = Expr t a
forall s a. Expr s a
Natural
denote (NaturalLit a :: Natural
a ) = Natural -> Expr t a
forall s a. Natural -> Expr s a
NaturalLit Natural
a
denote NaturalFold = Expr t a
forall s a. Expr s a
NaturalFold
denote NaturalBuild = Expr t a
forall s a. Expr s a
NaturalBuild
denote NaturalIsZero = Expr t a
forall s a. Expr s a
NaturalIsZero
denote NaturalEven = Expr t a
forall s a. Expr s a
NaturalEven
denote NaturalOdd = Expr t a
forall s a. Expr s a
NaturalOdd
denote NaturalToInteger = Expr t a
forall s a. Expr s a
NaturalToInteger
denote NaturalShow = Expr t a
forall s a. Expr s a
NaturalShow
denote NaturalSubtract = Expr t a
forall s a. Expr s a
NaturalSubtract
denote (NaturalPlus a :: Expr s a
a b :: Expr s a
b ) = Expr t a -> Expr t a -> Expr t a
forall s a. Expr s a -> Expr s a -> Expr s a
NaturalPlus (Expr s a -> Expr t a
forall s a t. Expr s a -> Expr t a
denote Expr s a
a) (Expr s a -> Expr t a
forall s a t. Expr s a -> Expr t a
denote Expr s a
b)
denote (NaturalTimes a :: Expr s a
a b :: Expr s a
b ) = Expr t a -> Expr t a -> Expr t a
forall s a. Expr s a -> Expr s a -> Expr s a
NaturalTimes (Expr s a -> Expr t a
forall s a t. Expr s a -> Expr t a
denote Expr s a
a) (Expr s a -> Expr t a
forall s a t. Expr s a -> Expr t a
denote Expr s a
b)
denote Integer = Expr t a
forall s a. Expr s a
Integer
denote (IntegerLit a :: Integer
a ) = Integer -> Expr t a
forall s a. Integer -> Expr s a
IntegerLit Integer
a
denote IntegerClamp = Expr t a
forall s a. Expr s a
IntegerClamp
denote IntegerNegate = Expr t a
forall s a. Expr s a
IntegerNegate
denote IntegerShow = Expr t a
forall s a. Expr s a
IntegerShow
denote IntegerToDouble = Expr t a
forall s a. Expr s a
IntegerToDouble
denote Double = Expr t a
forall s a. Expr s a
Double
denote (DoubleLit a :: DhallDouble
a ) = DhallDouble -> Expr t a
forall s a. DhallDouble -> Expr s a
DoubleLit DhallDouble
a
denote DoubleShow = Expr t a
forall s a. Expr s a
DoubleShow
denote Text = Expr t a
forall s a. Expr s a
Text
denote (TextLit (Chunks a :: [(Text, Expr s a)]
a b :: Text
b)) = Chunks t a -> Expr t a
forall s a. Chunks s a -> Expr s a
TextLit ([(Text, Expr t a)] -> Text -> Chunks t a
forall s a. [(Text, Expr s a)] -> Text -> Chunks s a
Chunks (((Text, Expr s a) -> (Text, Expr t a))
-> [(Text, Expr s a)] -> [(Text, Expr t a)]
forall (f :: * -> *) a b. Functor f => (a -> b) -> f a -> f b
fmap ((Expr s a -> Expr t a) -> (Text, Expr s a) -> (Text, Expr t a)
forall (f :: * -> *) a b. Functor f => (a -> b) -> f a -> f b
fmap Expr s a -> Expr t a
forall s a t. Expr s a -> Expr t a
denote) [(Text, Expr s a)]
a) Text
b)
denote (TextAppend a :: Expr s a
a b :: Expr s a
b ) = Expr t a -> Expr t a -> Expr t a
forall s a. Expr s a -> Expr s a -> Expr s a
TextAppend (Expr s a -> Expr t a
forall s a t. Expr s a -> Expr t a
denote Expr s a
a) (Expr s a -> Expr t a
forall s a t. Expr s a -> Expr t a
denote Expr s a
b)
denote TextShow = Expr t a
forall s a. Expr s a
TextShow
denote List = Expr t a
forall s a. Expr s a
List
denote (ListLit a :: Maybe (Expr s a)
a b :: Seq (Expr s a)
b ) = Maybe (Expr t a) -> Seq (Expr t a) -> Expr t a
forall s a. Maybe (Expr s a) -> Seq (Expr s a) -> Expr s a
ListLit ((Expr s a -> Expr t a) -> Maybe (Expr s a) -> Maybe (Expr t a)
forall (f :: * -> *) a b. Functor f => (a -> b) -> f a -> f b
fmap Expr s a -> Expr t a
forall s a t. Expr s a -> Expr t a
denote Maybe (Expr s a)
a) ((Expr s a -> Expr t a) -> Seq (Expr s a) -> Seq (Expr t a)
forall (f :: * -> *) a b. Functor f => (a -> b) -> f a -> f b
fmap Expr s a -> Expr t a
forall s a t. Expr s a -> Expr t a
denote Seq (Expr s a)
b)
denote (ListAppend a :: Expr s a
a b :: Expr s a
b ) = Expr t a -> Expr t a -> Expr t a
forall s a. Expr s a -> Expr s a -> Expr s a
ListAppend (Expr s a -> Expr t a
forall s a t. Expr s a -> Expr t a
denote Expr s a
a) (Expr s a -> Expr t a
forall s a t. Expr s a -> Expr t a
denote Expr s a
b)
denote ListBuild = Expr t a
forall s a. Expr s a
ListBuild
denote ListFold = Expr t a
forall s a. Expr s a
ListFold
denote ListLength = Expr t a
forall s a. Expr s a
ListLength
denote ListHead = Expr t a
forall s a. Expr s a
ListHead
denote ListLast = Expr t a
forall s a. Expr s a
ListLast
denote ListIndexed = Expr t a
forall s a. Expr s a
ListIndexed
denote ListReverse = Expr t a
forall s a. Expr s a
ListReverse
denote Optional = Expr t a
forall s a. Expr s a
Optional
denote (Some a :: Expr s a
a ) = Expr t a -> Expr t a
forall s a. Expr s a -> Expr s a
Some (Expr s a -> Expr t a
forall s a t. Expr s a -> Expr t a
denote Expr s a
a)
denote None = Expr t a
forall s a. Expr s a
None
denote OptionalFold = Expr t a
forall s a. Expr s a
OptionalFold
denote OptionalBuild = Expr t a
forall s a. Expr s a
OptionalBuild
denote (Record a :: Map Text (Expr s a)
a ) = Map Text (Expr t a) -> Expr t a
forall s a. Map Text (Expr s a) -> Expr s a
Record ((Expr s a -> Expr t a)
-> Map Text (Expr s a) -> Map Text (Expr t a)
forall (f :: * -> *) a b. Functor f => (a -> b) -> f a -> f b
fmap Expr s a -> Expr t a
forall s a t. Expr s a -> Expr t a
denote Map Text (Expr s a)
a)
denote (RecordLit a :: Map Text (Expr s a)
a ) = Map Text (Expr t a) -> Expr t a
forall s a. Map Text (Expr s a) -> Expr s a
RecordLit ((Expr s a -> Expr t a)
-> Map Text (Expr s a) -> Map Text (Expr t a)
forall (f :: * -> *) a b. Functor f => (a -> b) -> f a -> f b
fmap Expr s a -> Expr t a
forall s a t. Expr s a -> Expr t a
denote Map Text (Expr s a)
a)
denote (Union a :: Map Text (Maybe (Expr s a))
a ) = Map Text (Maybe (Expr t a)) -> Expr t a
forall s a. Map Text (Maybe (Expr s a)) -> Expr s a
Union ((Maybe (Expr s a) -> Maybe (Expr t a))
-> Map Text (Maybe (Expr s a)) -> Map Text (Maybe (Expr t a))
forall (f :: * -> *) a b. Functor f => (a -> b) -> f a -> f b
fmap ((Expr s a -> Expr t a) -> Maybe (Expr s a) -> Maybe (Expr t a)
forall (f :: * -> *) a b. Functor f => (a -> b) -> f a -> f b
fmap Expr s a -> Expr t a
forall s a t. Expr s a -> Expr t a
denote) Map Text (Maybe (Expr s a))
a)
denote (Combine _ b :: Expr s a
b c :: Expr s a
c ) = Maybe Text -> Expr t a -> Expr t a -> Expr t a
forall s a. Maybe Text -> Expr s a -> Expr s a -> Expr s a
Combine Maybe Text
forall a. Maybe a
Nothing (Expr s a -> Expr t a
forall s a t. Expr s a -> Expr t a
denote Expr s a
b) (Expr s a -> Expr t a
forall s a t. Expr s a -> Expr t a
denote Expr s a
c)
denote (CombineTypes a :: Expr s a
a b :: Expr s a
b ) = Expr t a -> Expr t a -> Expr t a
forall s a. Expr s a -> Expr s a -> Expr s a
CombineTypes (Expr s a -> Expr t a
forall s a t. Expr s a -> Expr t a
denote Expr s a
a) (Expr s a -> Expr t a
forall s a t. Expr s a -> Expr t a
denote Expr s a
b)
denote (Prefer a :: Expr s a
a b :: Expr s a
b ) = Expr t a -> Expr t a -> Expr t a
forall s a. Expr s a -> Expr s a -> Expr s a
Prefer (Expr s a -> Expr t a
forall s a t. Expr s a -> Expr t a
denote Expr s a
a) (Expr s a -> Expr t a
forall s a t. Expr s a -> Expr t a
denote Expr s a
b)
denote (RecordCompletion a :: Expr s a
a b :: Expr s a
b) = Expr t a -> Expr t a -> Expr t a
forall s a. Expr s a -> Expr s a -> Expr s a
RecordCompletion (Expr s a -> Expr t a
forall s a t. Expr s a -> Expr t a
denote Expr s a
a) (Expr s a -> Expr t a
forall s a t. Expr s a -> Expr t a
denote Expr s a
b)
denote (Merge a :: Expr s a
a b :: Expr s a
b c :: Maybe (Expr s a)
c ) = Expr t a -> Expr t a -> Maybe (Expr t a) -> Expr t a
forall s a. Expr s a -> Expr s a -> Maybe (Expr s a) -> Expr s a
Merge (Expr s a -> Expr t a
forall s a t. Expr s a -> Expr t a
denote Expr s a
a) (Expr s a -> Expr t a
forall s a t. Expr s a -> Expr t a
denote Expr s a
b) ((Expr s a -> Expr t a) -> Maybe (Expr s a) -> Maybe (Expr t a)
forall (f :: * -> *) a b. Functor f => (a -> b) -> f a -> f b
fmap Expr s a -> Expr t a
forall s a t. Expr s a -> Expr t a
denote Maybe (Expr s a)
c)
denote (ToMap a :: Expr s a
a b :: Maybe (Expr s a)
b ) = Expr t a -> Maybe (Expr t a) -> Expr t a
forall s a. Expr s a -> Maybe (Expr s a) -> Expr s a
ToMap (Expr s a -> Expr t a
forall s a t. Expr s a -> Expr t a
denote Expr s a
a) ((Expr s a -> Expr t a) -> Maybe (Expr s a) -> Maybe (Expr t a)
forall (f :: * -> *) a b. Functor f => (a -> b) -> f a -> f b
fmap Expr s a -> Expr t a
forall s a t. Expr s a -> Expr t a
denote Maybe (Expr s a)
b)
denote (Field a :: Expr s a
a b :: Text
b ) = Expr t a -> Text -> Expr t a
forall s a. Expr s a -> Text -> Expr s a
Field (Expr s a -> Expr t a
forall s a t. Expr s a -> Expr t a
denote Expr s a
a) Text
b
denote (Project a :: Expr s a
a b :: Either (Set Text) (Expr s a)
b ) = Expr t a -> Either (Set Text) (Expr t a) -> Expr t a
forall s a. Expr s a -> Either (Set Text) (Expr s a) -> Expr s a
Project (Expr s a -> Expr t a
forall s a t. Expr s a -> Expr t a
denote Expr s a
a) ((Expr s a -> Expr t a)
-> Either (Set Text) (Expr s a) -> Either (Set Text) (Expr t a)
forall (f :: * -> *) a b. Functor f => (a -> b) -> f a -> f b
fmap Expr s a -> Expr t a
forall s a t. Expr s a -> Expr t a
denote Either (Set Text) (Expr s a)
b)
denote (Assert a :: Expr s a
a ) = Expr t a -> Expr t a
forall s a. Expr s a -> Expr s a
Assert (Expr s a -> Expr t a
forall s a t. Expr s a -> Expr t a
denote Expr s a
a)
denote (Equivalent a :: Expr s a
a b :: Expr s a
b ) = Expr t a -> Expr t a -> Expr t a
forall s a. Expr s a -> Expr s a -> Expr s a
Equivalent (Expr s a -> Expr t a
forall s a t. Expr s a -> Expr t a
denote Expr s a
a) (Expr s a -> Expr t a
forall s a t. Expr s a -> Expr t a
denote Expr s a
b)
denote (ImportAlt a :: Expr s a
a b :: Expr s a
b ) = Expr t a -> Expr t a -> Expr t a
forall s a. Expr s a -> Expr s a -> Expr s a
ImportAlt (Expr s a -> Expr t a
forall s a t. Expr s a -> Expr t a
denote Expr s a
a) (Expr s a -> Expr t a
forall s a t. Expr s a -> Expr t a
denote Expr s a
b)
denote (Embed a :: a
a ) = a -> Expr t a
forall s a. a -> Expr s a
Embed a
a
renote :: Expr Void a -> Expr s a
renote :: Expr Void a -> Expr s a
renote = Expr Void a -> Expr s a
forall a b. a -> b
unsafeCoerce
{-# INLINE renote #-}
shallowDenote :: Expr s a -> Expr s a
shallowDenote :: Expr s a -> Expr s a
shallowDenote (Note _ e :: Expr s a
e) = Expr s a -> Expr s a
forall s a. Expr s a -> Expr s a
shallowDenote Expr s a
e
shallowDenote e :: Expr s a
e = Expr s a
e
reservedIdentifiers :: HashSet Text
reservedIdentifiers :: HashSet Text
reservedIdentifiers =
[Text] -> HashSet Text
forall a. (Eq a, Hashable a) => [a] -> HashSet a
Data.HashSet.fromList
[
"if"
, "then"
, "else"
, "let"
, "in"
, "using"
, "missing"
, "as"
, "Infinity"
, "NaN"
, "merge"
, "Some"
, "toMap"
, "assert"
, "forall"
, "Natural/fold"
, "Natural/build"
, "Natural/isZero"
, "Natural/even"
, "Natural/odd"
, "Natural/toInteger"
, "Natural/show"
, "Natural/subtract"
, "Integer"
, "Integer/clamp"
, "Integer/negate"
, "Integer/show"
, "Integer/toDouble"
, "Integer/show"
, "Natural/subtract"
, "Double/show"
, "List/build"
, "List/fold"
, "List/length"
, "List/head"
, "List/last"
, "List/indexed"
, "List/reverse"
, "Optional/fold"
, "Optional/build"
, "Text/show"
, "Bool"
, "True"
, "False"
, "Optional"
, "None"
, "Natural"
, "Integer"
, "Double"
, "Text"
, "List"
, "Type"
, "Kind"
, "Sort"
]
splitOn :: Text -> Text -> NonEmpty Text
splitOn :: Text -> Text -> NonEmpty Text
splitOn needle :: Text
needle haystack :: Text
haystack =
case Text -> Text -> [Text]
Data.Text.splitOn Text
needle Text
haystack of
[] -> "" Text -> [Text] -> NonEmpty Text
forall a. a -> [a] -> NonEmpty a
:| []
t :: Text
t : ts :: [Text]
ts -> Text
t Text -> [Text] -> NonEmpty Text
forall a. a -> [a] -> NonEmpty a
:| [Text]
ts
linesLiteral :: Chunks s a -> NonEmpty (Chunks s a)
linesLiteral :: Chunks s a -> NonEmpty (Chunks s a)
linesLiteral (Chunks [] suffix :: Text
suffix) =
(Text -> Chunks s a) -> NonEmpty Text -> NonEmpty (Chunks s a)
forall (f :: * -> *) a b. Functor f => (a -> b) -> f a -> f b
fmap ([(Text, Expr s a)] -> Text -> Chunks s a
forall s a. [(Text, Expr s a)] -> Text -> Chunks s a
Chunks []) (Text -> Text -> NonEmpty Text
splitOn "\n" Text
suffix)
linesLiteral (Chunks ((prefix :: Text
prefix, interpolation :: Expr s a
interpolation) : pairs₀ :: [(Text, Expr s a)]
pairs₀) suffix₀ :: Text
suffix₀) =
(Chunks s a -> NonEmpty (Chunks s a) -> NonEmpty (Chunks s a))
-> NonEmpty (Chunks s a) -> [Chunks s a] -> NonEmpty (Chunks s a)
forall (t :: * -> *) a b.
Foldable t =>
(a -> b -> b) -> b -> t a -> b
foldr
Chunks s a -> NonEmpty (Chunks s a) -> NonEmpty (Chunks s a)
forall a. a -> NonEmpty a -> NonEmpty a
Data.List.NonEmpty.cons
([(Text, Expr s a)] -> Text -> Chunks s a
forall s a. [(Text, Expr s a)] -> Text -> Chunks s a
Chunks ((Text
lastLine, Expr s a
interpolation) (Text, Expr s a) -> [(Text, Expr s a)] -> [(Text, Expr s a)]
forall a. a -> [a] -> [a]
: [(Text, Expr s a)]
pairs₁) Text
suffix₁ Chunks s a -> [Chunks s a] -> NonEmpty (Chunks s a)
forall a. a -> [a] -> NonEmpty a
:| [Chunks s a]
chunks)
((Text -> Chunks s a) -> [Text] -> [Chunks s a]
forall (f :: * -> *) a b. Functor f => (a -> b) -> f a -> f b
fmap ([(Text, Expr s a)] -> Text -> Chunks s a
forall s a. [(Text, Expr s a)] -> Text -> Chunks s a
Chunks []) [Text]
initLines)
where
splitLines :: NonEmpty Text
splitLines = Text -> Text -> NonEmpty Text
splitOn "\n" Text
prefix
initLines :: [Text]
initLines = NonEmpty Text -> [Text]
forall a. NonEmpty a -> [a]
Data.List.NonEmpty.init NonEmpty Text
splitLines
lastLine :: Text
lastLine = NonEmpty Text -> Text
forall a. NonEmpty a -> a
Data.List.NonEmpty.last NonEmpty Text
splitLines
Chunks pairs₁ :: [(Text, Expr s a)]
pairs₁ suffix₁ :: Text
suffix₁ :| chunks :: [Chunks s a]
chunks = Chunks s a -> NonEmpty (Chunks s a)
forall s a. Chunks s a -> NonEmpty (Chunks s a)
linesLiteral ([(Text, Expr s a)] -> Text -> Chunks s a
forall s a. [(Text, Expr s a)] -> Text -> Chunks s a
Chunks [(Text, Expr s a)]
pairs₀ Text
suffix₀)
unlinesLiteral :: NonEmpty (Chunks s a) -> Chunks s a
unlinesLiteral :: NonEmpty (Chunks s a) -> Chunks s a
unlinesLiteral chunks :: NonEmpty (Chunks s a)
chunks =
NonEmpty (Chunks s a) -> Chunks s a
forall (t :: * -> *) m. (Foldable t, Monoid m) => t m -> m
Data.Foldable.fold (Chunks s a -> NonEmpty (Chunks s a) -> NonEmpty (Chunks s a)
forall a. a -> NonEmpty a -> NonEmpty a
Data.List.NonEmpty.intersperse "\n" NonEmpty (Chunks s a)
chunks)
emptyLine :: Chunks s a -> Bool
emptyLine :: Chunks s a -> Bool
emptyLine (Chunks [] "" ) = Bool
True
emptyLine (Chunks [] "\r") = Bool
True
emptyLine _ = Bool
False
leadingSpaces :: Chunks s a -> Text
leadingSpaces :: Chunks s a -> Text
leadingSpaces chunks :: Chunks s a
chunks = (Char -> Bool) -> Text -> Text
Data.Text.takeWhile Char -> Bool
isSpace Text
firstText
where
isSpace :: Char -> Bool
isSpace c :: Char
c = Char
c Char -> Char -> Bool
forall a. Eq a => a -> a -> Bool
== ' ' Bool -> Bool -> Bool
|| Char
c Char -> Char -> Bool
forall a. Eq a => a -> a -> Bool
== '\t'
firstText :: Text
firstText =
case Chunks s a
chunks of
Chunks [] suffix :: Text
suffix -> Text
suffix
Chunks ((prefix :: Text
prefix, _) : _ ) _ -> Text
prefix
longestSharedWhitespacePrefix :: NonEmpty (Chunks s a) -> Text
longestSharedWhitespacePrefix :: NonEmpty (Chunks s a) -> Text
longestSharedWhitespacePrefix literals :: NonEmpty (Chunks s a)
literals =
case (Chunks s a -> Text) -> [Chunks s a] -> [Text]
forall (f :: * -> *) a b. Functor f => (a -> b) -> f a -> f b
fmap Chunks s a -> Text
forall s a. Chunks s a -> Text
leadingSpaces [Chunks s a]
filteredLines of
l :: Text
l : ls :: [Text]
ls -> (Text -> Text -> Text) -> Text -> [Text] -> Text
forall (t :: * -> *) b a.
Foldable t =>
(b -> a -> b) -> b -> t a -> b
Data.Foldable.foldl' Text -> Text -> Text
sharedPrefix Text
l [Text]
ls
[] -> ""
where
sharedPrefix :: Text -> Text -> Text
sharedPrefix ab :: Text
ab ac :: Text
ac =
case Text -> Text -> Maybe (Text, Text, Text)
Data.Text.commonPrefixes Text
ab Text
ac of
Just (a :: Text
a, _b :: Text
_b, _c :: Text
_c) -> Text
a
Nothing -> ""
filteredLines :: [Chunks s a]
filteredLines = [Chunks s a]
newInit [Chunks s a] -> [Chunks s a] -> [Chunks s a]
forall a. Semigroup a => a -> a -> a
<> Chunks s a -> [Chunks s a]
forall (f :: * -> *) a. Applicative f => a -> f a
pure Chunks s a
oldLast
where
oldInit :: [Chunks s a]
oldInit = NonEmpty (Chunks s a) -> [Chunks s a]
forall a. NonEmpty a -> [a]
Data.List.NonEmpty.init NonEmpty (Chunks s a)
literals
oldLast :: Chunks s a
oldLast = NonEmpty (Chunks s a) -> Chunks s a
forall a. NonEmpty a -> a
Data.List.NonEmpty.last NonEmpty (Chunks s a)
literals
newInit :: [Chunks s a]
newInit = (Chunks s a -> Bool) -> [Chunks s a] -> [Chunks s a]
forall a. (a -> Bool) -> [a] -> [a]
filter (Bool -> Bool
not (Bool -> Bool) -> (Chunks s a -> Bool) -> Chunks s a -> Bool
forall b c a. (b -> c) -> (a -> b) -> a -> c
. Chunks s a -> Bool
forall s a. Chunks s a -> Bool
emptyLine) [Chunks s a]
oldInit
dropLiteral :: Int -> Chunks s a -> Chunks s a
dropLiteral :: Int -> Chunks s a -> Chunks s a
dropLiteral n :: Int
n (Chunks [] suffix :: Text
suffix) =
[(Text, Expr s a)] -> Text -> Chunks s a
forall s a. [(Text, Expr s a)] -> Text -> Chunks s a
Chunks [] (Int -> Text -> Text
Data.Text.drop Int
n Text
suffix)
dropLiteral n :: Int
n (Chunks ((prefix :: Text
prefix, interpolation :: Expr s a
interpolation) : rest :: [(Text, Expr s a)]
rest) suffix :: Text
suffix) =
[(Text, Expr s a)] -> Text -> Chunks s a
forall s a. [(Text, Expr s a)] -> Text -> Chunks s a
Chunks ((Int -> Text -> Text
Data.Text.drop Int
n Text
prefix, Expr s a
interpolation) (Text, Expr s a) -> [(Text, Expr s a)] -> [(Text, Expr s a)]
forall a. a -> [a] -> [a]
: [(Text, Expr s a)]
rest) Text
suffix
toDoubleQuoted :: Chunks Src a -> Chunks Src a
toDoubleQuoted :: Chunks Src a -> Chunks Src a
toDoubleQuoted literal :: Chunks Src a
literal =
NonEmpty (Chunks Src a) -> Chunks Src a
forall s a. NonEmpty (Chunks s a) -> Chunks s a
unlinesLiteral ((Chunks Src a -> Chunks Src a)
-> NonEmpty (Chunks Src a) -> NonEmpty (Chunks Src a)
forall (f :: * -> *) a b. Functor f => (a -> b) -> f a -> f b
fmap (Int -> Chunks Src a -> Chunks Src a
forall s a. Int -> Chunks s a -> Chunks s a
dropLiteral Int
indent) NonEmpty (Chunks Src a)
literals)
where
literals :: NonEmpty (Chunks Src a)
literals = Chunks Src a -> NonEmpty (Chunks Src a)
forall s a. Chunks s a -> NonEmpty (Chunks s a)
linesLiteral Chunks Src a
literal
longestSharedPrefix :: Text
longestSharedPrefix = NonEmpty (Chunks Src a) -> Text
forall s a. NonEmpty (Chunks s a) -> Text
longestSharedWhitespacePrefix NonEmpty (Chunks Src a)
literals
indent :: Int
indent = Text -> Int
Data.Text.length Text
longestSharedPrefix