Reference

Every module's exports as GHCi's :browse prints them for the compiled library (scripts/site/capture.py). The umbrella module Quaalude re-exports all of these except Braket and Type, together with the libraries it builds on. The guide explains how the pieces fit together.

Quaalude.Alias101Notation: number-set types (ℤ, ℕ, ℚ, ℝ, 𝔹, 𝕊, 𝕋), logic and function operators (∘ ≡ ≤ ∧ ∨ ⋅), ⊥, sorting with 🎜 and 🎝, and the ??? conditional.
type ℤ' :: *
type ℤ' = Int
type ℤ₆₄ :: *
type ℤ₆₄ = Int
type ℤ :: *
type ℤ = Integer
type ℤ² :: *
type ℤ² = (ℤ, ℤ)
type ℤ³ :: *
type ℤ³ = (ℤ, ℤ, ℤ)
type ℤ⁴ :: *
type ℤ⁴ = (ℤ, ℤ, ℤ, ℤ)
type ℤ⁵ :: *
type ℤ⁵ = (ℤ, ℤ, ℤ, ℤ, ℤ)
type ℤ⁶ :: *
type ℤ⁶ = (ℤ, ℤ, ℤ, ℤ, ℤ, ℤ)
type ℤ⁷ :: *
type ℤ⁷ = (ℤ, ℤ, ℤ, ℤ, ℤ, ℤ, ℤ)
type ℤ⁸ :: *
type ℤ⁸ = (ℤ, ℤ, ℤ, ℤ, ℤ, ℤ, ℤ, ℤ)
type ℤ⁹ :: *
type ℤ⁹ = (ℤ, ℤ, ℤ, ℤ, ℤ, ℤ, ℤ, ℤ, ℤ)
type ℤ¹⁰ :: *
type ℤ¹⁰ = (ℤ, ℤ, ℤ, ℤ, ℤ, ℤ, ℤ, ℤ, ℤ, ℤ)
type ℕ :: *
type ℕ = Natural
type Nat10 :: Data.Nat.Nat
type Nat10 = Data.Nat.S Data.Type.Nat.Nat9 :: Data.Nat.Nat
type ℕ₁ :: *
type ℕ₁ = Data.Fin.Fin Data.Type.Nat.Nat1
type ℕ₂ :: *
type ℕ₂ = Data.Fin.Fin Data.Type.Nat.Nat2
type ℕ₃ :: *
type ℕ₃ = Data.Fin.Fin Data.Type.Nat.Nat3
type ℕ₄ :: *
type ℕ₄ = Data.Fin.Fin Data.Type.Nat.Nat4
type ℕ₅ :: *
type ℕ₅ = Data.Fin.Fin Data.Type.Nat.Nat5
type ℕ₆ :: *
type ℕ₆ = Data.Fin.Fin Data.Type.Nat.Nat6
type ℕ₇ :: *
type ℕ₇ = Data.Fin.Fin Data.Type.Nat.Nat7
type ℕ₈ :: *
type ℕ₈ = Data.Fin.Fin Data.Type.Nat.Nat8
type ℕ₉ :: *
type ℕ₉ = Data.Fin.Fin Data.Type.Nat.Nat9
type ℕ₁₀ :: *
type ℕ₁₀ = Data.Fin.Fin Nat10
type ℕ₁₀² :: *
type ℕ₁₀² = (ℕ₁₀, ℕ₁₀)
type ℚ :: *
type ℚ = Rational
type ℚ² :: *
type ℚ² = (ℚ, ℚ)
type ℝ :: *
type ℝ = Double
type ℝ² :: *
type ℝ² = (ℝ, ℝ)
type ℂ :: *
type ℂ = Data.Complex.Complex ℝ
type 𝔹 :: *
type 𝔹 = Bool
type 𝕊 :: *
type 𝕊 = String
type 𝕋 :: *
type 𝕋 = Text
type Inf :: * -> Constraint
class Inf a where infinity :: a (∞) :: a ꝏ :: a
bottom :: a
(⊥) :: a
(∘) :: (b -> c) -> (a -> b) -> a -> c
(⋅) :: Num a => a -> a -> a
(≡) :: Eq a => a -> a -> Bool
(≢) :: Eq a => a -> a -> Bool
(≤) :: Ord a => a -> a -> Bool
(≥) :: Ord a => a -> a -> Bool
(∧) :: Bool -> Bool -> Bool
(∨) :: Bool -> Bool -> Bool
type QuestionableF :: * -> *
type family QuestionableF a where QuestionableF (Maybe a) = a
type QuestionableFR :: * -> *
type family QuestionableFR a where QuestionableFR (Maybe a) = a
type Questionable :: * -> Constraint
class Questionable a where (?) :: a -> QuestionableF a -> QuestionableFR a
(???) :: Bool -> a -> a -> a
(<>.) :: Monoid c => (b -> [c]) -> (a -> b) -> a -> c
(<>∘) :: Monoid c => (b -> [c]) -> (a -> b) -> a -> c
(<>!) :: Monoid a => [a] -> a
(<>?) :: [Maybe a] -> [a]
(±) :: Num a => a -> a
(⇱) :: Bifunctor p => (a -> b) -> p a c -> p b c
(⇲) :: Bifunctor p => p b a -> (a -> c) -> p b c
(#) :: Applicative m => a -> m a
φ :: Applicative m => a -> m a
type (:|->) :: * -> * -> *
type (:|->) k v = Map k v
ixℤ :: (Control.Lens.At.Ixed m, Applicative f, Integral p, Num (Control.Lens.At.Index m)) => p -> (Control.Lens.At.IxValue m -> f (Control.Lens.At.IxValue m)) -> m -> f m
(🎜) :: (Ord a, Foldable f) => f a -> [a]
(🎝) :: (Ord a, Foldable f) => f a -> [a]
type (≠) :: * -> (* -> *) -> *
type family (≠) a nonEmptyMarker where (≠) [a] [] = NonEmpty a
Quaalude.Bits7Bit helpers: bits to and from integers, most and least common bit, hex to binary.
bitsToInt :: Bits a => a -> Integer
intToBits :: Int -> [Bool]
zeroCount :: Bits a => a -> Int
mostCommonBit :: Bits a => a -> Bool
leastCommonBit :: Bits a => a -> Bool
hexToBin :: Char -> String
bitArrayToInt :: bitwise-1.0.0.1:Data.Array.BitArray.Internal.BitArray Int -> Int
Quaalude.BoundedSet7Sets that track their bounds and an origin.
type Originable :: (* -> *) -> * -> Constraint
class Originable f a where origin :: a toOrigin :: f a -> f a default toOrigin :: f a -> f a (⌞) :: f a -> f a default (⌞) :: f a -> f a
type Bounded1 :: (* -> *) -> * -> Constraint
class Bounded1 f a where minBound1 :: f a -> a maxBound1 :: f a -> a
type role BoundedSet nominal
type BoundedSet :: * -> *
data BoundedSet a = BoundedSet !a !a !(Set a)
Quaalude.Braket23An experiment with bra-ket notation. Not re-exported by Quaalude.
type Braket :: * -> * -> *
data Braket a b = Braket !a !b
type Bra' :: * -> *
newtype Bra' a = Bra' a
type Ket :: * -> *
newtype Ket a = Ket a
type Bra :: * -> *
type Bra a = () -> BraketClose -> Braket a ()
type BraketDivider :: *
data BraketDivider = Ⲓ
type BraketClose :: *
data BraketClose = BraketClose
ᐳ :: BraketClose
type Braketed :: (* -> * -> *) -> * -> * -> Constraint
class Braketed t a b where く :: a -> BraketDivider -> b -> BraketClose -> t a b unBraket :: t a b -> (a, b) unBra :: t a b -> a unKet :: t a b -> b
type BraketedBra :: * -> * -> Constraint
class BraketedBra t a where bra :: t -> Bra' a
type BraketedKet :: * -> * -> Constraint
class BraketedKet t a where ket :: t -> Ket a
ߊ :: a -> BraketClose -> Ket a
a :: Braket Int Int
b :: Bra Int
c :: Ket Int
Quaalude.Collection229One vocabulary for lists, sets, maps, sequences, vectors and queues: mk, un and co for conversion, and operators for lookup, insertion, deletion, membership and size.
traceMk :: String -> a -> a
traceUn :: String -> a -> a
traceCo :: String -> a -> a
type Packable :: * -> * -> Constraint
class Packable a b where pack :: a -> b unpack :: b -> a
type MkWithable :: (* -> * -> *) -> Constraint
class MkWithable f where mkWith :: (Ord k, Unable t) => (v -> v -> v) -> t (k, v) -> f k v
type Mkable :: (* -> *) -> * -> Constraint
class Mkable f a where mk :: [a] -> f a
pattern Seq₁ :: a -> Seq a
mk₁ :: Mkable f a => a -> f a
type MkableKey :: (* -> * -> *) -> Constraint
class MkableKey f where mkKey :: Ord k => [(k, v)] -> f k v
type MkableOrd :: (* -> *) -> Constraint
class MkableOrd f where mkOrd :: Ord a => [a] -> f a
type Unable :: (* -> *) -> Constraint
class Unable f where un :: f a -> [a]
type UnableKey :: (* -> * -> *) -> Constraint
class UnableKey f where unKey :: f k v -> [(k, v)]
coMk :: (Mkable f y, a ~ [x], Convable x y, c ~ f y) => a -> c
type Convable :: * -> * -> Constraint
class Convable a c where co :: a -> c default co :: (Mkable f y, a ~ [x], Convable x y, c ~ f y) => a -> c
(⊏⊐) :: Convable a c => a -> c
ͼͽ :: Convable a c => a -> c
(⊏) :: Unable f => f a -> [a]
ͽ :: Unable f => f a -> [a]
(⊐) :: Mkable f a => [a] -> f a
ͼ :: (Foldable f, Mkable g a) => f a -> g a
type SplitOnable :: * -> Constraint
class SplitOnable a where splitOn :: a -> a -> [a]
chunksOf :: Int -> [a] -> [[a]]
minimum :: Ord a => [a] -> a
maximum :: Ord a => [a] -> a
nub :: Eq a => [a] -> [a]
foldl1 :: (a -> a -> a) -> [a] -> a
foldl1' :: (a -> a -> a) -> [a] -> a
foldr1 :: (a -> a -> a) -> [a] -> a
mkVec :: [a] -> Vector a
unVec :: Vector a -> [a]
mkSet :: Ord a => [a] -> Set a
unSet :: Set a -> [a]
type Insertable :: (* -> *) -> * -> Constraint
class Insertable f a where (<-|) :: f a -> a -> f a default (<-|) :: f a -> a -> f a (|->) :: a -> f a -> f a default (|->) :: a -> f a -> f a
type Differenceable :: forall {k}. (k -> *) -> k -> Constraint
class Differenceable f a where (\\) :: f a -> f a -> f a (∖) :: f a -> f a -> f a
type Sizable :: * -> Constraint
class Sizable a where size :: Integral i => a -> i
type Memberable :: * -> * -> Constraint
class Memberable a b | b -> a where (∈) :: a -> b -> Bool (∉) :: a -> b -> Bool (∋) :: b -> a -> Bool (∌) :: b -> a -> Bool
type Ixable :: * -> (* -> *) -> Constraint
class Ixable i f where (!!) :: f a -> i -> a (!.) :: f a -> (i, a) -> f a (!?) :: f a -> i -> Maybe a
type Gettable :: (* -> * -> *) -> * -> * -> Constraint
class Gettable f k v where (|!) :: f k v -> k -> v default (|!) :: Ixable k (f k) => f k v -> k -> v
type MaybeGettable :: (* -> * -> *) -> * -> * -> Constraint
class MaybeGettable f k v where (|?) :: f k v -> k -> Maybe v default (|?) :: Ixable k (f k) => f k v -> k -> Maybe v
type ValueGettable :: * -> * -> * -> Constraint
class ValueGettable f k v | f -> v where (|?>) :: f -> v -> [k] (|!>) :: f -> v -> k default (|!>) :: f -> v -> k
type Settable :: (* -> * -> *) -> * -> * -> Constraint
class Settable f k v where (|.) :: f k v -> (k, v) -> f k v default (|.) :: Ixable k (f k) => f k v -> (k, v) -> f k v
type Modifiable :: (* -> * -> *) -> * -> * -> Constraint
class Modifiable f k v where (|~) :: f k v -> (k, v -> v) -> f k v default (|~) :: (Gettable f k v, Settable f k v) => f k v -> (k, v -> v) -> f k v
type Keysable :: * -> * -> Constraint
class Keysable f k where keys :: f -> [k]
type Valuesable :: forall {k}. (k -> * -> *) -> k -> * -> Constraint
class Valuesable f k1 v where values :: f k1 v -> [v]
type Itemsable :: (* -> * -> *) -> * -> * -> Constraint
class Itemsable f k v where items :: f k v -> [(k, v)]
type Deletable :: * -> * -> Constraint
class Deletable m k where delete :: k -> m -> m default delete :: k -> m -> m (|\) :: m -> k -> m default (|\) :: m -> k -> m (|\..) :: Foldable f => m -> f k -> m default (|\..) :: Foldable f => m -> f k -> m (∸) :: m -> k -> m
(∅) :: Monoid a => a
ø :: Monoid a => a
type ConvMonoidLeft :: forall {k}. (k -> *) -> (k -> *) -> Constraint
class ConvMonoidLeft f g where (<⊕) :: forall (a :: k). f a -> g a -> f a
type ConvMonoidRight :: forall {k}. (k -> *) -> (k -> *) -> Constraint
class ConvMonoidRight f g where (⊕>) :: forall (a :: k). f a -> g a -> g a
type ConvMonoid :: forall {k}. (k -> *) -> (k -> *) -> (k -> *) -> Constraint
class ConvMonoid f g h where (<⊕>) :: forall (a :: k). f a -> g a -> h a
(⊆) :: Ord a => Set a -> Set a -> Bool
(⊈) :: Ord a => Set a -> Set a -> Bool
(⊂) :: Ord a => Set a -> Set a -> Bool
(⊄) :: Ord a => Set a -> Set a -> Bool
(⊇) :: Ord a => Set a -> Set a -> Bool
(⊉) :: Ord a => Set a -> Set a -> Bool
(⊃) :: Ord a => Set a -> Set a -> Bool
(⊅) :: Ord a => Set a -> Set a -> Bool
type SetMap :: (* -> *) -> Constraint
class SetMap f where setMap :: Ord b => (a -> b) -> f a -> f b
setConcat :: Ord a => Set (Set a) -> Set a
setConcatMap :: Ord b => (a -> Set b) -> Set a -> Set b
setFilter :: (a -> Bool) -> Set a -> Set a
mkHashMap :: Hashable k => [(k, v)] -> HashMap k v
unHashMap :: HashMap k v -> [(k, v)]
mkHashMapWith :: Hashable k => (v -> v -> v) -> [(k, v)] -> HashMap k v
mkMap :: Ord k => [(k, v)] -> Map k v
unMap :: Map k v -> [(k, v)]
mkMapWith :: Ord k => (v -> v -> v) -> [(k, v)] -> Map k v
mapFilter :: (v -> Bool) -> Map k v -> Map k v
mapSplit :: Ord k => k -> Map k v -> (Map k v, Map k v)
(|/) :: Ord k => Map k v -> k -> Map k v
mkBimap :: (Ord a, Ord b) => [(a, b)] -> Data.Bimap.Bimap a b
unBimap :: Data.Bimap.Bimap a b -> [(a, b)]
mkSeq :: [a] -> Seq a
unSeq :: Seq a -> [a]
emptySeq :: Seq a
(<|) :: a -> Seq a -> Seq a
(⊲) :: a -> Seq a -> Seq a
(|>) :: Seq a -> a -> Seq a
(⊳) :: Seq a -> a -> Seq a
(><) :: Seq a -> Seq a -> Seq a
(⋈) :: Seq a -> Seq a -> Seq a
(>/<) :: Eq a => Seq a -> a -> Seq a
mkMinQ :: Ord k => [(k, a)] -> pqueue-1.5.0.0:Data.PQueue.Prio.Internals.MinPQueue k a
mkQ :: Ord k => [(k, a)] -> pqueue-1.5.0.0:Data.PQueue.Prio.Internals.MinPQueue k a
mkQ₁ :: Ord k => (a -> k) -> a -> pqueue-1.5.0.0:Data.PQueue.Prio.Internals.MinPQueue k a
mkK₁ :: (MkableKey f, Ord k) => k -> a -> pqueue-1.5.0.0:Data.PQueue.Prio.Internals.MinPQueue k a
type ZeroKey :: * -> Constraint
class ZeroKey k where zeroKey :: k
mkℤ₁ :: (Ord k, ZeroKey k, MkableKey f) => a -> f k a
qInsert :: Ord k => (a -> k) -> a -> pqueue-1.5.0.0:Data.PQueue.Prio.Internals.MinPQueue k a -> pqueue-1.5.0.0:Data.PQueue.Prio.Internals.MinPQueue k a
(<-||) :: Ord k => pqueue-1.5.0.0:Data.PQueue.Prio.Internals.MinPQueue k a -> (a -> k, [a]) -> pqueue-1.5.0.0:Data.PQueue.Prio.Internals.MinPQueue k a
(||->) :: Ord k => (a -> k, [a]) -> pqueue-1.5.0.0:Data.PQueue.Prio.Internals.MinPQueue k a -> pqueue-1.5.0.0:Data.PQueue.Prio.Internals.MinPQueue k a
qAppend :: Ord k => (a -> k) -> [a] -> pqueue-1.5.0.0:Data.PQueue.Prio.Internals.MinPQueue k a -> pqueue-1.5.0.0:Data.PQueue.Prio.Internals.MinPQueue k a
nullQ :: pqueue-1.5.0.0:Data.PQueue.Prio.Internals.MinPQueue k a -> Bool
type Emptyable :: * -> Constraint
class Emptyable fa where (∅?) :: fa -> Bool
pattern Φ :: forall {k} (f :: k -> *) (a :: k). Emptyable (f a) => f a
type MinQ :: * -> * -> *
type MinQ = pqueue-1.5.0.0:Data.PQueue.Prio.Internals.MinPQueue :: * -> * -> *
pattern NullQ :: pqueue-1.5.0.0:Data.PQueue.Prio.Internals.MinPQueue k a
pattern (:<!) :: Ord k => (k, a) -> pqueue-1.5.0.0:Data.PQueue.Prio.Internals.MinPQueue k a -> pqueue-1.5.0.0:Data.PQueue.Prio.Internals.MinPQueue k a
pattern (:<!!) :: Ord k => a -> pqueue-1.5.0.0:Data.PQueue.Prio.Internals.MinPQueue k a -> pqueue-1.5.0.0:Data.PQueue.Prio.Internals.MinPQueue k a
(<!) :: Ord k => pqueue-1.5.0.0:Data.PQueue.Prio.Internals.MinPQueue k a -> ((k, a), pqueue-1.5.0.0:Data.PQueue.Prio.Internals.MinPQueue k a)
(<!!) :: Ord k => pqueue-1.5.0.0:Data.PQueue.Prio.Internals.MinPQueue k a -> (a, pqueue-1.5.0.0:Data.PQueue.Prio.Internals.MinPQueue k a)
mkArray :: ghc-internal-9.1003.0:GHC.Internal.Ix.Ix i => (i, i) -> [(i, e)] -> ghc-internal-9.1003.0:GHC.Internal.Arr.Array i e
uhead :: [a] -> a
utail :: [a] -> [a]
uinit :: [a] -> [a]
ulast :: [a] -> a
uread :: Read a => String -> a
digitToInt :: Char -> Int
intToDigit :: Int -> Char
(<%>) :: (Functor g, Data.HList.HList.HMapOut f l e) => f -> g (HList l) -> g [e]
hom :: (Functor g, Data.HList.HList.HMapOut (a -> a) l e) => ([e] -> b) -> g (HList l) -> g b
hdup :: p -> HList [p, p]
cartesian :: [a] -> [b] -> [(a, b)]
type Swappable :: (* -> * -> *) -> * -> * -> Constraint
class Swappable f a b where Quaalude.swap :: f a b -> f b a default Quaalude.swap :: (Ord b, UnableKey f, MkableKey f) => f a b -> f b a
type SwapWithable :: (* -> * -> *) -> (* -> *) -> * -> * -> Constraint
class SwapWithable f m a b where swapWith :: (m a -> m a -> m a) -> f a b -> f b (m a) default swapWith :: (Applicative m, Ord b, UnableKey f, MkWithable f) => (m a -> m a -> m a) -> f a b -> f b (m a)
swapcat :: (SwapWithable f m a b, Semigroup (m a)) => f a b -> f b (m a)
type Filterable :: (* -> *) -> * -> Constraint
class Filterable f a where Quaalude.filter :: (a -> Bool) -> f a -> f a default Quaalude.filter :: (a -> Bool) -> f a -> f a (|-?->) :: f a -> (a -> Bool) -> f a default (|-?->) :: f a -> (a -> Bool) -> f a (<-?-|) :: (a -> Bool) -> f a -> f a default (<-?-|) :: (a -> Bool) -> f a -> f a
type Takeable :: forall {k}. * -> (k -> *) -> k -> Constraint
class Takeable n f a where Quaalude.take :: n -> f a -> f a
type Droppable :: forall {k}. * -> (k -> *) -> k -> Constraint
class Droppable n f a where Quaalude.drop :: n -> f a -> f a
type Headable :: (* -> *) -> * -> Constraint
class Headable f a where head' :: f a -> a
type Tailable :: forall {k}. (k -> *) -> k -> Constraint
class Tailable f a where tail' :: f a -> f a
type role Ť representational nominal
type Ť :: forall {k}. (k -> *) -> k -> *
data Ť f a = Ť !(f a)
type role Ȟ representational nominal
type Ȟ :: forall {k}. (k -> *) -> k -> *
data Ȟ f a = Ȟ !(f a)
type Snocable :: (* -> *) -> * -> Constraint
class Snocable f a where snoc' :: f a -> (a, f a) default snoc' :: (Headable f a, Tailable f a) => f a -> (a, f a)
type Consable :: (* -> *) -> * -> Constraint
class Consable f a where cons' :: a -> f a -> f a
Quaalude.splitAt :: forall {k} n (f :: k -> *) (a :: k). (Takeable n f a, Droppable n f a) => n -> f a -> (f a, f a)
halve :: forall {k} n (f :: k -> *) (a :: k). (Sizable (f a), Integral n, Takeable n f a, Droppable n f a) => f a -> (f a, f a)
type Arbitrary :: (* -> *) -> * -> Constraint
class Arbitrary f a where arbitrary :: f a -> a default arbitrary :: f a -> a (⟒) :: f a -> a arbitrarySnoc :: f a -> (a, f a) default arbitrarySnoc :: (Unable f, Mkable f a) => f a -> (a, f a) arb :: f a -> Maybe a default arb :: Foldable f => f a -> Maybe a
traceArb :: (Arbitrary f a, Show a) => f a -> f a
inRange :: Ord a => (a, a) -> a -> Bool
type RangeSize :: *
data RangeSize = Incl | Excl
rlen :: Num a => RangeSize -> (a, a) -> a
type (|-|) :: forall {k}. * -> k -> *
type (|-|) a b = RangeOf a
(⊯) :: a -> a -> RangeOf2 a a
(⊫) :: a -> a -> RangeOf2 a a
(⥅) :: Num a => a -> a -> RangeOf2 a a
type RangeOf2 :: * -> * -> *
data RangeOf2 a b = RangeOf !RangeSize !(a, b)
type RangeOf :: * -> *
type RangeOf a = RangeOf2 a a
type MagnitudeF :: * -> *
type family MagnitudeF a
type role MagnitudeOp phantom phantom
type MagnitudeOp :: forall {k} {k1}. k -> k1 -> *
data MagnitudeOp a b
type (|.|) :: forall {k}. * -> k -> *
type family (|.|) a b where forall k (_1 :: k) a. (|.|) a _1 = MagnitudeF a
type Magnitude :: * -> Constraint
class Magnitude a where (|.|) :: a -> MagnitudeF a default (|.|) :: (Sizable a, Integral (MagnitudeF a)) => a -> MagnitudeF a magnitude :: a -> MagnitudeF a default magnitude :: a -> MagnitudeF a
(|?|) :: (Magnitude (m b), Alternative m, Monad m) => m b -> (b -> Bool) -> MagnitudeF (m b)
(|≡|) :: (MagnitudeF p1 ~ MagnitudeF p2, Eq (MagnitudeF p2), Magnitude p2, Magnitude p1) => p2 -> p1 -> Bool
(|≢|) :: (MagnitudeF p1 ~ MagnitudeF p2, Eq (MagnitudeF p2), Magnitude p2, Magnitude p1) => p2 -> p1 -> Bool
(|≤|) :: (MagnitudeF p1 ~ MagnitudeF p2, Ord (MagnitudeF p2), Magnitude p2, Magnitude p1) => p2 -> p1 -> Bool
(|≥|) :: (MagnitudeF p1 ~ MagnitudeF p2, Ord (MagnitudeF p2), Magnitude p2, Magnitude p1) => p2 -> p1 -> Bool
(¦<¦) :: (MagnitudeF p1 ~ MagnitudeF p2, Ord (MagnitudeF p2), Magnitude p2, Magnitude p1) => p2 -> p1 -> Bool
(¦>¦) :: (MagnitudeF p1 ~ MagnitudeF p2, Ord (MagnitudeF p2), Magnitude p2, Magnitude p1) => p2 -> p1 -> Bool
type Transposable :: * -> Constraint
class Transposable a where (⊤) :: a -> a
type HMirrorable :: * -> Constraint
class HMirrorable a where (◐) :: a -> a
type VMirrorable :: * -> Constraint
class VMirrorable a where (◓) :: a -> a
type Rotatable :: * -> Constraint
class Rotatable a where (↺) :: a -> a (↻) :: a -> a
type Bimaximum :: * -> Constraint
class Bimaximum a where bimaximum :: Foldable f => f a -> a default bimaximum :: (Bimaximum [a], Foldable f) => f a -> a
type Biminimum :: * -> Constraint
class Biminimum a where biminimum :: Foldable f => f a -> a default biminimum :: (Biminimum [a], Foldable f) => f a -> a
type Trifunctor :: (* -> * -> * -> *) -> Constraint
class Trifunctor f where trimap :: (a -> a') -> (b -> b') -> (c -> c') -> f a b c -> f a' b' c' third :: (c -> c') -> f a b c -> f a b c' default third :: (c -> c') -> f a b c -> f a b c'
three :: Trifunctor f => (a -> b) -> f a a a -> f b b b
type Thd :: (* -> * -> * -> *) -> Constraint
class Trifunctor f => Thd f where thd :: f a b c -> c
type Middle :: (* -> *) -> Constraint
class Middle f where middle :: f a -> a
snoc :: [a] -> (a, [a])
(⇑) :: [a] -> [b] -> [(a, b)]
type ZipWithable :: (* -> *) -> Constraint
class ZipWithable f where (⤊) :: ZipWithable f => (f a, f b) -> (a -> b -> c) -> f c (⤊*) :: (Integral i, Mkable f a, Semigroup (f a), Foldable f, Functor f) => f a -> f i -> f a
type Uniqueable :: forall {k}. (k -> *) -> k -> Constraint
class Uniqueable f a where uniq :: f a -> f a
Quaalude.Compose4Composition of functions of any arity, through a type family.
type ComposeNF :: * -> * -> *
type family ComposeNF g f where forall (t1 :: ghc-prim-0.12.0:GHC.Types.RuntimeRep) (t2 :: ghc-prim-0.12.0:GHC.Types.RuntimeRep) (t3 :: ghc-prim-0.12.0:GHC.Types.RuntimeRep) (b :: TYPE t1) (c :: TYPE t2) (a :: TYPE t3). ComposeNF (b -> c) (a -> b) = a -> c ComposeNF (b -> c) b = c forall (t1 :: ghc-prim-0.12.0:GHC.Types.RuntimeRep) (t2 :: ghc-prim-0.12.0:GHC.Types.RuntimeRep) (t3 :: ghc-prim-0.12.0:GHC.Types.RuntimeRep) (t4 :: ghc-prim-0.12.0:GHC.Types.RuntimeRep) (b :: TYPE t1) (c :: TYPE t2) (x :: TYPE t3) (a :: TYPE t4). ComposeNF (b -> c) (x -> a -> b) = x -> ComposeNF (b -> c) (a -> b)
type ComposeN :: * -> * -> Constraint
class ComposeN g f where composeN :: g -> f -> ComposeNF g f
Quaalude.Coord54Directions in two and three dimensions, turning, coordinates, Manhattan and squared distances, neighbourhoods.
type Dir2 :: *
data Dir2 = DirUp | DirDown | DirLeft | DirRight
type Dir² :: *
type Dir² = Dir2
type RelativeDir :: * -> * -> Constraint
class RelativeDir c d where goingTo :: c -> c -> [d] default goingTo :: Turnable d => c -> c -> [d] comingFrom :: c -> c -> [d] default comingFrom :: Turnable d => c -> c -> [d]
type Turnable :: * -> Constraint
class Turnable d where turnCW :: d -> d turnDiff :: (Integral i, Ord i) => d -> d -> i default turnDiff :: (Integral i, Ord i) => d -> d -> i turnDiffCW :: (Integral i, Ord i) => d -> d -> i default turnDiffCW :: (Integral i, Ord i, Eq d) => d -> d -> i turnDiffCCW :: (Integral i, Ord i) => d -> d -> i default turnDiffCCW :: (Integral i, Ord i, Eq d) => d -> d -> i turnCCW :: d -> d default turnCCW :: d -> d turn180 :: d -> d default turn180 :: d -> d opposite :: d -> d default opposite :: d -> d
type Dir3 :: *
data Dir3 = D3xP | D3xN | D3yP | D3yN | D3zP | D3zN
udlrToDir2 :: Char -> Dir2
nsewToDir2 :: Char -> Dir2
fromArrow² :: Char -> Dir2
fromArrow2 :: Char -> Dir2
toArrow² :: Dir2 -> Char
toArrow2 :: Dir2 -> Char
type Coord2' :: * -> *
type Coord2' a = (a, a)
type Coord2 :: *
type Coord2 = Coord2' Int
type Coord3 :: *
type Coord3 = (Int, Int, Int)
type Coord4 :: *
type Coord4 = (Int, Int, Int, Int)
type Idem2 :: * -> *
type family Idem2 a where Idem2 (a, a) = (a, a) Idem2 Integer = (Integer, Integer) Idem2 Int = (Int, Int) Idem2 Rational = (Rational, Rational)
type Coord' :: * -> * -> * -> Constraint
class Coord' i a k where fromXY :: (i, i) -> k toXY :: k -> (i, i) mapXY :: ((i, i) -> (i, i)) -> k -> k default mapXY :: (k ~ (a, a)) => ((i, i) -> (i, i)) -> k -> k
type Coord :: * -> Constraint
class Coord' Int a a => Coord a
manhattan0 :: Coord2 -> Int
manhattan :: (Coord (a, a), Num a) => (a, a) -> (a, a) -> a
manhattan3 :: Coord3 -> Coord3 -> Int
manhattan4 :: Coord4 -> Coord4 -> Int
type SSDL :: Nat -> * -> * -> Constraint
class SSDL n a b where ssdl :: a -> a -> b
type SSD :: Nat -> * -> * -> Constraint
class SSD n t a where ssd :: t -> t -> a
ds² :: Num a => (a, a) -> (a, a) -> a
ssd² :: Num a => (a, a) -> (a, a) -> a
ssd³ :: Num a => (a, a, a) -> (a, a, a) -> a
move :: (Num c, Num i, Coord' i c (c, c)) => Dir2 -> i -> (c, c) -> (c, c)
move3 :: Dir3 -> Int -> Coord3 -> Coord3
rlToTurn :: Char -> Dir2 -> Dir2
type Neighbors :: Nat -> (* -> *) -> * -> * -> Constraint
class Neighbors n f a g where neighs :: a -> g -> f a
type Vicinity :: Nat -> (* -> *) -> * -> Constraint
class Vicinity n f a where vicinity' :: Integral i => a -> i -> f a vicinity :: a -> f a default vicinity :: a -> f a
neighbors :: Num a => (a, a) -> [(a, a)]
neighborsNoDiags :: Num a => (a, a) -> [(a, a)]
neighbors3 :: Coord3 -> [Coord3]
partitionSpace :: Coord3 -> Coord3 -> [(Coord3, Coord3)]
linePoints :: (Coord2, Coord2) -> [Coord2]
wrap :: Int -> Int -> Coord2 -> Coord2
Quaalude.Described44Functions and arguments tagged with type-level descriptions.
type role ArgDesc phantom
type ArgDesc :: Symbol -> *
data ArgDesc desc = ArgDesc
type role FnDesc phantom
type FnDesc :: Symbol -> *
data FnDesc desc = FnDesc
type role FnName phantom
type FnName :: Symbol -> *
data FnName name = FnName
type (:@) :: * -> Symbol -> *
type (:@) arg description = Data.Tagged.Tagged (ArgDesc description) arg
type (:#>) :: Symbol -> * -> *
type (:#>) name fn = Data.Tagged.Tagged (FnName name) fn
type (:@>) :: Symbol -> * -> *
type (:@>) description fn = Data.Tagged.Tagged (FnDesc description) fn
type ArgName :: forall {k}. k -> Constraint
class ArgName a where argName :: Text
type ArgType :: forall {k}. k -> Constraint
class ArgType a where argType :: Text
type UnIdentity :: * -> *
type family UnIdentity a where UnIdentity (Identity x) = x UnIdentity x = x
type ArgTypeIs :: forall {k} {k1}. k -> k1 -> Constraint
class ArgTypeIs a x
type ArgDescription :: forall {k}. k -> Constraint
class ArgDescription a where argDescription :: Maybe Text
type IsFunction' :: * -> * -> Constraint
class IsFunction' t f where getFunction :: t -> f
type IsFunction :: * -> Constraint
class IsFunction' f f => IsFunction f
type FName' :: * -> * -> Constraint
class IsFunction' t f => FName' t f where fName :: Text default fName :: FName f => Text
type FName :: * -> Constraint
class FName' f f => FName f
type FDescription' :: * -> * -> Constraint
class IsFunction' t f => FDescription' t f where fDescription :: Maybe Text default fDescription :: FDescription f => Maybe Text
type FDescription :: * -> Constraint
class FDescription' f f => FDescription f
type ShowArg :: forall {k}. k -> Constraint
class (ArgName a, ArgType a, ArgDescription a) => ShowArg a where showArg :: Text showArgT :: Text default showArgT :: Text showArgD :: Text
type ShowArgKW :: forall {k} {k1}. k -> (k1 -> *) -> k1 -> Constraint
class (ShowArg a, ArgType a, ArgTypeIs a (g x)) => ShowArgKW a g x where showArgKW :: g x -> Text
parenArgs :: [Text] -> Text
parenLinesArgs :: [Text] -> Text
nameArgs :: FName' t f => Text -> Text
Quaalude.Encoding.JSON26Aeson deriving helpers: prefix stripping, omitted Nothing fields.
type JSONPrefixed :: forall {k}. k -> Constraint
class KnownSymbol (RemovePrefix a) => JSONPrefixed a where type RemovePrefix :: forall {k}. k -> Symbol type family RemovePrefix a
type role StripPrefixLowerFirst phantom
type StripPrefixLowerFirst :: forall {k}. k -> *
data StripPrefixLowerFirst t
type OmitNothingUntagged :: Symbol -> * -> *
type OmitNothingUntagged prefix = Deriving.Aeson.CustomJSON [Deriving.Aeson.OmitNothingFields, Deriving.Aeson.SumUntaggedValue] :: * -> *
type PrefixedCamel :: Symbol -> * -> *
type PrefixedCamel prefix = Deriving.Aeson.CustomJSON '[Deriving.Aeson.FieldLabelModifier (StripPrefixLowerFirst prefix)] :: * -> *
type PrefixedCamelOmitNothing :: Symbol -> * -> *
type PrefixedCamelOmitNothing prefix = Deriving.Aeson.CustomJSON [Deriving.Aeson.FieldLabelModifier (StripPrefixLowerFirst prefix), Deriving.Aeson.OmitNothingFields] :: * -> *
type PrefixedCamelOmitNothingUntagged :: Symbol -> * -> *
type PrefixedCamelOmitNothingUntagged prefix = Deriving.Aeson.CustomJSON [Deriving.Aeson.FieldLabelModifier (StripPrefixLowerFirst prefix), Deriving.Aeson.OmitNothingFields, Deriving.Aeson.SumUntaggedValue] :: * -> *
type PrefixedCamelRejectUnknown :: Symbol -> * -> *
type PrefixedCamelRejectUnknown prefix = Deriving.Aeson.CustomJSON [Deriving.Aeson.FieldLabelModifier (StripPrefixLowerFirst prefix), Deriving.Aeson.RejectUnknownFields] :: * -> *
type PrefixedCamelRejectUnknownOmitNothing :: Symbol -> * -> *
type PrefixedCamelRejectUnknownOmitNothing prefix = Deriving.Aeson.CustomJSON [Deriving.Aeson.FieldLabelModifier (StripPrefixLowerFirst prefix), Deriving.Aeson.RejectUnknownFields] :: * -> *
type PrefixedSnakeOmitNothing :: Symbol -> * -> *
type PrefixedSnakeOmitNothing prefix = Deriving.Aeson.CustomJSON [Deriving.Aeson.FieldLabelModifier [StripPrefixLowerFirst prefix, Deriving.Aeson.CamelToSnake], Deriving.Aeson.OmitNothingFields] :: * -> *
type PrefixedSnakeOmitNothingUntagged :: Symbol -> * -> *
type PrefixedSnakeOmitNothingUntagged prefix = Deriving.Aeson.CustomJSON [Deriving.Aeson.FieldLabelModifier [StripPrefixLowerFirst prefix, Deriving.Aeson.CamelToSnake], Deriving.Aeson.OmitNothingFields, Deriving.Aeson.SumUntaggedValue] :: * -> *
type PrefixedSnakeRejectUnknown :: Symbol -> * -> *
type PrefixedSnakeRejectUnknown prefix = Deriving.Aeson.CustomJSON [Deriving.Aeson.FieldLabelModifier [StripPrefixLowerFirst prefix, Deriving.Aeson.CamelToSnake], Deriving.Aeson.RejectUnknownFields] :: * -> *
type PrefixedSnakeRejectUnknownOmitNothing :: Symbol -> * -> *
type PrefixedSnakeRejectUnknownOmitNothing prefix = Deriving.Aeson.CustomJSON [Deriving.Aeson.FieldLabelModifier [StripPrefixLowerFirst prefix, Deriving.Aeson.CamelToSnake], Deriving.Aeson.RejectUnknownFields] :: * -> *
unsafeCoerceViaJSON :: (aeson-2.2.4.1:Data.Aeson.Types.ToJSON.ToJSON a, aeson-2.2.4.1:Data.Aeson.Types.FromJSON.FromJSON b) => a -> b
Quaalude.Encoding.JSON.Instances5JSON instances for the library's types.
tupleToJSON :: (aeson-2.2.4.1:Data.Aeson.Types.ToJSON.ToJSON a, TupSnoc u a t, aeson-2.2.4.1:Data.Aeson.Types.ToJSON.ToJSON t) => u -> aeson-2.2.4.1:Data.Aeson.Types.Internal.Value
tupleFromJSON :: (aeson-2.2.4.1:Data.Aeson.Types.FromJSON.FromJSON a, aeson-2.2.4.1:Data.Aeson.Types.FromJSON.FromJSON t, TupCons a t u) => aeson-2.2.4.1:Data.Aeson.Types.Internal.Value -> aeson-2.2.4.1:Data.Aeson.Types.Internal.Parser u
type role TaggedKV phantom representational
type TaggedKV :: forall {k}. k -> * -> *
newtype TaggedKV k1 v = TaggedKV {unTaggedKV :: Data.Tagged.Tagged k1 v}
Quaalude.Encoding.JSON.TH6Template Haskell for JSON instances.
deriveJSONPrefixed :: [Language.Haskell.TH.Syntax.Name] -> Language.Haskell.TH.Syntax.Q [Language.Haskell.TH.Syntax.Dec]
deriveJSONPrefixed' :: String -> [Language.Haskell.TH.Syntax.Name] -> Language.Haskell.TH.Syntax.Q [Language.Haskell.TH.Syntax.Dec]
deriveJSONVia :: ([Language.Haskell.TH.Syntax.Name] -> Language.Haskell.TH.Syntax.Q Language.Haskell.TH.Syntax.Type) -> [Language.Haskell.TH.Syntax.Name] -> Language.Haskell.TH.Syntax.Q [Language.Haskell.TH.Syntax.Dec]
deriveJSONRemovingPrefix' :: Language.Haskell.TH.Syntax.Name -> ([Language.Haskell.TH.Syntax.Name] -> Language.Haskell.TH.Syntax.Q [Language.Haskell.TH.Syntax.Dec]) -> [Language.Haskell.TH.Syntax.Name] -> Language.Haskell.TH.Syntax.Q [Language.Haskell.TH.Syntax.Dec]
deriveJSONSnakeRemovingPrefix :: Language.Haskell.TH.Syntax.Name -> Language.Haskell.TH.Syntax.Q [Language.Haskell.TH.Syntax.Dec]
deriveJSONCamelRemovingPrefix :: Language.Haskell.TH.Syntax.Name -> Language.Haskell.TH.Syntax.Q [Language.Haskell.TH.Syntax.Dec]
Quaalude.Geometry9Rectangles and line segments: intersection, subtraction, outlines.
type Box :: (* -> *) -> * -> Constraint
class Box f a where box :: (a, a) -> (a, a) -> f (a, a) box₀ :: (a, a) -> f (a, a) default box₀ :: Num a => (a, a) -> f (a, a)
linesSubtractLines :: [ℤ² × ℤ²] -> [ℤ² × ℤ²] -> [ℤ² × ℤ²]
lineSubtractLines :: [ℤ² × ℤ²] -> (ℤ² × ℤ²) -> [ℤ² × ℤ²]
lineSubtractLine :: (ℤ² × ℤ²) -> (ℤ² × ℤ²) -> [ℤ² × ℤ²]
intersectRectangles :: (ℤ² × ℤ²) -> (ℤ² × ℤ²) -> 𝔹
(□?□) :: (ℤ² × ℤ²) -> (ℤ² × ℤ²) -> 𝔹
turnOutside :: [ℤ² × ℤ²] -> Dir² -> Dir²
outside :: [ℤ² × ℤ²] -> [ℤ² × ℤ²]
Quaalude.Grid165The Griddable class over ten storage backends, pure and mutable; typed cells; reading, iterating, cropping and rotating grids.
emptyGrid :: Griddable Identity g k a => g k a
defGrid :: (Default a, Griddable Identity g k a) => [k] -> g k a
mkGrid :: Griddable Identity g k a => [(k, a)] -> g k a
unGrid :: Griddable Identity g k a => g k a -> [(k, a)]
coords :: Griddable Identity g k a => g k a -> [k]
cells :: Griddable Identity g k a => g k a -> [a]
gridGetMaybe :: Griddable Identity g k a => k -> g k a -> Maybe a
(||?) :: Griddable Identity g k a => g k a -> k -> Maybe a
gridGet :: Griddable Identity g k a => k -> g k a -> a
(||!) :: Griddable Identity g k a => g k a -> k -> a
gridSet :: Griddable Identity g k a => a -> k -> g k a -> g k a
(||.) :: Griddable Identity g k a => g k a -> (k, a) -> g k a
gridModify :: Griddable Identity g k a => (a -> a) -> k -> g k a -> g k a
(||~) :: Griddable Identity g k a => g k a -> (k, a -> a) -> g k a
maxXY :: Griddable Identity g k a => g k a -> k
minXY :: Griddable Identity g k a => g k a -> k
gridDims :: Griddable Identity g k a => g k a -> k
gridFind :: Griddable Identity g k a => a -> g k a -> [k]
gridFindOne :: Griddable Identity g k a => a -> g k a -> Maybe k
fromCoords :: (Foldable f, Bounded a, Griddable Identity g k a) => a -> f k -> g k a
fillDef :: Griddable Identity g k a => a -> g k a -> g k a
fillEmpty :: (Bounded a, Griddable Identity g k a) => g k a -> g k a
mapCoords :: Griddable Identity g k a => (k -> k) -> g k a -> g k a
filterCoords :: Griddable Identity g k a => (k -> Bool) -> g k a -> g k a
partitionCoords :: Griddable Identity g k a => (k -> Bool) -> g k a -> (g k a, g k a)
gridMember :: Griddable Identity g k a => k -> g k a -> Bool
type Griddable :: (* -> *) -> (* -> * -> *) -> * -> * -> Constraint
class (Monad m, Coord k, GridCell a) => Griddable m g k a where emptyGridM :: m (g k a) mkGridM :: [(k, a)] -> m (g k a) unGridM :: g k a -> m [(k, a)] coordsM :: g k a -> m [k] cellsM :: g k a -> m [a] gridGetMaybeM :: k -> g k a -> m (Maybe a) (<||?>) :: g k a -> k -> m (Maybe a) gridGetM :: k -> g k a -> m a (<||!>) :: g k a -> k -> m a gridSetM :: a -> k -> g k a -> m (g k a) (<||.>) :: g k a -> (k, a) -> m (g k a) gridModifyM :: (a -> a) -> k -> g k a -> m (g k a) (<||~>) :: g k a -> (k, a -> a) -> m (g k a) maxXYM :: g k a -> m k minXYM :: g k a -> m k gridDimsM :: g k a -> m k gridFindM :: a -> g k a -> m [k] gridFindOneM :: a -> g k a -> m (Maybe k) fromCoordsM :: (Foldable f, Bounded a) => a -> f k -> m (g k a) fillDefM :: a -> g k a -> m (g k a) fillEmptyM :: Bounded a => g k a -> m (g k a) mapCoordsM :: (k -> k) -> g k a -> m (g k a) filterCoordsM :: (k -> Bool) -> g k a -> m (g k a) partitionCoordsM :: (k -> Bool) -> g k a -> m (g k a, g k a) gridMemberM :: k -> g k a -> m Bool (<||∈>) :: k -> g k a -> m Bool (<||∉>) :: k -> g k a -> m Bool gridModifyM, maxXYM, minXYM #-}
type role ListGrid' phantom representational
type ListGrid' :: forall {k}. k -> * -> *
newtype ListGrid' k1 a = ListGrid {unListGrid :: [[a]]}
type ListGrid :: * -> *
type ListGrid a = ListGrid' Coord2 a
type role Grid' nominal representational
type Grid' :: * -> * -> *
newtype Grid' k a = Grid (Map k a)
type Grid :: * -> *
type Grid = Grid' Coord2 :: * -> *
type G :: * -> * -> *
type G = Grid' :: * -> * -> *
type PrettyGrid :: * -> *
newtype PrettyGrid g = PrettyGrid g
type role IntMapGrid' phantom representational
type IntMapGrid' :: forall {k}. k -> * -> *
newtype IntMapGrid' k1 a = IntMapGrid (IntMap (IntMap a))
type IntMapGrid :: * -> *
type IntMapGrid = IntMapGrid' Coord2 :: * -> *
type role HashGrid' nominal representational
type HashGrid' :: * -> * -> *
newtype HashGrid' k a = HashGrid (HashMap k a)
type HashGrid :: * -> *
type HashGrid = HashGrid' Coord2 :: * -> *
type role VectorGrid' phantom representational
type VectorGrid' :: forall {k}. k -> * -> *
newtype VectorGrid' k1 a = VectorGrid (Vector (Vector a))
type VectorGrid :: * -> *
type VectorGrid = VectorGrid' Coord2 :: * -> *
type role AGrid' nominal representational
type AGrid' :: * -> * -> *
newtype AGrid' k a = AGrid (ghc-internal-9.1003.0:GHC.Internal.Arr.Array k a)
type AGrid :: * -> *
type AGrid a = AGrid' Coord2 a
type role ArrayGrid' nominal representational
type ArrayGrid' :: * -> * -> *
newtype ArrayGrid' k a = ArrayGrid (ghc-internal-9.1003.0:GHC.Internal.IOArray.IOArray k a)
type ArrayGrid :: * -> *
type ArrayGrid a = ArrayGrid' Coord2 a
type role STUArrayGrid' nominal nominal nominal
type STUArrayGrid' :: * -> * -> * -> *
newtype STUArrayGrid' s k a = STUArrayGrid (Data.Array.Base.STUArray s k a)
type STUArrayGrid :: * -> * -> *
type STUArrayGrid s a = STUArrayGrid' s Coord2 a
type role STArrayGrid' nominal nominal representational
type STArrayGrid' :: * -> * -> * -> *
newtype STArrayGrid' s k a = STArrayGrid (ghc-internal-9.1003.0:GHC.Internal.Arr.STArray s k a)
type STArrayGrid :: * -> * -> *
type STArrayGrid s a = STArrayGrid' s Coord2 a
type role STVectorGrid' nominal phantom representational
type STVectorGrid' :: forall {k}. * -> k -> * -> *
newtype STVectorGrid' s k1 a = STVectorGrid (Data.Vector.Mutable.STVector s (Data.Vector.Mutable.STVector s a))
type STVectorGrid :: * -> * -> *
type STVectorGrid s a = STVectorGrid' s Coord2 a
type role IOVectorGrid' phantom representational
type IOVectorGrid' :: forall {k}. k -> * -> *
newtype IOVectorGrid' k1 a = IOVectorGrid (Data.Vector.Mutable.IOVector (Data.Vector.Mutable.IOVector a))
type IOVectorGrid :: * -> *
type IOVectorGrid a = IOVectorGrid' Coord2 a
type GridCell :: * -> Constraint
class Eq a => GridCell a where charMap :: Data.Bimap.Bimap a Char default charMap :: Ord a => Data.Bimap.Bimap a Char cs :: [(a, Char)] default cs :: [(a, Char)] fromChar :: Char -> a default fromChar :: Ord a => Char -> a toChar :: a -> Char default toChar :: Ord a => a -> Char
type EmptyCell :: * -> Constraint
class GridCell a => EmptyCell a where emptyCell :: a -> Bool
cellEmptyM :: (Griddable m g k a, EmptyCell a) => k -> g k a -> m Bool
cellEmpty :: (Griddable Identity g k a, EmptyCell a) => k -> g k a -> Bool
type DotHash :: *
data DotHash = Dot | Hash
type role Cell nominal
type Cell :: Symbol -> *
newtype Cell cs = Cell {unCell :: CharV cs}
mkC :: (SChar c :< SymSChars cs, KnownChar c) => Cell cs
(□) :: (SChar c :< SymSChars cs, KnownChar c) => SChar c -> Cell cs
type DigitCell :: *
newtype DigitCell = DigitCell (Data.Fin.Fin Nat10)
cellToInt :: DigitCell -> Integer
intToCell :: Int -> DigitCell
type IntCell :: *
newtype IntCell = IntCell Int
readGridM :: Griddable m g k a => Text -> m (g k a)
readGrid :: Griddable Identity g k a => Text -> g k a
toGridM :: Griddable m g k a => [Text] -> m (g k a)
toGrid :: Griddable Identity g k a => [Text] -> g k a
pointsM :: Griddable m g k a => [k] -> g k a -> m [a]
points :: Griddable Identity g k a => [k] -> g k a -> [a]
type IterGrid :: (* -> *) -> (* -> * -> *) -> * -> * -> * -> Constraint
class Griddable m g k a => IterGrid m g k d a where iterGridM' :: d -> g k a -> m [(k, a)] iterCoordsM' :: d -> g k a -> m [k] default iterCoordsM' :: d -> g k a -> m [k] iterCellsM' :: d -> g k a -> m [a] default iterCellsM' :: d -> g k a -> m [a]
iterGridM :: (IterGrid m g k d a, Default d) => g k a -> m [(k, a)]
iterCoordsM :: (IterGrid m g k d a, Default d) => g k a -> m [k]
iterCellsM :: (IterGrid m g k d a, Default d) => g k a -> m [a]
iterGrid' :: IterGrid Identity g k d a => d -> g k a -> [(k, a)]
iterGrid :: (IterGrid Identity g k d a, Default d) => g k a -> [(k, a)]
iterCoords' :: IterGrid Identity g k d a => d -> g k a -> [k]
iterCoords :: (IterGrid Identity g k d a, Default d) => g k a -> [k]
foldGridM' :: IterGrid m g k d a => d -> (acc -> (k, a) -> m acc) -> acc -> g k a -> m acc
foldGridM :: (IterGrid m g k d a, Default d) => (acc -> (k, a) -> m acc) -> acc -> g k a -> m acc
foldGrid :: (IterGrid Identity g k d a, Default d) => (acc -> (k, a) -> acc) -> acc -> g k a -> acc
foldCoordsM' :: IterGrid m g k d a => d -> (acc -> k -> m acc) -> acc -> g k a -> m acc
foldCoordsM :: (IterGrid m g k d a, Default d) => (acc -> k -> m acc) -> acc -> g k a -> m acc
foldCoords :: (IterGrid Identity g k d a, Default d) => (acc -> k -> acc) -> acc -> g k a -> acc
cropXM :: Griddable m g k a => Int -> Int -> g k a -> m (g k a)
cropX :: Griddable Identity g k a => Int -> Int -> g k a -> g k a
modifyCoordsM :: Griddable m g k a => (k -> k) -> g k a -> m (g k a)
modifyCoords :: Griddable Identity g k a => (k -> k) -> g k a -> g k a
variantsNubM :: (Griddable m g k a, Eq (g k a)) => g k a -> m [g k a]
variantsNub :: (Griddable Identity g k a, Eq (g k a)) => g k a -> [g k a]
rotations :: Griddable Identity g k a => g k a -> [g k a]
variantsM' :: Griddable m g k a => g k a -> m [g k a]
variants' :: Griddable Identity g k a => g k a -> [g k a]
type role Variants representational nominal nominal
type Variants :: forall {k} {k1}. (k -> k1 -> *) -> k -> k1 -> *
data Variants g k2 a = Variants {vId :: !(g k2 a), r90 :: !(g k2 a), r180 :: !(g k2 a), r270 :: !(g k2 a), h0 :: !(g k2 a), h90 :: !(g k2 a), h180 :: !(g k2 a), h270 :: !(g k2 a), v0 :: !(g k2 a), v90 :: !(g k2 a), v180 :: !(g k2 a), v270 :: !(g k2 a)}
variantsM :: Griddable m g k a => g k a -> m (Variants g k a)
variants :: Griddable Identity g k a => g k a -> Variants g k a
gridLinesM :: Griddable m g k a => g k a -> m [[a]]
gridLines :: Griddable Identity g k a => g k a -> [[a]]
prettyM :: Griddable m g k a => g k a -> m Text
pretty :: Griddable Identity g k a => g k a -> Text
convolve :: (Griddable Identity g Coord2 c, Griddable Identity g Coord2 d) => (Int, Int, Int, Int) -> (g Coord2 c -> d) -> g Coord2 c -> g Coord2 d
convolveWith :: (Griddable Identity g Coord2 c, Griddable Identity g Coord2 d) => (g Coord2 c -> g Coord2 c -> d) -> g Coord2 c -> g Coord2 c -> g Coord2 d
type GridPerimeter :: * -> *
data GridPerimeter k = GridPerimeter {pTop :: ![k], pRight :: ![k], pBottom :: ![k], pLeft :: ![k]}
pFrom :: GridPerimeter Coord2 -> Dir2 -> [Coord2]
gridPerimeterM :: Griddable m g Coord2 a => g Coord2 a -> m (GridPerimeter Coord2)
gridPerimeter :: Griddable Identity g Coord2 a => g Coord2 a -> GridPerimeter Coord2
type GridUnionable :: (* -> *) -> * -> Constraint
class GridUnionable g a where gridUnionL :: g a -> g a -> g a gridUnionR :: g a -> g a -> g a gridUnionWith :: (a -> a -> a) -> g a -> g a -> g a
type role MonoidalGrid representational nominal nominal nominal
type MonoidalGrid :: forall {k} {k1} {k2}. (k -> *) -> (k1 -> k2 -> k) -> k1 -> k2 -> *
newtype MonoidalGrid m g k3 a = MonoidalGrid {unMonoidalGrid :: m (g k3 a)}
idMonoidalGridSconcat :: forall {k1} {k2} (g :: k1 -> k2 -> *) (k3 :: k1) (a :: k2). Semigroup (MonoidalGrid Identity g k3 a) => g k3 a -> g k3 a -> g k3 a
idMonoidalGridMempty :: forall {k1} {k2} (g :: k1 -> k2 -> *) (k3 :: k1) (a :: k2). Monoid (MonoidalGrid Identity g k3 a) => g k3 a
wildEq :: (Eq k, Griddable Identity g k a, GridUnionable (g k) a) => a -> g k a -> g k a -> Bool
x_x :: (Eq k, Griddable Identity g k Char, GridUnionable (g k) Char) => g k Char -> g k Char -> Bool
type (▦) :: Symbol -> * -> *
type (▦) cs k = G k (Cell cs)
gridParseCanonical :: Griddable Identity g (CanonicalParseF k) (CanonicalParseF a) => Parser (g (CanonicalParseF k) (CanonicalParseF a))
traceGrid :: (Unable (g k), Griddable Identity g k a) => g k a -> p -> p
Quaalude.Lists42Heterogeneous lists and length-indexed homogeneous lists.
type Nothings :: [*] -> Constraint
class Nothings l where nothings :: HList l
type role HomList nominal representational
type HomList :: Nat -> * -> *
data HomList n a where HomNil :: HomList 0 a HomCons :: !a -> !(HomList (n - 1) a) -> HomList n a
type HomConsF :: * -> * -> *
type family HomConsF a b where HomConsF a a = HomList 2 a HomConsF a (HomList n a) = HomList (n + 1) a
type HomConsEvidenceF :: Natural -> * -> Constraint
type family HomConsEvidenceF n a where HomConsEvidenceF 2 a = HomConsF a a ~ HomList 2 a HomConsEvidenceF n (HomList n a) = (((n + 1) - 1) ~ n, HomConsF a (HomList n a) ~ HomList (n + 1) a)
type HomConsEvidenceC :: * -> Constraint
type family HomConsEvidenceC na where HomConsEvidenceC (SNat n, a) = HomConsEvidenceF n a
type HomConsEvidenceT :: * -> *
type family HomConsEvidenceT na
type HomConsEvidence :: Nat -> * -> Constraint
class HomConsEvidenceC (HomConsEvidenceT (SNat n, a)) => HomConsEvidence n a
type HomConsLHS :: * -> *
type family HomConsLHS b where HomConsLHS (HomList _1 a) = a HomConsLHS a = a
type NatSuccPred :: Natural -> Constraint
class (n ~ ((n + 1) - 1)) => NatSuccPred n
type HomConsC :: * -> Constraint
class HomConsC a where (~:~) :: NatSuccPred n => a -> HomList n a -> HomList (n + 1) a (~:|) :: a -> a -> HomList 2 a
type role Question phantom representational
type Question :: (* -> Constraint) -> * -> *
data Question c a = Question !a
type (:~:~) :: * -> * -> *
type (:~:~) a b = HomConsF a b
type ConstC :: forall k. (k -> Constraint) -> k -> Constraint
class ConstC cf a
type AllEqF :: * -> * -> Constraint
type family AllEqF a where AllEqF (HomList _1 _2) = ConstC AllEq
type (:≡) :: * -> * -> *
type family (:≡) a b where (:≡) a () = Question AllEq (HomList 1 a) (:≡) a (Question c (HomList n a)) = Question c (HomList (n + 1) a)
type AllEq :: * -> Constraint
class AllEq a where allEq :: a -> Bool
type QuestionResultF :: (* -> Constraint) -> *
type family QuestionResultF c where QuestionResultF AllEq = Bool
type RunQuestionC :: * -> Constraint
type family RunQuestionC q where RunQuestionC (Question c a) = c a
type RunQuestionF :: * -> *
type family RunQuestionF q where RunQuestionF (Question c a) = a -> QuestionResultF c
type RunQuestion :: * -> Constraint
class RunQuestion q where runQuestion :: RunQuestionC q => RunQuestionF q
Quaalude.LossQ16Priority queues ordered by a loss function, for best-first search.
type LossF :: * -> *
type family LossF a
type role LossFn nominal
type LossFn :: * -> *
data LossFn a = LossFn !(a -> LossF a)
type role LossQ nominal
type LossQ :: * -> *
data LossQ a where LossQ :: Ord (LossF a) => !(LossFn a) -> !(MinQ (LossF a) a) -> LossQ a
type role LossSet nominal
type LossSet :: * -> *
data LossSet a = LossSet !(Set a) !(LossQ a)
type IntLoss :: * -> Constraint
class IntLoss a where loss :: a -> Integer default loss :: Sizable a => a -> Integer
type role IntLossSet nominal
type IntLossSet :: * -> *
data IntLossSet a = IntLossSet !(Set a) !(MinQ Integer a)
Quaalude.Math34Digits, differences, sign, triangular numbers, mean and median.
diff :: Num a => a -> a -> a
diffs :: Num a => [a] -> [a]
type DiffList :: * -> *
data DiffList a = DiffList !(Seq a)
type MkDiffList :: * -> Constraint
class MkDiffList a where mkDiffList :: [a] -> DiffList a
diffListConcatVia :: MkDiffList a => DiffList a -> a -> a -> DiffList a -> DiffList a
sgn :: (Num a, Ord a) => a -> a
triangular :: Integral a => a -> a
median :: Ord a => [a] -> a
mean :: Integral a => [a] -> a
type ToDigit :: * -> * -> Constraint
class Integral n => ToDigit n a where toDigit :: a -> n
type FromDigit :: * -> * -> Constraint
class FromDigit n a where fromDigit :: n -> a
type ToDigits :: * -> * -> Constraint
class Integral n => ToDigits n a where toDigits :: a -> [n]
type FromDigits :: * -> * -> Constraint
class Integral n => FromDigits n a where fromDigits :: [n] -> a
type OverDigits :: * -> * -> Constraint
class (ToDigits n a, FromDigits n a) => OverDigits n a where overDigits :: ([n] -> [n]) -> a -> a overDigits2 :: ([n] -> [n] -> [n]) -> a -> a -> a
type ToDecimal :: * -> * -> Constraint
class ToDigits n a => ToDecimal n a where toDecimal :: a -> n
type FromDecimal :: * -> * -> Constraint
class FromDigits n a => FromDecimal n a where fromDecimal :: n -> a
type OverDecimal :: * -> * -> Constraint
class (ToDecimal n a, FromDecimal n a) => OverDecimal n a where overDecimal :: (n -> n) -> a -> a overDecimal2 :: (n -> n -> n) -> a -> a -> a
type role Dec phantom representational
type Dec :: forall {k}. k -> * -> *
newtype Dec n a = Dec {unDec :: a}
type Dℤ :: * -> *
type Dℤ = Dec ℤ :: * -> *
decDigit :: Integral n => n -> n -> n
showDP :: (Integral i, Floating n, RealFrac n, IsString s, Show n) => i -> n -> s
Quaalude.MaxSet3A set that keeps track of its maximum.
type role MaxSet nominal
type MaxSet :: * -> *
data MaxSet a = MaxSet !a !(Set a)
Quaalude.Megaparsec4A Megaparsec parser type and helpers such as parseMatches.
type MParser :: * -> *
type MParser a = Text.Megaparsec.Parsec Void String a
parserM :: (Text.Megaparsec.Stream.Stream s, Ord e) => Text.Megaparsec.Parsec e s a -> s -> a
parseMatches :: MParser a -> String -> [a]
Quaalude.QuasiSet3A wrapper that treats a container as a set.
type role QuasiSet representational nominal
type QuasiSet :: forall {k}. (k -> *) -> k -> *
data QuasiSet f a = QuasiSet !(f a)
Quaalude.Records8HList record helpers: prefix stripping and record conversion.
dropPrefix :: String -> String -> String
snakeCaseNoPrefix :: String -> String -> String
type UnRecord :: * -> [*]
type family UnRecord record where UnRecord (Data.HList.Record.Record r) = r UnRecord e = (TypeError ...)
type NothingsR :: [*] -> Constraint
class NothingsR l where nothingsR :: Data.HList.Record.Record l
type ConvertRecord :: [*] -> [*] -> Constraint
class NothingsR to => ConvertRecord from to where convertRecord :: Data.HList.Record.Record from -> Data.HList.Record.Record to default convertRecord :: (from ~ to) => Data.HList.Record.Record from -> Data.HList.Record.Record to
Quaalude.Reducible60Type-level machinery that reduces curried functions to a terminal value.
type Reduced :: * -> *
data Reduced f where Reduced :: !f -> Reduced f
type Terminal :: * -> *
newtype Terminal b = Terminal {unTerminal :: b}
type ReducedF :: * -> *
type family ReducedF f where ReducedF (f :@ d) = ReducedF f :@ d ReducedF (Reduced f) = Reduced f ReducedF (Terminal b) = Terminal b forall (t :: ghc-prim-0.12.0:GHC.Types.RuntimeRep) (a :: TYPE t) b. ReducedF (a -> b) = Reduced (a -> ReducedF b) ReducedF b = Terminal b
type Reducible :: * -> Constraint
class Reducible f where reduce :: f -> ReducedF f
type StripDescriptionsF :: * -> *
type family StripDescriptionsF f where StripDescriptionsF (f :@ _1) = StripDescriptionsF f StripDescriptionsF (Reduced f) = Reduced (StripDescriptionsF f) StripDescriptionsF ((a :@ _1) -> b) = a -> StripDescriptionsF b StripDescriptionsF b = b
type StripDescriptions :: * -> Constraint
class StripDescriptions f where stripDescriptions :: f -> StripDescriptionsF f default stripDescriptions :: (f ~ StripDescriptionsF f) => f -> StripDescriptionsF f
type ArgL :: * -> [*]
type family ArgL f where ArgL (Reduced (a -> b)) = a : ArgL b forall (t1 :: ghc-prim-0.12.0:GHC.Types.RuntimeRep) (t2 :: ghc-prim-0.12.0:GHC.Types.RuntimeRep) (a :: TYPE t1) (b :: TYPE t2). ArgL (a -> b) = ArgL (ReducedF (a -> b)) ArgL _1 = '[]
type CurryF :: * -> *
type family CurryF f where CurryF (HList '[] -> b) = b forall (t :: ghc-prim-0.12.0:GHC.Types.RuntimeRep) a (b :: [*]) (c :: TYPE t). CurryF (HList (a : b) -> c) = a -> CurryF (HList b -> c)
type UncurryF :: * -> *
type UncurryF f = HList (ArgL f) -> ReturnF f
type CurryHList :: * -> Constraint
class CurryHList f where uncurryHList :: f -> UncurryF f default uncurryHList :: (CurryHList (ReducedF f), Reducible f, UncurryF f ~ UncurryF (ReducedF f)) => f -> UncurryF f curryHList :: UncurryF f -> f
type ArgR :: * -> [*]
type family ArgR f where forall (t :: ghc-prim-0.12.0:GHC.Types.RuntimeRep) (_1 :: Symbol) a (b :: TYPE t). ArgR (Reduced ((a :@ _1) -> b)) = ArgR (Reduced (a -> b)) ArgR (Reduced (Named.Internal.NamedF g a name -> b)) = Data.Tagged.Tagged name (g a) : ArgR b ArgR (Terminal _1) = '[] ArgR (f :@ _1) = ArgR f forall (t1 :: ghc-prim-0.12.0:GHC.Types.RuntimeRep) (t2 :: ghc-prim-0.12.0:GHC.Types.RuntimeRep) (a :: TYPE t1) (b :: TYPE t2). ArgR (a -> b) = ArgR (ReducedF (a -> b)) ArgR _1 = '[]
type HasArg :: forall {k}. * -> k -> * -> Constraint
type HasArg f name v = Data.HList.Record.HasField name (Data.HList.Record.Record (ArgR f)) v :: Constraint
type RequiredArgs :: * -> Constraint
class Reducible f => RequiredArgs f where requiredArgs :: [String] default requiredArgs :: RequiredArgs (ReducedF f) => [String] requiredArgs' :: f -> [String]
type ReturnF :: * -> *
type family ReturnF f where forall (t :: ghc-prim-0.12.0:GHC.Types.RuntimeRep) (_1 :: TYPE t) b. ReturnF (Reduced (_1 -> b)) = ReturnF b ReturnF (Terminal b) = b ReturnF f = ReturnF (ReducedF f)
type Return :: * -> * -> Constraint
class (ReturnF f ~ out) => Return f out where returnF :: Proxy out default returnF :: Return (ReducedF f) out => Proxy out returnF' :: f -> Proxy out
type AppArgR :: * -> [*] -> * -> Constraint
class AppArgR f argR out where appArgR :: f -> Data.HList.Record.Record argR -> out
type ShowArgR :: [*] -> Constraint
class ShowArgR a where showArgR' :: [Text] showArgR :: Text showArgRT' :: [Text] showArgRT :: Text showArgRD' :: [Text] showArgRD :: Text
type ShowArgRKW :: [*] -> Constraint
class ShowArgRKW a where showArgRKW' :: Data.HList.Record.Record a -> [Text] showArgRKW :: Data.HList.Record.Record a -> Text
type ShowArgs :: * -> Constraint
class ShowArgR (ArgR f) => ShowArgs f where showArgs :: Text showArgs' :: f -> Text showArgsT :: Text showArgsT' :: f -> Text showArgsD :: Text showArgsD' :: f -> Text
type ShowArgsKW :: * -> Constraint
class ShowArgRKW (ArgR f) => ShowArgsKW f where showArgsKW :: Data.HList.Record.Record (ArgR f) -> Text
type ShowReturn :: * -> Constraint
class Typeable (ReturnF f) => ShowReturn f where showReturn :: Text showReturn' :: f -> Text
nameArgsReturns :: (FName' t f, ShowReturn f) => Text -> Text
nameArgsValue :: (FName' t f, Show x) => Text -> x -> Text
type ShowF' :: * -> * -> Constraint
class (IsFunction' t f, FName' t f, ShowArgs f, ShowReturn f) => ShowF' t f where showF :: Text showF' :: f -> Text showFT :: Text showFT' :: f -> Text
type ShowF :: * -> Constraint
class ShowF' f f => ShowF f
type ShowFD' :: * -> * -> Constraint
class (IsFunction' t f, FName' t f, FDescription' t f, ShowArgs f, ShowReturn f) => ShowFD' t f where showFD :: Text showFD' :: f -> Text
type ShowFD :: * -> Constraint
class ShowFD' f f => ShowFD f
type ShowFKW' :: * -> * -> Constraint
class (IsFunction' t f, FName' t f, ShowArgsKW f) => ShowFKW' t f where showFKW :: Data.HList.Record.Record (ArgR f) -> Text showFKW' :: f -> Data.HList.Record.Record (ArgR f) -> Text
type ShowFKW :: * -> Constraint
class ShowFKW' f f => ShowFKW f
type ShowFKWR' :: * -> * -> Constraint
class (IsFunction' t f, FName' t f, ShowArgsKW f) => ShowFKWR' t f where showFKWR :: Data.HList.Record.Record (ArgR f) -> Text -> Text
type ShowFKWR :: * -> Constraint
class ShowFKWR' f f => ShowFKWR f
Quaalude.Shape18Shapes as sets of cells with their bounds, for falling-block and tiling puzzles.
type role Shape nominal
type Shape :: * -> *
data Shape a where EmptyShape :: Shape a Invalid :: Shape a Shape :: (Ord a, MkDiffList a) => !(Seq a) -> !(Set a) -> !(DiffList a) -> !(a, a) -> Shape a
type ShapeLikeC :: (* -> *) -> * -> Constraint
type ShapeLikeC s i = (Show i, Integral i, Coord' i i (i, i), Semigroup (s (i, i)), Monoid (s (i, i))) :: Constraint
type ShapeLike :: (* -> *) -> * -> Constraint
class ShapeLike s i where mkShape :: (Foldable m, Unable m) => m (i, i) -> s (i, i) validShape :: (i, i) -> s (i, i) -> 𝔹 boundedShape :: (i, i) -> s (i, i) -> 𝔹 shapeWH :: s (i, i) -> (i, i) offsetShape :: (i, i) -> s (i, i) -> s (i, i) (⇆⇅) :: s (i, i) -> (i, i) -> s (i, i) (⇆) :: s (i, i) -> i -> s (i, i) default (⇆) :: Num i => s (i, i) -> i -> s (i, i) (⇅) :: s (i, i) -> i -> s (i, i) default (⇅) :: Num i => s (i, i) -> i -> s (i, i) area :: (a ~ (i, i)) => s (i, i) -> i contiguous :: s (i, i) -> 𝔹 offsetShape, area, contiguous #-}
toG :: (Integral i, Eq (s (i, i)), Memberable (i, i) (s (i, i)), Foldable s, Monoid (s (i, i)), Sizable (s (i, i)), Coord' i i (i, i), ShapeLike s i) => s (i, i) -> ".#X" ▦ (i, i)
showShape :: (Integral i, Eq (s (i, i)), Memberable (i, i) (s (i, i)), Foldable s, Monoid (s (i, i)), Sizable (s (i, i)), Coord' i i (i, i), ShapeLike s i) => s (i, i) -> Text
showShapes :: (Integral i, Eq (s (i, i)), Memberable (i, i) (s (i, i)), Foldable s, Monoid (s (i, i)), Sizable (s (i, i)), Coord' i i (i, i), ShapeLike s i) => [s (i, i)] -> Text
showShapess :: (Integral i, Eq (s (i, i)), Memberable (i, i) (s (i, i)), Foldable s, Monoid (s (i, i)), Sizable (s (i, i)), Coord' i i (i, i), ShapeLike s i) => [[s (i, i)]] -> Text
traceShape :: (Integral i, Eq (s (i, i)), Memberable (i, i) (s (i, i)), Foldable s, Monoid (s (i, i)), Sizable (s (i, i)), Coord' i i (i, i), ShapeLike s i) => s (i, i) -> b -> b
traceShapeId :: (Integral i, Eq (s (i, i)), Memberable (i, i) (s (i, i)), Foldable s, Monoid (s (i, i)), Sizable (s (i, i)), Coord' i i (i, i), ShapeLike s i) => s (i, i) -> s (i, i)
traceShapeLabelled :: (Integral i, Eq (s (i, i)), Memberable (i, i) (s (i, i)), Foldable s, Monoid (s (i, i)), Sizable (s (i, i)), Coord' i i (i, i), ShapeLike s i, Show t) => t -> s (i, i) -> a -> a
traceShapeIdLabelled :: (Integral i, Eq (s (i, i)), Memberable (i, i) (s (i, i)), Foldable s, Monoid (s (i, i)), Sizable (s (i, i)), Coord' i i (i, i), ShapeLike s i, Show t) => t -> s (i, i) -> s (i, i)
type role LossShape nominal
type LossShape :: * -> *
data LossShape a = LossShape {unLossShape :: !(Shape a)}
Quaalude.Show0Show instances, such as arrows for directions.

Instances only.

Quaalude.Solve37Z3 from Haskell: solve and minimize, with results extracted by type.
z3 :: Z3 a -> a
z3IO :: MonadIO m => Z3 a -> m a
type Z3SolverF :: * -> *
type family Z3SolverF a where Z3SolverF [a] = [Z3SolverF a] Z3SolverF (Σ a) = [Z3SolverF a] Z3SolverF a = a
type Z3Solver :: * -> Constraint
class Z3Solver a where eval1 :: Z3.Base.Model -> Z3.Base.AST -> Z3 (Maybe (Z3SolverF a))
type SolveForF :: * -> *
type family SolveForF a where SolveForF [_1] = [Z3.Base.AST] SolveForF (Σ _1) = [Z3.Base.AST] SolveForF (a, b) = (SolveForF a, SolveForF b) SolveForF _1 = Z3.Base.AST
type Minimize :: * -> * -> Constraint
class (Integral i, SolveFor i, SolveFor a) => Minimize i a where minimize :: String -> Z3 (SolveForF i, SolveForF a) -> Z3 (Maybe (i, a))
type SolveFor :: * -> Constraint
class SolveFor a where solve :: SolveForF a -> Z3 (Maybe a)
z3WithModel :: (Applicative z3, Z3.Monad.MonadZ3 z3) => (Z3.Base.Model -> z3 a) -> z3 (Z3.Base.Result, Maybe a)
traceModel :: Z3.Base.Model -> Z3 a -> Z3 a
printModel :: Z3.Base.Model -> Z3 ()
printAST :: Z3.Base.AST -> Z3 ()
fromZ3Maybe :: Maybe a -> a
z3Check :: Z3 Z3.Base.Result
z3EvalInt :: Z3.Monad.MonadZ3 z3 => Z3.Monad.EvalAst z3 Integer
z3EvalReal :: Z3.Monad.MonadZ3 z3 => Z3.Monad.EvalAst z3 Rational
z3EvalBool :: Z3.Monad.MonadZ3 z3 => Z3.Monad.EvalAst z3 Bool
z3Rational :: Z3.Monad.MonadZ3 z3 => Rational -> z3 Z3.Base.AST
z3Int :: Z3.Monad.MonadZ3 z3 => Integer -> z3 Z3.Base.AST
z3Bool :: Z3.Monad.MonadZ3 z3 => Bool -> z3 Z3.Base.AST
z3RealVar' :: Z3.Monad.MonadZ3 z3 => Z3.Base.Symbol -> z3 Z3.Base.AST
z3IntVar' :: Z3.Monad.MonadZ3 z3 => Z3.Base.Symbol -> z3 Z3.Base.AST
z3BoolVar' :: Z3.Monad.MonadZ3 z3 => Z3.Base.Symbol -> z3 Z3.Base.AST
z3RealVar :: Z3.Monad.MonadZ3 z3 => String -> z3 Z3.Base.AST
z3IntVar :: Z3.Monad.MonadZ3 z3 => String -> z3 Z3.Base.AST
z3BoolVar :: Z3.Monad.MonadZ3 z3 => String -> z3 Z3.Base.AST
z3Add :: Z3.Monad.MonadZ3 z3 => [Z3.Base.AST] -> z3 Z3.Base.AST
z3Sub :: Z3.Monad.MonadZ3 z3 => [Z3.Base.AST] -> z3 Z3.Base.AST
z3Eq :: Z3.Monad.MonadZ3 z3 => Z3.Base.AST -> Z3.Base.AST -> z3 Z3.Base.AST
z3Gt :: Z3.Monad.MonadZ3 z3 => Z3.Base.AST -> Z3.Base.AST -> z3 Z3.Base.AST
z3Ge :: Z3.Monad.MonadZ3 z3 => Z3.Base.AST -> Z3.Base.AST -> z3 Z3.Base.AST
z3And :: Z3.Monad.MonadZ3 z3 => [Z3.Base.AST] -> z3 Z3.Base.AST
z3Assert :: Z3.Monad.MonadZ3 z3 => Z3.Base.AST -> z3 ()
Quaalude.TH22Compile-time embedding of puzzle input and examples (aoc, grid, …) and runners for every day.
runAllDays :: Language.Haskell.TH.Syntax.Q Language.Haskell.TH.Syntax.Exp
runAllDays' :: Integral n => n -> Language.Haskell.TH.Syntax.Q Language.Haskell.TH.Syntax.Exp
type EmbedInput :: * -> Constraint
class EmbedInput a where input :: a -> Language.Haskell.TH.Syntax.Q Language.Haskell.TH.Syntax.Exp
grid :: Int -> Language.Haskell.TH.Syntax.Q Language.Haskell.TH.Syntax.Exp
gridx :: Int -> Language.Haskell.TH.Syntax.Q Language.Haskell.TH.Syntax.Exp
aoc :: Int -> Language.Haskell.TH.Syntax.Q Language.Haskell.TH.Syntax.Exp
aocx :: Int -> Language.Haskell.TH.Syntax.Q Language.Haskell.TH.Syntax.Exp
aocxn :: Int -> Int -> Language.Haskell.TH.Syntax.Q Language.Haskell.TH.Syntax.Exp
type Example :: *
data Example = Example !Int | ExampleN !Int !Int
inputS :: EmbedInput a => a -> Language.Haskell.TH.Syntax.Q Language.Haskell.TH.Syntax.Exp
gridsT :: (Griddable Identity g k a, Packable t Text) => t -> [g k a]
grids :: (Int -> Language.Haskell.TH.Syntax.Q Language.Haskell.TH.Syntax.Exp) -> Int -> Language.Haskell.TH.Syntax.Q Language.Haskell.TH.Syntax.Exp
gridM :: (Int -> Language.Haskell.TH.Syntax.Q Language.Haskell.TH.Syntax.Exp) -> Int -> Language.Haskell.TH.Syntax.Q Language.Haskell.TH.Syntax.Exp
gridsTM :: (Griddable m g k a, Packable t Text) => t -> m [g k a]
gridsM :: (Int -> Language.Haskell.TH.Syntax.Q Language.Haskell.TH.Syntax.Exp) -> Int -> Language.Haskell.TH.Syntax.Q Language.Haskell.TH.Syntax.Exp
fileLine :: Language.Haskell.TH.Syntax.Q Language.Haskell.TH.Syntax.Exp
getJsonPrefix :: [Language.Haskell.TH.Syntax.Name] -> Language.Haskell.TH.Syntax.Q String
stringToSymbol :: String -> Language.Haskell.TH.Syntax.Q Language.Haskell.TH.Syntax.Type
joinNames :: [Language.Haskell.TH.Syntax.Name] -> Language.Haskell.TH.Syntax.Q Language.Haskell.TH.Syntax.Type
nameSuffix :: Language.Haskell.TH.Syntax.Name -> String -> Language.Haskell.TH.Syntax.Name
Quaalude.Tracers20Debug.Trace variants: conditional, prefixed, animated, and tracing inside parsers.
pauseId :: a -> a
traceStrLn :: String -> a -> a
traceStrLnId :: Show a => a -> a
traceTextLn :: Text -> a -> a
traceTextLnId :: Show a => a -> a
traceWhen :: Bool -> (a -> a) -> a -> a
traceShowIdWhen :: Show a => (a -> Bool) -> a -> a
traceUnless :: Bool -> (a -> a) -> a -> a
traceShowF :: Show b => (a -> b) -> a -> a
traceTextF :: (a -> Text) -> a -> a
ptrace' :: Bool -> String -> Parser a -> Parser a
ptrace :: Parser a -> Parser a
traceAnim :: Show a => Double -> a -> b -> b
traceStack :: Text -> a -> a
traceStackId :: a -> a
traceIf :: Bool -> String -> a -> a
tracePrefixId :: (Show a, Show b) => a -> b -> b
tracePrefixIdM :: (Monad m, Show a, Show b) => a -> m b -> m b
traceN :: Foldable t => (a -> p -> p) -> t a -> p -> p
traceNId :: Foldable t => (a -> t a -> t a) -> t a -> t a
Quaalude.Tuple73Tuple construction, access and uncurried application for large arities ($@, dup, …).
type TupConsF :: * -> * -> *
type family TupConsF a as where TupConsF a () = Solo a TupConsF a (Solo b) = (a, b) TupConsF a (b, c) = (a, b, c) TupConsF a (b, c, d) = (a, b, c, d) TupConsF a (b, c, d, e) = (a, b, c, d, e) TupConsF a (b, c, d, e, f) = (a, b, c, d, e, f) TupConsF a (b, c, d, e, f, g) = (a, b, c, d, e, f, g) TupConsF a (b, c, d, e, f, g, h) = (a, b, c, d, e, f, g, h) TupConsF a (b, c, d, e, f, g, h, i) = (a, b, c, d, e, f, g, h, i) TupConsF a (b, c, d, e, f, g, h, i, j) = (a, b, c, d, e, f, g, h, i, j) TupConsF a (b, c, d, e, f, g, h, i, j, k) = (a, b, c, d, e, f, g, h, i, j, k) TupConsF a (b, c, d, e, f, g, h, i, j, k, l) = (a, b, c, d, e, f, g, h, i, j, k, l) TupConsF a (b, c, d, e, f, g, h, i, j, k, l, m) = (a, b, c, d, e, f, g, h, i, j, k, l, m) TupConsF a (b, c, d, e, f, g, h, i, j, k, l, m, n) = (a, b, c, d, e, f, g, h, i, j, k, l, m, n) TupConsF a (b, c, d, e, f, g, h, i, j, k, l, m, n, o) = (a, b, c, d, e, f, g, h, i, j, k, l, m, n, o) TupConsF a (b, c, d, e, f, g, h, i, j, k, l, m, n, o, p) = (a, b, c, d, e, f, g, h, i, j, k, l, m, n, o, p) TupConsF a (b, c, d, e, f, g, h, i, j, k, l, m, n, o, p, q) = (a, b, c, d, e, f, g, h, i, j, k, l, m, n, o, p, q) TupConsF a (b, c, d, e, f, g, h, i, j, k, l, m, n, o, p, q, r) = (a, b, c, d, e, f, g, h, i, j, k, l, m, n, o, p, q, r) TupConsF a (b, c, d, e, f, g, h, i, j, k, l, m, n, o, p, q, r, s) = (a, b, c, d, e, f, g, h, i, j, k, l, m, n, o, p, q, r, s) TupConsF a (b, c, d, e, f, g, h, i, j, k, l, m, n, o, p, q, r, s, t) = (a, b, c, d, e, f, g, h, i, j, k, l, m, n, o, p, q, r, s, t) TupConsF a (b, c, d, e, f, g, h, i, j, k, l, m, n, o, p, q, r, s, t, u) = (a, b, c, d, e, f, g, h, i, j, k, l, m, n, o, p, q, r, s, t, u) TupConsF a (b, c, d, e, f, g, h, i, j, k, l, m, n, o, p, q, r, s, t, u, v) = (a, b, c, d, e, f, g, h, i, j, k, l, m, n, o, p, q, r, s, t, u, v) TupConsF a (b, c, d, e, f, g, h, i, j, k, l, m, n, o, p, q, r, s, t, u, v, w) = (a, b, c, d, e, f, g, h, i, j, k, l, m, n, o, p, q, r, s, t, u, v, w) TupConsF a (b, c, d, e, f, g, h, i, j, k, l, m, n, o, p, q, r, s, t, u, v, w, x) = (a, b, c, d, e, f, g, h, i, j, k, l, m, n, o, p, q, r, s, t, u, v, w, x) TupConsF a (b, c, d, e, f, g, h, i, j, k, l, m, n, o, p, q, r, s, t, u, v, w, x, y) = (a, b, c, d, e, f, g, h, i, j, k, l, m, n, o, p, q, r, s, t, u, v, w, x, y) TupConsF a (b, c, d, e, f, g, h, i, j, k, l, m, n, o, p, q, r, s, t, u, v, w, x, y, z) = (a, b, c, d, e, f, g, h, i, j, k, l, m, n, o, p, q, r, s, t, u, v, w, x, y, z) TupConsF a b = (a, b)
type (×) :: * -> * -> *
type (×) a b = (a, b)
type TupCons :: * -> * -> * -> Constraint
class TupCons a b c where tupCons :: a -> b -> c
type TupSnocF :: * -> *
type family TupSnocF a where TupSnocF () = (TypeError ...) TupSnocF (Solo a) = (a, ()) TupSnocF (a, b) = (a, Solo b) TupSnocF (a, b, c) = (a, (b, c)) TupSnocF (a, b, c, d) = (a, (b, c, d)) TupSnocF (a, b, c, d, e) = (a, (b, c, d, e)) TupSnocF (a, b, c, d, e, f) = (a, (b, c, d, e, f)) TupSnocF (a, b, c, d, e, f, g) = (a, (b, c, d, e, f, g)) TupSnocF (a, b, c, d, e, f, g, h) = (a, (b, c, d, e, f, g, h)) TupSnocF (a, b, c, d, e, f, g, h, i) = (a, (b, c, d, e, f, g, h, i)) TupSnocF (a, b, c, d, e, f, g, h, i, j) = (a, (b, c, d, e, f, g, h, i, j)) TupSnocF (a, b, c, d, e, f, g, h, i, j, k) = (a, (b, c, d, e, f, g, h, i, j, k)) TupSnocF (a, b, c, d, e, f, g, h, i, j, k, l) = (a, (b, c, d, e, f, g, h, i, j, k, l)) TupSnocF (a, b, c, d, e, f, g, h, i, j, k, l, m) = (a, (b, c, d, e, f, g, h, i, j, k, l, m)) TupSnocF (a, b, c, d, e, f, g, h, i, j, k, l, m, n) = (a, (b, c, d, e, f, g, h, i, j, k, l, m, n)) TupSnocF (a, b, c, d, e, f, g, h, i, j, k, l, m, n, o) = (a, (b, c, d, e, f, g, h, i, j, k, l, m, n, o)) TupSnocF (a, b, c, d, e, f, g, h, i, j, k, l, m, n, o, p) = (a, (b, c, d, e, f, g, h, i, j, k, l, m, n, o, p)) TupSnocF (a, b, c, d, e, f, g, h, i, j, k, l, m, n, o, p, q) = (a, (b, c, d, e, f, g, h, i, j, k, l, m, n, o, p, q)) TupSnocF (a, b, c, d, e, f, g, h, i, j, k, l, m, n, o, p, q, r) = (a, (b, c, d, e, f, g, h, i, j, k, l, m, n, o, p, q, r)) TupSnocF (a, b, c, d, e, f, g, h, i, j, k, l, m, n, o, p, q, r, s) = (a, (b, c, d, e, f, g, h, i, j, k, l, m, n, o, p, q, r, s)) TupSnocF (a, b, c, d, e, f, g, h, i, j, k, l, m, n, o, p, q, r, s, t) = (a, (b, c, d, e, f, g, h, i, j, k, l, m, n, o, p, q, r, s, t)) TupSnocF (a, b, c, d, e, f, g, h, i, j, k, l, m, n, o, p, q, r, s, t, u) = (a, (b, c, d, e, f, g, h, i, j, k, l, m, n, o, p, q, r, s, t, u)) TupSnocF (a, b, c, d, e, f, g, h, i, j, k, l, m, n, o, p, q, r, s, t, u, v) = (a, (b, c, d, e, f, g, h, i, j, k, l, m, n, o, p, q, r, s, t, u, v)) TupSnocF (a, b, c, d, e, f, g, h, i, j, k, l, m, n, o, p, q, r, s, t, u, v, w) = (a, (b, c, d, e, f, g, h, i, j, k, l, m, n, o, p, q, r, s, t, u, v, w)) TupSnocF (a, b, c, d, e, f, g, h, i, j, k, l, m, n, o, p, q, r, s, t, u, v, w, x) = (a, (b, c, d, e, f, g, h, i, j, k, l, m, n, o, p, q, r, s, t, u, v, w, x)) TupSnocF (a, b, c, d, e, f, g, h, i, j, k, l, m, n, o, p, q, r, s, t, u, v, w, x, y) = (a, (b, c, d, e, f, g, h, i, j, k, l, m, n, o, p, q, r, s, t, u, v, w, x, y)) TupSnocF (a, b, c, d, e, f, g, h, i, j, k, l, m, n, o, p, q, r, s, t, u, v, w, x, y, z) = (a, (b, c, d, e, f, g, h, i, j, k, l, m, n, o, p, q, r, s, t, u, v, w, x, y, z))
type TupSnoc :: * -> * -> * -> Constraint
class TupSnoc a head tail where tupSnoc :: a -> (head, tail)
type TupFstF :: * -> *
type family TupFstF a where TupFstF () = (TypeError ...) TupFstF (Solo a) = a TupFstF (a, b) = a TupFstF (a, b, c) = a TupFstF (a, b, c, d) = a TupFstF (a, b, c, d, e) = a TupFstF (a, b, c, d, e, f) = a TupFstF (a, b, c, d, e, f, g) = a TupFstF (a, b, c, d, e, f, g, h) = a TupFstF (a, b, c, d, e, f, g, h, i) = a TupFstF (a, b, c, d, e, f, g, h, i, j) = a TupFstF (a, b, c, d, e, f, g, h, i, j, k) = a TupFstF (a, b, c, d, e, f, g, h, i, j, k, l) = a TupFstF (a, b, c, d, e, f, g, h, i, j, k, l, m) = a TupFstF (a, b, c, d, e, f, g, h, i, j, k, l, m, n) = a TupFstF (a, b, c, d, e, f, g, h, i, j, k, l, m, n, o) = a TupFstF (a, b, c, d, e, f, g, h, i, j, k, l, m, n, o, p) = a TupFstF (a, b, c, d, e, f, g, h, i, j, k, l, m, n, o, p, q) = a TupFstF (a, b, c, d, e, f, g, h, i, j, k, l, m, n, o, p, q, r) = a TupFstF (a, b, c, d, e, f, g, h, i, j, k, l, m, n, o, p, q, r, s) = a TupFstF (a, b, c, d, e, f, g, h, i, j, k, l, m, n, o, p, q, r, s, t) = a TupFstF (a, b, c, d, e, f, g, h, i, j, k, l, m, n, o, p, q, r, s, t, u) = a TupFstF (a, b, c, d, e, f, g, h, i, j, k, l, m, n, o, p, q, r, s, t, u, v) = a TupFstF (a, b, c, d, e, f, g, h, i, j, k, l, m, n, o, p, q, r, s, t, u, v, w) = a TupFstF (a, b, c, d, e, f, g, h, i, j, k, l, m, n, o, p, q, r, s, t, u, v, w, x) = a TupFstF (a, b, c, d, e, f, g, h, i, j, k, l, m, n, o, p, q, r, s, t, u, v, w, x, y) = a TupFstF (a, b, c, d, e, f, g, h, i, j, k, l, m, n, o, p, q, r, s, t, u, v, w, x, y, z) = a
type TupFst :: * -> Constraint
class TupFst a where tupFst :: a -> TupFstF a
type TupNthF :: Natural -> * -> *
type family TupNthF n a where TupNthF 0 a = TupFstF a TupNthF n a = TupNthF (n - 1) (TupTailF a)
type TupNth :: Natural -> * -> Constraint
class TupNth n a where tupNth :: a -> TupNthF n a
type TupHeadF :: * -> *
type family TupHeadF a where TupHeadF () = (TypeError ...) TupHeadF a = TupFstF a
type TupHead :: * -> * -> Constraint
class TupHead a head where tupHead :: a -> head
type TupSndF :: * -> *
type family TupSndF a where TupSndF (a, b) = b
type TupTailF :: * -> *
type family TupTailF a where TupTailF () = (TypeError ...) TupTailF a = TupSndF (TupSnocF a)
type TupTail :: * -> * -> Constraint
class TupTail a tail where tupTail :: a -> tail
type TupInitFL :: forall {a}. [a] -> [a]
type family TupInitFL t where TupInitFL '[] = '[] forall a (t :: a). TupInitFL '[t] = '[] forall a (t :: a) (ts :: [a]). TupInitFL (t : ts) = t : TupInitFL ts
type TupInitF :: * -> *
type TupInitF t = List2TupF (TupInitFL (Tup2ListF t))
type TupInit :: [*] -> Constraint
class TupInit t where tupInit :: List2TupF t -> TupInitF (List2TupF t)
type Tup2ListF :: * -> [*]
type family Tup2ListF a where Tup2ListF () = '[] Tup2ListF (Solo a) = '[a] Tup2ListF (a, b) = [a, b] Tup2ListF (a, b, c) = [a, b, c] Tup2ListF (a, b, c, d) = [a, b, c, d] Tup2ListF (a, b, c, d, e) = [a, b, c, d, e] Tup2ListF (a, b, c, d, e, f) = [a, b, c, d, e, f] Tup2ListF (a, b, c, d, e, f, g) = [a, b, c, d, e, f, g] Tup2ListF (a, b, c, d, e, f, g, h) = [a, b, c, d, e, f, g, h] Tup2ListF (a, b, c, d, e, f, g, h, i) = [a, b, c, d, e, f, g, h, i] Tup2ListF (a, b, c, d, e, f, g, h, i, j) = [a, b, c, d, e, f, g, h, i, j] Tup2ListF (a, b, c, d, e, f, g, h, i, j, k) = [a, b, c, d, e, f, g, h, i, j, k] Tup2ListF (a, b, c, d, e, f, g, h, i, j, k, l) = [a, b, c, d, e, f, g, h, i, j, k, l] Tup2ListF (a, b, c, d, e, f, g, h, i, j, k, l, m) = [a, b, c, d, e, f, g, h, i, j, k, l, m] Tup2ListF (a, b, c, d, e, f, g, h, i, j, k, l, m, n) = [a, b, c, d, e, f, g, h, i, j, k, l, m, n] Tup2ListF (a, b, c, d, e, f, g, h, i, j, k, l, m, n, o) = [a, b, c, d, e, f, g, h, i, j, k, l, m, n, o] Tup2ListF (a, b, c, d, e, f, g, h, i, j, k, l, m, n, o, p) = [a, b, c, d, e, f, g, h, i, j, k, l, m, n, o, p] Tup2ListF (a, b, c, d, e, f, g, h, i, j, k, l, m, n, o, p, q) = [a, b, c, d, e, f, g, h, i, j, k, l, m, n, o, p, q] Tup2ListF (a, b, c, d, e, f, g, h, i, j, k, l, m, n, o, p, q, r) = [a, b, c, d, e, f, g, h, i, j, k, l, m, n, o, p, q, r] Tup2ListF (a, b, c, d, e, f, g, h, i, j, k, l, m, n, o, p, q, r, s) = [a, b, c, d, e, f, g, h, i, j, k, l, m, n, o, p, q, r, s] Tup2ListF (a, b, c, d, e, f, g, h, i, j, k, l, m, n, o, p, q, r, s, t) = [a, b, c, d, e, f, g, h, i, j, k, l, m, n, o, p, q, r, s, t] Tup2ListF (a, b, c, d, e, f, g, h, i, j, k, l, m, n, o, p, q, r, s, t, u) = [a, b, c, d, e, f, g, h, i, j, k, l, m, n, o, p, q, r, s, t, u] Tup2ListF (a, b, c, d, e, f, g, h, i, j, k, l, m, n, o, p, q, r, s, t, u, v) = [a, b, c, d, e, f, g, h, i, j, k, l, m, n, o, p, q, r, s, t, u, v] Tup2ListF (a, b, c, d, e, f, g, h, i, j, k, l, m, n, o, p, q, r, s, t, u, v, w) = [a, b, c, d, e, f, g, h, i, j, k, l, m, n, o, p, q, r, s, t, u, v, w] Tup2ListF (a, b, c, d, e, f, g, h, i, j, k, l, m, n, o, p, q, r, s, t, u, v, w, x) = [a, b, c, d, e, f, g, h, i, j, k, l, m, n, o, p, q, r, s, t, u, v, w, x] Tup2ListF (a, b, c, d, e, f, g, h, i, j, k, l, m, n, o, p, q, r, s, t, u, v, w, x, y) = [a, b, c, d, e, f, g, h, i, j, k, l, m, n, o, p, q, r, s, t, u, v, w, x, y] Tup2ListF (a, b, c, d, e, f, g, h, i, j, k, l, m, n, o, p, q, r, s, t, u, v, w, x, y, z) = [a, b, c, d, e, f, g, h, i, j, k, l, m, n, o, p, q, r, s, t, u, v, w, x, y, z]
type List2TupF :: [*] -> *
type family List2TupF a where List2TupF '[] = () List2TupF '[a] = Solo a List2TupF [a, b] = (a, b) List2TupF [a, b, c] = (a, b, c) List2TupF [a, b, c, d] = (a, b, c, d) List2TupF [a, b, c, d, e] = (a, b, c, d, e) List2TupF [a, b, c, d, e, f] = (a, b, c, d, e, f) List2TupF [a, b, c, d, e, f, g] = (a, b, c, d, e, f, g) List2TupF [a, b, c, d, e, f, g, h] = (a, b, c, d, e, f, g, h) List2TupF [a, b, c, d, e, f, g, h, i] = (a, b, c, d, e, f, g, h, i) List2TupF [a, b, c, d, e, f, g, h, i, j] = (a, b, c, d, e, f, g, h, i, j) List2TupF [a, b, c, d, e, f, g, h, i, j, k] = (a, b, c, d, e, f, g, h, i, j, k) List2TupF [a, b, c, d, e, f, g, h, i, j, k, l] = (a, b, c, d, e, f, g, h, i, j, k, l) List2TupF [a, b, c, d, e, f, g, h, i, j, k, l, m] = (a, b, c, d, e, f, g, h, i, j, k, l, m) List2TupF [a, b, c, d, e, f, g, h, i, j, k, l, m, n] = (a, b, c, d, e, f, g, h, i, j, k, l, m, n) List2TupF [a, b, c, d, e, f, g, h, i, j, k, l, m, n, o] = (a, b, c, d, e, f, g, h, i, j, k, l, m, n, o) List2TupF [a, b, c, d, e, f, g, h, i, j, k, l, m, n, o, p] = (a, b, c, d, e, f, g, h, i, j, k, l, m, n, o, p) List2TupF [a, b, c, d, e, f, g, h, i, j, k, l, m, n, o, p, q] = (a, b, c, d, e, f, g, h, i, j, k, l, m, n, o, p, q) List2TupF [a, b, c, d, e, f, g, h, i, j, k, l, m, n, o, p, q, r] = (a, b, c, d, e, f, g, h, i, j, k, l, m, n, o, p, q, r) List2TupF [a, b, c, d, e, f, g, h, i, j, k, l, m, n, o, p, q, r, s] = (a, b, c, d, e, f, g, h, i, j, k, l, m, n, o, p, q, r, s) List2TupF [a, b, c, d, e, f, g, h, i, j, k, l, m, n, o, p, q, r, s, t] = (a, b, c, d, e, f, g, h, i, j, k, l, m, n, o, p, q, r, s, t) List2TupF [a, b, c, d, e, f, g, h, i, j, k, l, m, n, o, p, q, r, s, t, u] = (a, b, c, d, e, f, g, h, i, j, k, l, m, n, o, p, q, r, s, t, u) List2TupF [a, b, c, d, e, f, g, h, i, j, k, l, m, n, o, p, q, r, s, t, u, v] = (a, b, c, d, e, f, g, h, i, j, k, l, m, n, o, p, q, r, s, t, u, v) List2TupF [a, b, c, d, e, f, g, h, i, j, k, l, m, n, o, p, q, r, s, t, u, v, w] = (a, b, c, d, e, f, g, h, i, j, k, l, m, n, o, p, q, r, s, t, u, v, w) List2TupF [a, b, c, d, e, f, g, h, i, j, k, l, m, n, o, p, q, r, s, t, u, v, w, x] = (a, b, c, d, e, f, g, h, i, j, k, l, m, n, o, p, q, r, s, t, u, v, w, x) List2TupF [a, b, c, d, e, f, g, h, i, j, k, l, m, n, o, p, q, r, s, t, u, v, w, x, y] = (a, b, c, d, e, f, g, h, i, j, k, l, m, n, o, p, q, r, s, t, u, v, w, x, y) List2TupF [a, b, c, d, e, f, g, h, i, j, k, l, m, n, o, p, q, r, s, t, u, v, w, x, y, z] = (a, b, c, d, e, f, g, h, i, j, k, l, m, n, o, p, q, r, s, t, u, v, w, x, y, z)
type Tup2List :: * -> [*] -> Constraint
class Tup2List t h where tup2List :: t -> HList h
type List2Tup :: [*] -> Constraint
class List2Tup l where list2Tup :: HList l -> List2TupF l
(<$@>) :: Functor f => (a -> b -> c) -> f (a, b) -> f c
(<$$@>) :: (Functor f, Functor g) => (a -> b -> c) -> g (f (a, b)) -> g (f c)
(=<<@) :: Monad m => (a -> b -> m c) -> m (a, b) -> m c
($@) :: (a -> b -> c) -> (a, b) -> c
($$@) :: (a -> a -> b) -> a -> b
(&@) :: (a, b) -> (a -> b -> c) -> c
(&&@) :: a -> (a -> a -> b) -> b
aps :: Applicative f => (a -> b -> c) -> f a -> b -> f c
($<@>) :: Applicative f => (a -> b -> c) -> (f a, b) -> f c
(&<@>) :: Applicative f => (f a, b) -> (a -> b -> c) -> f c
dup :: a -> (a, a)
type role HomTup phantom representational
type HomTup :: Nat -> * -> *
newtype HomTup l a = HomTup [a]
type ToTupF :: * -> *
type family ToTupF a where ToTupF (HomTup 0 _1) = () ToTupF (HomTup 1 a) = Solo a ToTupF (HomTup n a) = TupConsF a (ToTupF (HomTup (n - 1) a)) ToTupF [a] = [ToTupF a] ToTupF a = Solo a
type (:^) :: * -> Nat -> *
type (:^) a n = ToTupF (HomTup n a)
type ToTup :: Nat -> * -> * -> Constraint
class ToTup n a b where toTup :: a -> b
type ToTupsF :: * -> *
type family ToTupsF a where ToTupsF () = () ToTupsF (HList a) = List2TupF a ToTupsF a = a
type ToTups :: * -> * -> Constraint
class ToTups a b where toTups :: a -> b
type MkHomTup :: forall {k}. k -> * -> * -> Constraint
class MkHomTup n a b where mkHomTup :: a -> b
type HomTupCons :: * -> * -> * -> Constraint
class HomTupCons a b c where homTupCons :: a -> b -> c
homTup :: (KnownNat n, Text.Parsec.Prim.Stream [String] m t, MkHomTup n [a] (HomTup n a)) => Text.Parsec.Prim.ParsecT String u m a -> Text.Parsec.Prim.ParsecT String u m (HomTup n a)
tuple :: (KnownNat n, Text.Parsec.Prim.Stream s m tok, ToTup n (HomTup n a) t, t ~ ToTupF (HomTup n a)) => Text.Parsec.Prim.ParsecT s u m a -> Text.Parsec.Prim.ParsecT s u m (ToTupF (HomTup n a))
tuples :: (ToTup n (HomTup n a) t, ToTups [a] [HomTup n a]) => Text.Parsec.Prim.ParsecT s u m [a] -> Text.Parsec.Prim.ParsecT s u m [t]
Quaalude.Type26Type-level experiments, work in progress. Not re-exported by Quaalude.
type Z :: *
data Z = Z
type S :: * -> *
data S n = S !n
type N :: Nat -> *
type family N n where N 0 = Z N n = S (N (n - 1))
type Plus1IsSucc :: Natural -> Constraint
class (N (n + 1) ~ S (N n)) => Plus1IsSucc n
type IsNat :: * -> Constraint
class IsNat n where nat :: n sing :: Nat
type FromNat :: Nat -> Constraint
class FromNat n where fromNat :: N n
type If :: forall {t}. Bool -> t -> ErrorMessage -> t
type family If cond a msg where forall t (_1 :: ErrorMessage) (a :: t). If True a _1 = a forall t (a :: t) (msg :: ErrorMessage). If False a msg = (TypeError ...)
type Not :: Bool -> Bool
type family Not a where Not True = False Not False = True
type (:==:) :: forall {k}. k -> k -> Bool
type family (:==:) a b where forall k (a :: k). (:==:) a a = True forall k (_1 :: k) (_2 :: k). (:==:) _1 _2 = False
type (:/=:) :: forall {k}. k -> k -> Bool
type (:/=:) a b = Not (a :==: b) :: Bool
type Even :: Natural -> *
type Even n = If (Mod n 2 :==: 0) (N n) ('Text "Expected an even number")
type Odd :: Natural -> *
type Odd n = If (Mod n 2 :==: 1) (N n) ('Text "Expected an even number")
type Without :: forall {k}. k -> k -> k
type Without without n = If (Not (n :==: without)) n ('Text "Expected any except " :<>: ShowType without) :: k
Quaalude.Unary79Operators taking () for prefix forms, set union and intersection, and Ѓ, the Maybe alias.
type (?) :: forall {k} {k1}. k -> k1 -> Constraint
class (?) a b
type Ѓ :: forall {k} {k1}. * -> (k -> k1 -> Constraint) -> *
type family Ѓ a f where Ѓ a (?) = Maybe a
type UnMonoid :: * -> * -> Constraint
class Monoid m => UnMonoid m a where unMonoid :: m -> a
(|=<) :: forall {k} (m :: k -> *) (a :: k) (f :: * -> *) b. (Monoid (m a), Monad f, Foldable f) => (b -> f (m a)) -> f b -> m a
type UnaryApply :: * -> * -> * -> Constraint
class UnaryApply a b c where (˙) :: a -> b -> c
type Intersectable :: * -> Constraint
class Intersectable a where (∩) :: a -> a -> a (⋂) :: Foldable f => () -> f a -> a
type UnaryIntersect :: *
data UnaryIntersect = Ⴖ
type Unionable :: * -> Constraint
class Unionable a where (∪) :: a -> a -> a (⋃) :: Foldable f => () -> f a -> a
type UnaryUnion :: *
data UnaryUnion = Ս
type Σ :: * -> *
newtype Σ a = Σ {getΣ :: a}
type Π :: * -> *
newtype Π a = Π {getΠ :: a}
type ConsAlias :: * -> (* -> *) -> * -> Constraint
class ConsAlias u f a where consAlias :: u -> f a -> a
type UnaryNot :: *
data UnaryNot = Ⴈ
ⴈ :: Bool -> Bool
type FoldLeft :: *
data FoldLeft
type FoldRight :: *
data FoldRight
type InitAcc :: *
data InitAcc
type Init1 :: *
data Init1
type FoldAccF :: forall {k}. * -> k -> k -> k
type family FoldAccF init acc a where forall k (_1 :: k) (acc :: k). FoldAccF InitAcc acc _1 = acc forall k (_1 :: k) (a :: k). FoldAccF Init1 _1 a = a
type FoldAccFnF :: * -> * -> * -> * -> *
type family FoldAccFnF dir init acc a where FoldAccFnF FoldLeft init acc a = FoldAccF init acc a -> a -> FoldAccF init acc a FoldAccFnF FoldRight init acc a = a -> FoldAccF init acc a -> FoldAccF init acc a
type GetFoldableF :: forall {k} {k1}. (k1 -> k) -> k1 -> k
type family GetFoldableF m a where forall k1 k2 (m :: k1 -> k2) (a :: k1). GetFoldableF m a = m a
type FoldFnF :: * -> * -> (* -> *) -> * -> * -> *
type family FoldFnF dir init m acc a where FoldFnF dir init m acc a = FoldAccFnF dir init acc a -> FoldAccF init acc a -> GetFoldableF m a -> FoldAccF init acc a
type role UnaryFold nominal nominal nominal nominal nominal
type UnaryFold :: * -> * -> (* -> *) -> * -> * -> *
data UnaryFold dir init m acc a = UnaryFold !(FoldAccFnF dir init acc a) !(FoldAccF init acc a) !(GetFoldableF m a)
type Fold :: * -> * -> (* -> *) -> * -> * -> *
data family Fold dir init m acc a
data instance Fold FoldLeft InitAcc m acc a = Ł !(FoldAccFnF FoldLeft InitAcc acc a) !(FoldAccF InitAcc acc a) !(GetFoldableF m a)
data instance Fold FoldRight InitAcc m acc a = Ɍ !(FoldAccFnF FoldRight InitAcc acc a) !(FoldAccF InitAcc acc a) !(GetFoldableF m a)
data instance Fold FoldLeft Init1 m acc a = Ŀ !(FoldAccFnF FoldLeft Init1 acc a) !(GetFoldableF m a)
data instance Fold FoldRight Init1 m acc a = Ṛ !(FoldAccFnF FoldRight Init1 acc a) !(GetFoldableF m a)
type FoldAccDF :: * -> *
type family FoldAccDF f where FoldAccDF (Fold dir init m acc a) = FoldAccF init acc a
type FoldAccFnDF :: * -> *
type family FoldAccFnDF f where FoldAccFnDF (Fold dir init m acc a) = FoldAccFnF dir init acc a
type GetFoldableDF :: * -> *
type family GetFoldableDF f where GetFoldableDF (Fold dir init m acc a) = GetFoldableF m a
type FoldFnDF :: * -> *
type family FoldFnDF f where FoldFnDF (Fold dir init m acc a) = FoldFnF dir init m acc a
type FoldAccFn :: * -> Constraint
class FoldAccFn f where foldAccFn :: f -> FoldAccFnDF f
type FoldAcc :: * -> Constraint
class FoldAcc f where foldAcc :: f -> FoldAccDF f
type GetFoldable :: * -> Constraint
class GetFoldable f where getFoldable :: f -> GetFoldableDF f
type FoldFn :: * -> Constraint
class FoldFn f where foldFn :: f -> FoldFnDF f
type ApplyUF :: * -> *
type family ApplyUF f
type ApplyU :: * -> * -> Constraint
class (o ~ ApplyUF f) => ApplyU f o where (!>) :: f -> o
type UnaryForce :: *
data UnaryForce = Λ
ȣ :: ()
ɾ :: a -> () -> a
type IsUnary :: * -> * -> Constraint
class IsUnary u a where unary :: u -> a (⁻) :: u -> a λ :: u -> a
ⵉ :: (Foldable f, Num a) => f a -> a
ꛛ :: (Foldable f, Num a) => f a -> a
Quaalude.Util302Parsing helpers (|-, number, numbers), conversion with as, memoisation, iteration and more.
inputPath :: Int -> FilePath
exampleInputPath :: Int -> FilePath
exampleInputNPath :: Int -> Int -> FilePath
readAsIO :: Data.Text.Read.Reader a -> FilePath -> IO [a]
(!<<) :: IO a -> a
flines :: Text -> [Text]
readAs :: Data.Text.Read.Reader a -> Text -> [a]
readOne :: Data.Text.Read.Reader a -> Text -> a
parseWithIO :: Parser a -> FilePath -> IO a
parseWith :: Parser a -> String -> a
parseEitherWith :: Parser a -> String -> Either ParseError a
parseLinesWith :: Parser a -> String -> [a]
parseLinesWith' :: Parser a -> String -> [a]
parseLinesEitherWith :: Parser a -> String -> [Either ParseError a]
(|-?) :: String -> Parser a -> Either ParseError a
(|-..?) :: String -> Parser a -> [Either ParseError a]
(|-..?!) :: String -> Parser a -> [a]
(|-<..?!>) :: Monoid a => String -> Parser a -> a
(-|) :: Parser a -> String -> a
(|-) :: String -> Parser a -> a
(|-..) :: String -> Parser a -> [a]
(|-.) :: String -> Parser a -> a
(|-<..>) :: (UnMonoid m a, m ~ m' a) => String -> Parser m -> a
(|-<.>) :: UnMonoid m a => String -> Parser m -> a
(|-<>) :: Monoid a => String -> Parser [a] -> a
(|-..<>) :: Monoid a => String -> Parser a -> a
(⊢) :: String -> Parser a -> a
twoOf :: Parser a -> Parser (a, a)
spaceTab :: Parser Char
spaceTabs :: Parser String
surrounding :: Parser a -> Parser b -> Parser b
wordOf :: Parser a -> Parser a
wordsOf :: Parser a -> Parser [a]
nums :: (Read a, Num a) => Parser [a]
numbers :: (Read a, Num a) => Parser [a]
nondigit :: Parser Char
nonnumber :: Parser String
oneInLineDiscarding :: Parser a -> Parser a
oneDiscarding :: Parser a -> Parser a
manyInLineDiscarding :: Parser a -> Parser [a]
type role PairSep phantom representational representational
type PairSep :: Symbol -> * -> * -> *
data PairSep sep a b = PairSep !a !b
type role TupSep phantom representational
type TupSep :: Symbol -> * -> *
data TupSep sep t = TupSep !t
type (⯻) :: * -> Symbol -> *
type family (⯻) t sep where (⯻) (a, b) sep = TupSep sep (a, b) (⯻) (a, b, c) sep = TupSep sep (a, b, c) (⯻) (a, b, c, d) sep = TupSep sep (a, b, c, d) (⯻) (a, b, c, d, e) sep = TupSep sep (a, b, c, d, e) (⯻) (a, b, c, d, e, f) sep = TupSep sep (a, b, c, d, e, f) (⯻) [a] sep = SepByMany sep a
type role LinesSep phantom representational
type LinesSep :: Symbol -> * -> *
data LinesSep sep a = LinesSep !a
type role MapSep phantom representational representational
type MapSep :: Symbol -> * -> * -> *
data MapSep sep k v = MapSep !k !v
type role CSV nominal nominal
type CSV :: * -> Nat -> *
data CSV a n = CSV !(a :^ n)
type (⹉) :: * -> Nat -> *
type (⹉) a n = CSV a n
type CSVAny :: * -> *
data CSVAny a = CSVAny ![a]
type role HListSep phantom nominal
type HListSep :: forall {k}. k -> [*] -> *
data HListSep sep xs = HListSep !(HList xs)
type role SepByMany phantom representational
type SepByMany :: Symbol -> * -> *
data SepByMany sep a = SepByMany !a
type role Between phantom phantom representational
type Between :: Symbol -> Symbol -> * -> *
data Between l r a = Between !a
type ℕw :: *
data ℕw = ℕw !String !ℕ
unℕw :: ℕw -> String
type ℕc :: *
data ℕc = ℕc !(Maybe Char)
unℕc :: ℕc -> Maybe Char
type role Exactly phantom
type Exactly :: Symbol -> *
data Exactly sym = Exactly
type role WithoutChars phantom representational
type WithoutChars :: Symbol -> * -> *
data WithoutChars sym t = Without !t
type (⊟) :: * -> Symbol -> *
type (⊟) t sym = WithoutChars sym t
type AaZz :: Symbol
type AaZz = "abcdefghijklmnopqrstuvwxyzABCDEFGHIJKLMNOPQRSTUVWXYZ" :: Symbol
type Whitespace :: Symbol
type Whitespace = " \t\n\r" :: Symbol
type EOLs :: Symbol
type EOLs = "\n\r" :: Symbol
type role OfChars phantom representational
type OfChars :: Symbol -> * -> *
data OfChars sym t = OfChars !t
type (⭀) :: * -> Symbol -> *
type (⭀) t sym = OfChars sym t
type CanonicalParseListF :: [*] -> [*]
type family CanonicalParseListF a where CanonicalParseListF '[] = '[] CanonicalParseListF (t : ts) = CanonicalParseF t : CanonicalParseListF ts
type CanonicalParseF :: * -> *
type family CanonicalParseF a where CanonicalParseF (SepByMany _1 a) = CanonicalParseF [a] CanonicalParseF (Between _1 _2 a) = CanonicalParseF a CanonicalParseF (Exactly _1) = String CanonicalParseF (WithoutChars _1 a) = a CanonicalParseF (OfChars _1 a) = a CanonicalParseF (PairSep _1 a b) = CanonicalParseF (a, b) CanonicalParseF (TupSep _1 t) = CanonicalParseF t CanonicalParseF (LinesSep _1 a) = CanonicalParseF [a] CanonicalParseF (MapSep _1 k v) = CanonicalParseF (Map k v) CanonicalParseF (CSVAny a) = [CanonicalParseF a] CanonicalParseF (CSV a n) = CanonicalParseF (a :^ n) CanonicalParseF (RangeOf a) = RangeOf a CanonicalParseF Char = Char CanonicalParseF String = String CanonicalParseF Text = Text CanonicalParseF [a] = [CanonicalParseF a] CanonicalParseF (Map k v) = Map (CanonicalParseF k) (CanonicalParseF v) CanonicalParseF (HList ts) = HList (CanonicalParseListF ts) forall k (_1 :: k) (ts :: [*]). CanonicalParseF (HListSep _1 ts) = CanonicalParseF (HList ts) CanonicalParseF (Solo a) = Solo (CanonicalParseF a) CanonicalParseF (a, b) = (CanonicalParseF a, CanonicalParseF b) CanonicalParseF (a, b, c) = (CanonicalParseF a, CanonicalParseF b, CanonicalParseF c) CanonicalParseF (f a b) = f (CanonicalParseF a) (CanonicalParseF b) CanonicalParseF (f a) = f (CanonicalParseF a) CanonicalParseF a = a
type CanonicalParse :: * -> Constraint
class CanonicalParse a where parseCanonical :: Parser (CanonicalParseF a)
type CanonicalParseSelf :: * -> Constraint
class (CanonicalParse a, a ~ CanonicalParseF a) => CanonicalParseSelf a where parseCanonicalSelf :: Parser a
type CanonicalParseTup :: * -> Constraint
class (CanonicalParseSelf (HList (CanonicalTupleL t)), List2Tup (CanonicalTupleL t), List2TupF (CanonicalTupleL t) ~ CanonicalParseF t) => CanonicalParseTup t where parseCanonicalTuple :: Parser (CanonicalParseF t)
type CanonicalTupleL :: * -> [*]
type CanonicalTupleL t = Tup2ListF (MapCanonicalParseF t) :: [*]
type CanonicalTupleHList :: * -> *
type CanonicalTupleHList t = HList (CanonicalTupleL t)
type MapCanonicalParseF :: * -> *
type family MapCanonicalParseF t where MapCanonicalParseF () = () MapCanonicalParseF (Solo a) = Solo (CanonicalParseF a) MapCanonicalParseF (a, b) = (CanonicalParseF a, CanonicalParseF b) MapCanonicalParseF (a, b, c) = (CanonicalParseF a, CanonicalParseF b, CanonicalParseF c)
(⋯) :: CanonicalParseSelf a => String -> a
traceCanonical :: String -> Parser a -> Parser a
type CanonicalParseVia :: * -> * -> Constraint
class CanonicalParse v => CanonicalParseVia v a where parseVia :: Parser a default parseVia :: (CanonicalParseF v ~ a) => Parser a (⋮) :: (CanonicalParseF v ~ a, CanonicalParse v) => String -> a
(⊏|⊐) :: (CanonicalParse v, Convable (CanonicalParseF v) a) => String -> a
(⋮⊏) :: (CanonicalParseVia v (f x), CanonicalParseF v ~ f x, Unable f) => String -> [x]
(⋮×⋮) :: CanonicalParseSelf (NonEmpty a, NonEmpty b) => Parser (NonEmpty a, NonEmpty b)
(⋮↵⋮) :: CanonicalParse (PairSep "\n" (NonEmpty a) (NonEmpty b)) => Parser (CanonicalParseF (PairSep "\n" (NonEmpty a) (NonEmpty b)))
(⋮×⋯) :: CanonicalParseSelf (NonEmpty a, [b]) => Parser (NonEmpty a, [b])
(⋮↵⋯) :: CanonicalParse (PairSep "\n" (NonEmpty a) [b]) => Parser (CanonicalParseF (PairSep "\n" (NonEmpty a) [b]))
natRange :: Read a => RangeSize -> Parser (RangeOf a)
naturals :: Read a => Parser [a]
mathOpChars :: String
mathOp :: Integral a => Parser (a -> a -> a)
nonMathOpChar :: Parser Char
nonMathOp :: Parser String
nats :: Read a => Parser [a]
nonNatDigit :: Parser Char
nonNatural :: Parser String
nat₁₀ :: Parser ℕ₁₀
anyWord :: Parser String
succeed :: a -> Parser a
trying :: [Parser a] -> Parser a
parend :: Parser a -> Parser a
assocsSep :: Parser kvSep -> Parser itemSep -> Parser k -> Parser v -> Parser [(k, v)]
mapSep :: Ord k => Parser kvSep -> Parser itemSep -> Parser k -> Parser v -> Parser (Map k v)
mapSepWith :: Ord k => (v -> v -> v) -> Parser kvSep -> Parser itemSep -> Parser k -> Parser v -> Parser (Map k v)
mapcat :: Ord k => String -> Parser k -> Parser v -> Parser (Map k [v])
abc :: Parser String
abc123 :: Parser String
abcABC123 :: Parser String
type CParsersF :: [*] -> [*]
type family CParsersF args where CParsersF '[] = '[] CParsersF (arg : args) = Parser arg : CParsersF args
type CFuncArgsF :: [*] -> [*]
type family CFuncArgsF argParsers where CFuncArgsF '[] = '[] CFuncArgsF (Parser arg : argParsers) = arg : CFuncArgsF argParsers
type CFuncArgs :: [*] -> Constraint
class CFuncArgs argParsers where cfuncArgs :: HList argParsers -> Parser (HList (CFuncArgsF argParsers))
type CFnName :: *
data CFnName = CFnName {unCFnName :: !String}
cfunc :: (CFuncArgsF (CParsersF args) ~ args, CFuncArgs (CParsersF args)) => CFnName -> HList (CParsersF args) -> Parser (String, HList args)
cfunc_ :: CFnName -> Parser String
cargs :: (CFuncArgs (CParsersF args), CFuncArgsF (CParsersF args) ~ args) => CFnName -> HList (CParsersF args) -> Parser (HList args)
type TShow :: * -> Constraint
class TShow a where tshow :: Show a => a -> Text tshowM :: Show a => Maybe a -> Text ltshow :: Show a => a -> Text utshow :: Show a => a -> Text
(<$$>) :: (Functor f, Functor g) => (a -> b) -> f (g a) -> f (g b)
(<$$$>) :: (Functor f, Functor g, Functor h) => (a -> b) -> f (g (h a)) -> f (g (h b))
(<&&>) :: (Functor f, Functor g) => f (g a) -> (a -> b) -> f (g b)
both :: Bifunctor f => (a -> b) -> f a a -> f b b
(<:>) :: Bifunctor f => (a -> b) -> f a a -> f b b
bothM :: (Bitraversable f, Monad m) => (a -> m b) -> f a a -> m (f b b)
same :: Eq a => (a, a) -> Bool
treverse :: (Traversable t, Monad f) => (t a -> b) -> t (f a) -> f b
iterateFix :: Eq a => (a -> a) -> a -> a
stabilize :: Eq a => (a -> a) -> [a] -> a
cycleGet :: Ord a => Int -> [a] -> a
(...) :: Ord a => [a] -> Int -> a
split :: ghc-internal-9.1003.0:GHC.Internal.Control.Arrow.Arrow a => a b c -> a (b, b) (c, c)
fanout :: ghc-internal-9.1003.0:GHC.Internal.Control.Arrow.Arrow a => a b c -> a b (c, c)
duping :: ((a, a) -> b) -> a -> b
bicomp :: (b -> c, a -> b) -> a -> c
biap :: (a -> b, a) -> b
fbiap :: Functor f => (a -> b, f a) -> f b
fbibind :: Monad m => (a -> m b, m a) -> m b
(&.&) :: (b1 -> b2 -> c) -> (b1 -> a -> b2) -> b1 -> a -> c
(&$&) :: (a -> d -> b) -> (c -> d) -> (a, c) -> b
(&<$>&) :: Functor f => (a1 -> a2 -> b) -> (c -> f a2) -> (a1, c) -> f b
(&<$>) :: Functor f => (a1 -> a2 -> b) -> (a1, f a2) -> f b
(&=<<&) :: Monad m => (a1 -> a2 -> m b) -> (c -> m a2) -> (a1, c) -> m b
(⇄) :: b -> (a -> b -> c) -> a -> c
(⥢) :: a -> ((a, a) -> b) -> b
appWhen :: (a -> Bool) -> (a -> a) -> a -> a
(<.>) :: Applicative f => f (b -> c) -> f (a -> b) -> f (a -> c)
(<∘>) :: Applicative f => f (b -> c) -> f (a -> b) -> f (a -> c)
(.<.) :: (c -> d) -> (a -> b -> c) -> a -> b -> d
(∘<∘) :: (c -> d) -> (a -> b -> c) -> a -> b -> d
(.>.) :: (a -> b -> c) -> (c -> d) -> a -> b -> d
(∘>∘) :: (a -> b -> c) -> (c -> d) -> a -> b -> d
toTuple2 :: [a] -> (a, a)
toTuple3 :: [a] -> (a, a, a)
toTuple4 :: [a] -> (a, a, a, a)
sortT2On :: Ord b => (a -> b) -> (a, a) -> (a, a)
sortT2OnM :: (Ord b, Monad m) => (a -> m b) -> (a, a) -> m (a, a)
toList2 :: (a, a) -> [a]
toList3 :: (a, a, a) -> [a]
uncurry4 :: (a -> b -> c -> d -> e) -> (a, b, c, d) -> e
fst4 :: (a, b, c, d) -> a
snd4 :: (a, b, c, d) -> b
thd4 :: (a, b, c, d) -> c
fth4 :: (a, b, c, d) -> d
perms3 :: [(Int, Int, Int) -> (Int, Int, Int)]
permsV3 :: [Linear.V3.V3 a -> Linear.V3.V3 a]
fromV3 :: Linear.V3.V3 a -> (a, a, a)
toV3 :: (a, a, a) -> Linear.V3.V3 a
fsts2 :: ((a, b1), (b2, b3)) -> (a, b2)
snds2 :: ((a1, a2), (a3, b)) -> (a2, b)
eol :: Parser Char
whitespace :: Parser String
number :: (Read a, Num a) => Parser a
nat :: Read a => Parser a
natural :: Read a => Parser a
bitChar :: Parser Bool
nBitInt :: Int -> Parser Integer
coord2 :: Parser (Int, Int)
csvLine :: Parser a -> Parser [a]
csv :: Parser [String]
csvOf :: Parser a -> Parser [a]
lineOf :: Parser a -> Parser a
linesOf :: Parser a -> Parser [a]
manyOf :: String -> Parser String
manyOf1 :: String -> Parser String
manyNoneOf :: String -> Parser String
manyNoneOf1 :: String -> Parser String
countMap :: (Ord a, Num n) => [a] -> Map a n
counts :: (Ord a, Num n) => [a] -> Map a n
adjustWithDefault :: Ord k => a -> (a -> a) -> k -> Map k a -> Map k a
adjustMany :: Ord k => (a -> a) -> [k] -> Map k a -> Map k a
insertMany :: Ord a => [a] -> Set a -> Set a
powerset :: [a] -> [[a]]
batch3 :: [a] -> [[a]]
pair :: a -> a -> [a]
about :: Integral a => a -> a -> [a]
listAsInt :: Integral a => [a] -> a
unlist :: [a] -> a
pairs :: [a] -> [(a, a)]
loopPairs :: [a] -> [(a, a)]
triPairs :: Unable t => t a -> [(a, a)]
triples :: Unable t => t a -> [(a, a, a)]
nSameIn :: Ord a => Int -> [a] -> Maybe a
count :: (a -> Bool) -> [a] -> Int
duplicates :: Ord a => [a] -> [a]
enumerate :: Enum a => [a]
enum :: (Foldable f, Mkable f (a, b), Num a, Enum a) => f b -> f (a, b)
(..#) :: (Foldable f, Mkable f (a, b), Num a, Enum a) => f b -> f (a, b)
permutationMaps :: (Enum a, Ord a) => [Map a a]
permuteSet :: Ord a => Map a a -> Set a -> Set a
type Solution :: * -> * -> Constraint
class Solution a b where toSolution :: a -> b
unjust :: Maybe a -> a
range :: (Ord a, Enum a) => a -> a -> [a]
(|...|) :: (Ord a, Enum a, Mkable f a) => a -> a -> f a
(-!) :: Num a => a -> a -> a
randomElement :: System.Random.Internal.RandomGen g => [a] -> g -> (a, g)
randomElements :: System.Random.Internal.RandomGen g => Int -> [a] -> g -> ([a], g)
randomElementIO :: [a] -> IO a
randomElementsIO :: Int -> [a] -> IO [a]
randomFromEnum :: (System.Random.Internal.RandomGen g, Enum a, Bounded a) => g -> (a, g)
randomFromEnumIO :: (Enum a, Bounded a) => IO a
shuffle :: System.Random.Internal.RandomGen g => [a] -> g -> [a]
shuffleIO :: [a] -> IO [a]
txt :: Language.Haskell.TH.Quote.QuasiQuoter
type As :: * -> * -> Constraint
class As to from where as :: from -> to
type Mℤ :: * -> *
data Mℤ k = Mℤ !ℤ !k
type MM :: * -> * -> *
type MM k v = Memo k v v
type (.->.) :: * -> * -> *
type (.->.) k v = k -> MM k v
(.$.) :: Ord k => (k .->. v) -> k -> MM k v
(.<$>.) :: (Ord k, Functor f) => (k .->. v) -> f k -> f (MM k v)
(.=<<.) :: (Ord k, Traversable m) => (k .->. v) -> m k -> Control.Monad.Trans.Memo.StateCache.StateCache (Control.Monad.Trans.Memo.State.Container (Map k v)) Identity (m v)
type Runnable :: (* -> *) -> Constraint
class Runnable f where run :: f a -> a
pad :: Int -> c -> [c] -> [c]
splitBy :: (a -> Bool) -> [a] -> [[a]]
pcases :: a -> [(a -> Bool, b)] -> b
cases :: Eq a => a -> [(a, b)] -> b
(?>) :: p -> [(p -> Bool, b)] -> b
(==?>) :: Eq p => p -> [(p, b)] -> b
(->>) :: a -> b -> (a, b)
(⊨) :: a -> Bool
(⊭) :: a -> Bool
type SymbolList :: forall {k}. Symbol -> k -> Constraint
class SymbolList cs l where symbolList :: [Char]
symbolHead :: (ConsSymbol c cs ~ css, KnownChar c) => Maybe Char
type ListToSymbol :: [Char] -> Symbol
type family ListToSymbol l where ListToSymbol '[] = "" ListToSymbol (c : l) = ConsSymbol c (ListToSymbol l)
type SymbolToList :: Symbol -> [Char]
type family SymbolToList s where SymbolToList "" = '[] SymbolToList s = SymbolToListM (UnconsSymbol s)
type SymbolToListM :: Maybe (Char, Symbol) -> [Char]
type family SymbolToListM s where SymbolToListM (Just '(c, s)) = c : SymbolToList s SymbolToListM Nothing = '[]
type SChars :: [Char] -> [*]
type family SChars cs where SChars '[] = '[] SChars (c : cs) = SChar c : SChars cs
type SymSChars :: Symbol -> [*]
type SymSChars s = SChars (SymbolToList s) :: [*]
type CharV :: Symbol -> *
type CharV s = V (SymSChars s)
type 𝘊 :: Symbol -> *
type 𝘊 s = CharV s
sortGroupOn :: Ord b => (a -> b) -> [a] -> [[a]]
nubOn :: Ord b => (a -> b) -> [a] -> [a]
Quaalude.Variadic18Variadic functions through type classes.
type role (|=>) nominal nominal
type (|=>) :: * -> * -> *
data (|=>) a b where Variadic :: (forall (n :: Nat). ToVariadic n a b) => !(forall (n :: Nat). ToVariadic n a b => ToVariadicF n a [b]) -> (|=>) a b
type role (|=*->) nominal nominal
type (|=*->) :: * -> * -> *
data (|=*->) a b where Variadicat :: (forall (n :: Nat). ToVariadicConcat n a b) => !(forall (n :: Nat). ToVariadicConcat n a b => ToVariadicF n a b) -> (|=*->) a b
type VF :: * -> Nat -> *
type family VF ab n where VF (a |=> b) n = ToVariadicF n a [b] VF (a |=*-> b) n = ToVariadicF n a b
type VC :: * -> Nat -> Constraint
type family VC ab n where VC (a |=> b) n = ToVariadic n a b VC (a |=*-> b) n = ToVariadicConcat n a b
type (-*=|) :: Nat -> * -> *
type (-*=|) n ab = VC ab n => VF ab n
type ToVariadicF :: Nat -> * -> * -> *
type family ToVariadicF arity a b where ToVariadicF 0 _1 b = b ToVariadicF arity a b = ToVariadicF (arity - 1) a (a -> b)
type ToVariadic :: Nat -> * -> * -> Constraint
class ToVariadic arity a b where variadic :: (a -> b) -> ToVariadicF arity a [b]
type ToVariadicConcat :: Nat -> * -> * -> Constraint
class (ToVariadic arity a b, ToVariadicF arity a b ~ ComposeNF ([b] -> b) (ToVariadicF arity a [b]), ComposeN ([b] -> b) (ToVariadicF arity a [b]), Monoid b) => ToVariadicConcat arity a b where variadicat :: (a -> b) -> ToVariadicF arity a b default variadicat :: (a -> b) -> ToVariadicF arity a b