FP.Prelude.Core

Documentation

type ℤ = Integer

data ℤᵀ

Constructors

ZNegInfinity

ZPosInfinity

ZFinite ℤ

type ℕ = Natural

data ℕᵀ

Constructors

NInfinity

NFinite ℕ

Instances

ToDouble ℕᵀ

Additive ℕᵀ

Peano ℕᵀ

Lattice ℕᵀ

MeetLattice ℕᵀ

JoinLattice ℕᵀ

Meet ℕᵀ

Top ℕᵀ

Join ℕᵀ

Bot ℕᵀ

POrd ℕᵀ

type 𝕀 = Int

type 𝔻 = Double

type ℂ = Char

type 𝕊 = Text

type 𝕊ᵇ = Builder

type 𝔹 = Bool

type (⨄) = Either infixr 4

newtype Fold a

Constructors

Fold

Fields

runFold :: forall b. (a -> b -> b) -> b -> b

Instances

Monad Fold

Functor Fold

Singleton a (Fold a)

ToFold a (Fold a)

Eq a => Eq (Fold a)

Ord a => Ord (Fold a)

Show a => Show (Fold a)

ToString (Fold ℂ)

Monoid (Fold a)

data Stream a where

Constructors

Stream :: forall s a. s -> (s -> Maybe (a, s)) -> Stream a

Instances

FunctorM Stream

Monad Stream

Functor Stream

Singleton a (Stream a)

ToStream a (Stream a)

ToFold a (Stream a)

Eq a => Eq (Stream a)

Ord a => Ord (Stream a)

Show a => Show (Stream a)

ToString (Stream ℂ)

Monoid (Stream a)

type 𝒮 = Seq

data 𝒫 a where

Constructors

EmptySet :: 𝒫 a

InhabitedSet :: Ord a => Set a -> 𝒫 a

Instances

Ord a => Singleton a (𝒫 a)

ToStream a (𝒫 a)

ToFold a (𝒫 a)

Eq (𝒫 a)

Ord (𝒫 a)

Show a => Show (𝒫 a)

Monoid (𝒫 a)

JoinLattice (𝒫 a)

Difference (𝒫 a)

Meet (𝒫 a)

Join (𝒫 a)

Bot (𝒫 a)

POrd (𝒫 a)

data k ⇰ v where infixr 3

Constructors

EmptyDict :: k ⇰ v

InhabitedDict :: Ord k => Map k v -> k ⇰ v

Instances

Lookup k v ((⇰) k v)

Functor ((⇰) k)

Eq v => Eq ((⇰) k v)

Ord v => Ord ((⇰) k v)

(Show k, Show v) => Show ((⇰) k v)

Monoid v => Monoid ((⇰) k v)

Join v => JoinLattice ((⇰) k v)

Difference v => Difference ((⇰) k v)

Meet v => Meet ((⇰) k v)

Join v => Join ((⇰) k v)

Bot ((⇰) k v)

POrd v => POrd ((⇰) k v)

Ord k => Singleton (k, v) ((⇰) k v)

ToStream (k, v) ((⇰) k v)

ToFold (k, v) ((⇰) k v)

newtype k ⇰♭⧺ v

Constructors

LazyDictAppend

Fields

runLazyDictAppend :: Fold (k, v)

Instances

(Ord k, Eq v, Monoid v) => Eq ((⇰♭⧺) k v)

(Ord k, Ord v, Monoid v) => Ord ((⇰♭⧺) k v)

(Ord k, Show k, Show v, Monoid v) => Show ((⇰♭⧺) k v)

Monoid ((⇰♭⧺) k v)

Singleton (k, v) ((⇰♭⧺) k v)

ToFold (k, v) ((⇰♭⧺) k v)

newtype k ⇰♭⊔ v

Constructors

LazyDictJoin

Fields

runLazyDictJoin :: Fold (k, v)

Instances

JoinLattice ((⇰♭⊔) k v)

(Ord k, JoinLattice v, Difference v) => Difference ((⇰♭⊔) k v)

Join ((⇰♭⊔) k v)

Bot ((⇰♭⊔) k v)

(Ord k, POrd v, JoinLattice v) => POrd ((⇰♭⊔) k v)

newtype 𝒫ᵇ a

