large-records-0.4.2: Efficient compilation for large records, linear in the size of the record

Safe Haskell	Safe-Inferred
Language	Haskell2010

Data.Record.Plugin.Runtime

Contents

Prelude
Other base
AnyArray
large-generics
- wrappers
- ThroughLRGenerics

Description

Re-exports of types and functions used by generated code

This exports all functionality required by the generated code, with the exception of GHC generics (name clash with large-records generics).

Synopsis

type Int = Int
error :: HasCallStack => String -> a
type Constraint = Constraint
type Proxy = Proxy
type Type = Type
proxy :: forall k (a :: k). Proxy a
type AnyArray = SmallArray Any
anyArrayFromList :: [Any] -> AnyArray
anyArrayToList :: AnyArray -> [Any]
anyArrayIndex :: AnyArray -> Int -> Any
anyArrayUpdate :: AnyArray -> [(Int, Any)] -> AnyArray
type Rep = Rep
type Dict = Dict
anyArrayToRep :: AnyArray -> Rep I a
anyArrayFromRep :: Rep I a -> AnyArray
mkDicts :: [Dict c Any] -> Rep (Dict c) a
mkDict :: c x => Proxy c -> Proxy x -> Dict c x
mkStrictField :: forall name a. KnownSymbol name => Proxy name -> FieldMetadata a
mkLazyField :: forall name a. KnownSymbol name => Proxy name -> FieldMetadata a
mkMetadata :: String -> String -> [FieldMetadata Any] -> Metadata a
gcompare :: (Generic a, Constraints a Ord) => a -> a -> Ordering
geq :: (Generic a, Constraints a Eq) => a -> a -> Bool
gshowsPrec :: (Generic a, Constraints a Show) => Int -> a -> ShowS
noInlineUnsafeCo :: a -> b
type ThroughLRGenerics = ThroughLRGenerics
wrapThroughLRGenerics :: a -> ThroughLRGenerics a p
unwrapThroughLRGenerics :: ThroughLRGenerics a p -> a

Prelude

type Int = Int Source #

error :: HasCallStack => String -> a Source #

Other base

type Constraint = Constraint Source #

type Proxy = Proxy Source #

type Type = Type Source #

proxy :: forall k (a :: k). Proxy a Source #

AnyArray

type AnyArray = SmallArray Any Source #

anyArrayFromList :: [Any] -> AnyArray Source #

anyArrayToList :: AnyArray -> [Any] Source #

anyArrayIndex :: AnyArray -> Int -> Any Source #

anyArrayUpdate :: AnyArray -> [(Int, Any)] -> AnyArray Source #

large-generics

type Rep = Rep Source #

type Dict = Dict Source #

anyArrayToRep :: AnyArray -> Rep I a Source #

anyArrayFromRep :: Rep I a -> AnyArray Source #

mkDicts :: [Dict c Any] -> Rep (Dict c) a Source #

mkDict :: c x => Proxy c -> Proxy x -> Dict c x Source #

mkStrictField :: forall name a. KnownSymbol name => Proxy name -> FieldMetadata a Source #

mkLazyField :: forall name a. KnownSymbol name => Proxy name -> FieldMetadata a Source #

mkMetadata Source #

Arguments

:: String	Record name
-> String	Constructor name
-> [FieldMetadata Any]
-> Metadata a

wrappers

gcompare :: (Generic a, Constraints a Ord) => a -> a -> Ordering Source #

geq :: (Generic a, Constraints a Eq) => a -> a -> Bool Source #

gshowsPrec :: (Generic a, Constraints a Show) => Int -> a -> ShowS Source #

noInlineUnsafeCo :: a -> b Source #

ThroughLRGenerics

type ThroughLRGenerics = ThroughLRGenerics Source #

wrapThroughLRGenerics :: a -> ThroughLRGenerics a p Source #

unwrapThroughLRGenerics :: ThroughLRGenerics a p -> a Source #