Constructors

LazySet

Fields

runLazySet :: Fold a

Instances

Functor 𝒫ᵇ

Singleton a (𝒫ᵇ a)

ToFold a (𝒫ᵇ a)

Ord a => Eq (𝒫ᵇ a)

Ord a => Ord (𝒫ᵇ a)

(Ord a, Show a) => Show (𝒫ᵇ a)

JoinLattice (𝒫ᵇ a)

Ord a => Difference (𝒫ᵇ a)

Join (𝒫ᵇ a)

Bot (𝒫ᵇ a)

Ord a => POrd (𝒫ᵇ a)

(≟) :: Eq a => a -> a -> 𝔹 infix 6

(⋚) :: Ord a => a -> a -> Ordering infix 6

(≤) :: Ord a => a -> a -> 𝔹 infix 6

(≥) :: Ord a => a -> a -> 𝔹 infix 6

minBy :: Ord b => (a -> b) -> a -> a -> a

maxBy :: Ord b => (a -> b) -> a -> a -> a

class Peano a where

Methods

suc :: a -> a

zero :: a

Instances

Peano 𝔻

Peano 𝕀

Peano ℕᵀ

Peano ℕ

Peano ℤ

class Peano a => Additive a where

Methods

(+) :: a -> a -> a infixr 4

Instances

Additive 𝔻

Additive 𝕀

Additive ℕᵀ

Additive ℕ

Additive ℤ

class Additive a => Subtractive a where

Methods

(-) :: a -> a -> a infix 4

Instances

Subtractive 𝔻

Subtractive 𝕀

Subtractive ℕ

Subtractive ℤ

class Additive a => Multiplicative a where

Methods

one :: a

(×) :: a -> a -> a infixr 5

Instances

Multiplicative 𝔻

Multiplicative 𝕀

Multiplicative ℕ

Multiplicative ℤ

class Multiplicative a => Divisible a where

Methods

(/) :: a -> a -> a infix 5

Instances

Divisible 𝔻

class Multiplicative a => TruncateDivisible a where

Methods

(⌿) :: a -> a -> a infix 5

Instances

TruncateDivisible 𝕀

TruncateDivisible ℕ

TruncateDivisible ℤ

class Multiplicative a => Exponential a where

Methods

(^) :: a -> a -> a infixl 8

negate :: Subtractive a => a -> a

inverse :: Divisible a => a -> a

class Monoid a where

Methods

null :: a

(⧺) :: a -> a -> a infixr 4

Instances

Monoid 𝕊ᵇ

Monoid 𝕊

Monoid PrettyOut

Monoid Doc

Functorial * Monoid ID

Monoid a => Functorial * Monoid ((,) a)

Monoid [a]

Monoid (𝒫 a)

Monoid (Stream a)

Monoid (Fold a)

Monoid a => Monoid (ID a)

Monoid (Last a)

Monoid (First a)

Monoid (Endo a)

Monoid (SourceErrorMaybe t)

Monoid (SourceContext t)

Monoid (ParserOut t)

Monoid b => Monoid (a -> b)

(Monoid a, Monoid b) => Monoid (a, b)

Monoid ((⇰♭⧺) k v)

Monoid v => Monoid ((⇰) k v)

Comonad w => Monoid (EndoW w a)

Monad m => Monoid (EndoM m a)

Monoid (SourceContextPrefix k t)

Monoid (Mixfix t a)

Monoid (Mixes t a)

Monoid (MixfixF t f a)

Monoid (MixesF t f a)

class Functor t where

Methods

map :: (a -> b) -> t a -> t b

Instances

Functor []

Functor IO

Functor Maybe

Functor 𝒫ᵇ

Functor Stream

Functor Fold

Functor AddTop

Functor AddBot

Functor ID

Functor PrettyM

Functor StampM

Functor ((->) a)

Functor ((,) a)

Functor ((⇰) k)

Functor ((⨄) a)

Functor (FullContextAnnotated t)

Functor (Parser t)

Functor (GreedyParser t)

Functor (PreAtom n)

Functor (PreExp n)

Functor (PathSensitiveM val)

Functor (FlowInsensitiveM val)

Functor (FlowSensitiveM val)

Functor ς => Functor (StateΠ s ς)

Functor m => Functor (PolyStateT s m)

Functor ς => Functor (PolyStateΠ s ς)

Functor m => Functor (RWST r o s m)

mapOn :: Functor t => t a -> (a -> b) -> t b

(^⋅) :: Functor t => (a -> b) -> t a -> t b infixl 9

(^$) :: Functor t => (a -> b) -> t a -> t b infixr 0

(^∘) :: Functor t => (b -> c) -> (a -> t b) -> a -> t c infixr 7

class Functor m => Monad m where

Methods

return :: a -> m a

(≫=) :: m a -> (a -> m b) -> m b infixr 1

Instances

Monad []

Monad IO

Monad Maybe

Monad Stream

Monad Fold

Monad ID

Monad PrettyM

Monad StampM

Monad ((->) a)

Monoid a => Monad ((,) a)

Monad ((⨄) a)

Monad (Parser t)

Monad (GreedyParser t)

Monad (PathSensitiveM val)

Join val => Monad (FlowInsensitiveM val)

Join val => Monad (FlowSensitiveM val)

Monad m => Monad (PolyStateT s m)

(Monad m, Monoid o) => Monad (RWST r o s m)

(*⋅) :: Monad m => (a -> m b) -> m a -> m b infixl 9

(*$) :: Monad m => (a -> m b) -> m a -> m b infixr 0

(*∘) :: Monad m => (b -> m c) -> (a -> m b) -> a -> m c infixr 7

kreturn :: Monad m => (a -> b) -> a -> m b

extend :: Monad m => (a -> m b) -> m a -> m b

(≫) :: Monad m => m a -> m b -> m b infixr 1

void :: Monad m => m a -> m ()

mjoin :: Monad m => m (m a) -> m a

mmap :: Monad m => (a -> b) -> m a -> m b

(<×>) :: Monad m => m a -> m b -> m (a, b) infixr 5

(<⋅>) :: Monad m => m (a -> b) -> m a -> m b infixl 9

when :: Monad m => 𝔹 -> m () -> m ()

whenM :: Monad m => m 𝔹 -> m () -> m ()

whenMaybe :: Monad m => Maybe a -> (a -> m ()) -> m ()

whenMaybeM :: Monad m => m (Maybe a) -> (a -> m ()) -> m ()

returnMaybe :: Monad m => m a -> Maybe a -> m a

class FunctorM t where

Methods

mapM :: Monad m => (a -> m b) -> t a -> m (t b)

Instances

FunctorM []

FunctorM Maybe

FunctorM Stream

FunctorM ID

FunctorM ((,) a)

FunctorM ((⨄) a)

FunctorM (PreAtom n)

FunctorM (PreExp n)

mapMOn :: (FunctorM t, Monad m) => t a -> (a -> m b) -> m (t b)

sequence :: (FunctorM t, Monad m) => t (m a) -> m (t a)

(^*⋅) :: (FunctorM t, Monad m) => (a -> m b) -> t a -> m (t b) infixl 9

(^*$) :: (FunctorM t, Monad m) => (a -> m b) -> t a -> m (t b) infixr 0

(^*∘) :: (FunctorM t, Monad m) => (b -> m c) -> (a -> m b) -> t a -> m (t c) infixr 7

class ToFold a t | t -> a where

Methods

fold :: t -> Fold a

Instances

ToFold ℂ 𝕊

ToFold a (𝒫ᵇ a)

ToFold a (𝒫 a)

ToFold a [a]

ToFold a (Stream a)

ToFold a (Fold a)

ToFold (k, v) ((⇰♭⧺) k v)

ToFold (k, v) ((⇰) k v)

class ToStream a t | t -> a where

Methods

stream :: t -> Stream a

Instances

ToStream ℂ 𝕊

ToStream a (𝒫 a)

ToStream a [a]

ToStream a (Stream a)

ToStream (k, v) ((⇰) k v)

class Singleton a t | t -> a where

Methods

single :: a -> t

Instances

Singleton ℂ 𝕊

Singleton a (𝒫ᵇ a)

Ord a => Singleton a (𝒫 a)

Singleton a [a]

Singleton a (Stream a)

Singleton a (Fold a)

Singleton (k, v) ((⇰♭⧺) k v)

Ord k => Singleton (k, v) ((⇰) k v)

class ToInteger a where

Methods

𝕫 :: a -> ℤ

Instances

ToInteger 𝕀

ToInteger ℕ

ToInteger ℤ

class ToNatural a where

Methods

𝕟 :: a -> ℕ

Instances

ToNatural 𝕀

ToNatural ℕ

ToNatural ℤ

class ToInt a where

Methods

𝕚 :: a -> 𝕀

Instances

ToInt 𝕀

ToInt ℕ

ToInt ℤ

class ToDouble a where

Methods

𝕕 :: a -> 𝔻

Instances

ToDouble 𝔻

ToDouble 𝕀

ToDouble ℕᵀ

ToDouble ℕ

ToDouble ℤ

class ToString a where

Methods

𝕤 :: a -> 𝕊

Instances

ToString 𝕊ᵇ

ToString 𝕊

ToString ℂ

ToString [ℂ]

ToString (Stream ℂ)

ToString (Fold ℂ)

𝕟ᵀ :: ToNatural a => a -> ℕᵀ

class Lookup k v t | t -> k, t -> v where

Methods

lookup :: k -> t -> Maybe v

Instances

Lookup k v ((⇰) k v)

Unbox a => Lookup (ℕ, ℕ) a (𝕄ᵘ a)

Lookup (ℕ, ℕ) a (𝕄 a)

(#) :: Lookup k v t => t -> k -> Maybe v infixl 8

(#!) :: Lookup k v t => t -> k -> v infixl 8

chars :: 𝕊 -> [ℂ]

𝕤show :: Show a => a -> 𝕊

𝕤read :: Read a => 𝕊 -> a

𝕤ᵇ :: ToString a => a -> 𝕊ᵇ

not :: 𝔹 -> 𝔹

(∧) :: 𝔹 -> 𝔹 -> 𝔹 infixr 5

(∨) :: 𝔹 -> 𝔹 -> 𝔹 infixr 4

fif :: 𝔹 -> a -> a -> a

elimSum :: (a -> c) -> (b -> c) -> (a ⨄ b) -> c

mapSum :: (a -> a') -> (b -> b') -> (a ⨄ b) -> a' ⨄ b'

mapLeft :: (a -> c) -> (a ⨄ b) -> c ⨄ b

mapRight :: (b -> c) -> (a ⨄ b) -> a ⨄ c

swapSum :: (a ⨄ b) -> b ⨄ a

fst :: (a, b) -> a

snd :: (a, b) -> b

swap :: (a, b) -> (b, a)

mapPair :: (a -> a') -> (b -> b') -> (a, b) -> (a', b')

mapFst :: (a -> a') -> (a, b) -> (a', b)

mapSnd :: (b -> b') -> (a, b) -> (a, b')

id :: a -> a

(♯$) :: (a -> b) -> a -> b infixr 0

(♯⋅) :: (a -> b) -> a -> b infixl 9

(∘) :: (b -> c) -> (a -> b) -> a -> c infixr 7

(∘∘) :: (c -> d) -> (a -> b -> c) -> a -> b -> d infixr 7

const :: b -> a -> b

flip :: (a -> b -> c) -> b -> a -> c

curry :: ((a, b) -> c) -> a -> b -> c

uncurry :: (a -> b -> c) -> (a, b) -> c

rotateR :: (a -> b -> c -> d) -> c -> a -> b -> d

rotateL :: (a -> b -> c -> d) -> b -> c -> a -> d

mirror :: (a -> b -> c -> d) -> c -> b -> a -> d

on :: (b -> b -> c) -> (a -> b) -> a -> a -> c

elimMaybe :: b -> (a -> b) -> Maybe a -> b

elimMaybeOn :: Maybe a -> b -> (a -> b) -> b

ifNothing :: a -> Maybe a -> a

emptyFold :: Fold a

singleFold :: a -> Fold a

consFold :: a -> Fold a -> Fold a

foldlk :: ToFold a t => (b -> a -> (b -> b) -> b) -> b -> t -> b

foldlkOn :: ToFold a t => t -> b -> (b -> a -> (b -> b) -> b) -> b

foldl :: ToFold a t => (b -> a -> b) -> b -> t -> b

foldlOn :: ToFold a t => t -> b -> (b -> a -> b) -> b

iter :: ToFold a t => (a -> b -> b) -> b -> t -> b

iterOn :: ToFold a t => t -> b -> (a -> b -> b) -> b

foldr :: ToFold a t => (a -> b -> b) -> b -> t -> b

foldrOn :: ToFold a t => t -> b -> (a -> b -> b) -> b

sum :: (ToFold a t, Additive a) => t -> a

product :: (ToFold a t, Multiplicative a) => t -> a

concat :: (ToFold a t, Monoid a) => t -> a

mfoldl :: (Monad m, ToFold a t) => (b -> a -> m b) -> b -> t -> m b

miter :: (Monad m, ToFold a t) => (a -> b -> m b) -> b -> t -> m b

mfoldr :: (Monad m, ToFold a t) => (a -> b -> m b) -> b -> t -> m b

foreach :: (Monad m, ToFold a t) => (a -> m ()) -> t -> m ()

foreachOn :: (Monad m, ToFold a t) => t -> (a -> m ()) -> m ()

exec :: (Monad m, ToFold (m ()) t) => t -> m ()

list :: ToFold a t => t -> [a]

set :: (ToFold a t, Ord a) => t -> 𝒫 a

lazySet :: ToFold a t => t -> 𝒫ᵇ a

dict :: (ToFold (k, v) t, Ord k) => t -> k ⇰ v

dictAppend :: (ToFold (k, v) t, Ord k, Monoid v) => t -> k ⇰ v

lazyDictAppend :: ToFold (k, v) t => t -> k ⇰♭⧺ v

emptyStream :: Stream a

singleStream :: a -> Stream a

unconsStream :: Stream a -> Maybe (a, Stream a)

isEmpty :: ToStream a t => t -> 𝔹

singleList :: a -> [a]

cons :: a -> [a] -> [a]

uncons :: [a] -> Maybe (a, [a])

zip :: [a] -> [b] -> Maybe [(a, b)]

zipAssumeSameLength :: [a] -> [b] -> [(a, b)]

unzip :: [(a, b)] -> ([a], [b])

partition :: [a ⨄ b] -> ([a], [b])

reverse :: [a] -> [a]

elimPrimConcreteSet :: b -> (Ord a => Set a -> b) -> 𝒫 a -> b

elimPrimOnSet :: 𝒫 a -> b -> (Ord a => Set a -> b) -> b

elimPrim22Set :: c -> (Ord b => Set b -> c) -> (Ord a => Set a -> c) -> ((Ord a, Ord b) => Set a -> Set b -> c) -> 𝒫 a -> 𝒫 b -> c

elimPrim21Set :: b -> (Ord a => Set a -> b) -> (Ord a => Set a -> Set a -> b) -> 𝒫 a -> 𝒫 a -> b

toPrimSet :: 𝒫 a -> Set a

learnSet :: 𝒫 a -> b -> (Ord a => b) -> b

learn22Set :: 𝒫 a -> 𝒫 b -> c -> (Ord b => c) -> (Ord a => c) -> ((Ord a, Ord b) => c) -> c

emptySet :: 𝒫 a

singleSet :: Ord a => a -> 𝒫 a

insert :: Ord a => a -> 𝒫 a -> 𝒫 a

unionSet :: 𝒫 a -> 𝒫 a -> 𝒫 a

intersectionSet :: 𝒫 a -> 𝒫 a -> 𝒫 a

differenceSet :: 𝒫 a -> 𝒫 a -> 𝒫 a

isSubsetOf :: 𝒫 a -> 𝒫 a -> 𝔹

(∈) :: a -> 𝒫 a -> 𝔹 infix 6

elem :: a -> 𝒫 a -> Bool

elemOf :: 𝒫 a -> a -> 𝔹

removeMin :: 𝒫 a -> Maybe (a, 𝒫 a)

removeMax :: 𝒫 a -> Maybe (a, 𝒫 a)

mapSet :: Ord b => (a -> b) -> 𝒫 a -> 𝒫 b

mapSetOn :: Ord b => 𝒫 a -> (a -> b) -> 𝒫 b

extendSet :: (a -> 𝒫 b) -> 𝒫 a -> 𝒫 b

(≫=*) :: 𝒫 a -> (a -> 𝒫 b) -> 𝒫 b infixr 1

elimPrimDict :: b -> (Ord k => Map k v -> b) -> (k ⇰ v) -> b

elimPrimOnDict :: (k ⇰ v) -> b -> (Ord k => Map k v -> b) -> b

elimPrim22Dict :: b -> (Ord k => Map k v -> b) -> (Ord k => Map k v -> b) -> (Ord k => Map k v -> Map k v -> b) -> (k ⇰ v) -> (k ⇰ v) -> b

elimPrim21Dict :: b -> (Ord k => Map k v -> b) -> (Ord k => Map k v -> Map k v -> b) -> (k ⇰ v) -> (k ⇰ v) -> b

toPrimDict :: (k ⇰ v) -> Map k v

learnDict :: (k ⇰ v) -> b -> (Ord k => b) -> b

emptyDict :: k ⇰ v

keys :: (k ⇰ v) -> 𝒫 k

values :: (k ⇰ v) -> [v]

type Old a = a

type New a = a

insertWithDict :: Ord k => (Old v -> New v -> v) -> k -> v -> (k ⇰ v) -> k ⇰ v

insertDict :: Ord k => k -> v -> (k ⇰ v) -> k ⇰ v

(↦) :: Ord k => k -> v -> (k, v) infixr 3

removeMinDict :: (k ⇰ v) -> Maybe ((k, v), k ⇰ v)

removeMaxDict :: (k ⇰ v) -> Maybe ((k, v), k ⇰ v)

unionWithDict :: (Old v -> New v -> v) -> (k ⇰ v) -> (k ⇰ v) -> k ⇰ v

unionWithDictOn :: (k ⇰ v) -> (k ⇰ v) -> (Old v -> New v -> v) -> k ⇰ v

isSubdictOfBy :: (v -> v -> 𝔹) -> (k ⇰ v) -> (k ⇰ v) -> 𝔹

intersectionWithDict :: (Old v -> New v -> v) -> (k ⇰ v) -> (k ⇰ v) -> k ⇰ v

differenceWithDict :: (v -> v -> v) -> (k ⇰ v) -> (k ⇰ v) -> k ⇰ v

modifyDict :: (v -> v) -> k -> (k ⇰ v) -> k ⇰ v

modifyDictOn :: k -> (v -> v) -> (k ⇰ v) -> k ⇰ v

onlyKeys :: Ord k => 𝒫 k -> (k ⇰ v) -> k ⇰ v

filterDict :: (v -> 𝔹) -> (k ⇰ v) -> k ⇰ v

concretizeSet :: Ord a => 𝒫ᵇ a -> 𝒫 a

concretizeDictAppend :: (Ord k, Monoid v) => (k ⇰♭⧺ v) -> k ⇰ v

mapKeyLazyDictAppend :: (k -> k') -> (k ⇰♭⧺ v) -> k' ⇰♭⧺ v

error :: 𝕊 -> a

undefined :: a

class MonadIO m where

Methods

io :: IO a -> m a

Instances

MonadIO IO

print :: MonadIO m => 𝕊 -> m ()

printLn :: MonadIO m => 𝕊 -> m ()

failIO :: MonadIO m => 𝕊 -> m a

abortIO :: MonadIO m => m a

readFile :: MonadIO m => 𝕊 -> m 𝕊

readInput :: IO 𝕊

writeFile :: MonadIO m => 𝕊 -> 𝕊 -> m ()

trace :: 𝕊 -> a -> a

traceM :: Monad m => 𝕊 -> m ()

ioFailure :: (Monad m, MonadIO m) => Maybe a -> m a

ifThenElse :: 𝔹 -> a -> a -> a

fromInteger :: ℤ -> ℤ

fromString :: [ℂ] -> 𝕊

fail :: [ℂ] -> m a

(>>=) :: Monad m => m a -> (a -> m b) -> m b infixr 1

(>>) :: Monad m => m a -> m b -> m b infixr 1

module Control.Exception

module Data.Char

module Data.Coerce

module Data.List

module Language.Haskell.TH

module Numeric.Natural

module Prelude

module System.IO.Unsafe