Prelude.Spiros.Types

re-export custom data types that are generally useful for me.

the newtypes distinguish them with more meaningful names (of constructors, accessors, transformers, etc), but still support the convenience of automatically deriving as many instances as correct.

Documentation

type (:~>) f g = forall x. f x -> g x

a natural transformation

type (:.) f g x = f (g x)

type (:.:) = Compose

 (f :.: g) a  ≡  f (g a)

type (:*:) = Product

(f :*: g) a  ≡  (f a, g a)

type (:+:) = Sum

(f :+: g) a  ≡  Either (f a) (g a)

type P = Proxy

P a ≡ ()

type C = Const

C a b ≡ a

type I = Identity

I a ≡ a

type HaskellName = Name

a haskell identifier, via TemplateHaskellQuotes.

> :set -XTemplateHaskellQuotes
> 'fmap :: HaskellName

type CanInterpolate t = (IsString t, Monoid t)

for `interpolatedstring-perl6` i.e. the type supports string literals (via IsString) and can be appended (via Monoid).

uses ConstraintKinds.

e.g.

-- -XQuasiQuotes
import Text.InterpolatedString.Perl6 (qq)

hello :: (CanInterpolate t) => t -> t
hello t = [qc| "hello" ++ $t |]

helloworld = hello "world" :: String

type BoundedEnum a = (Enum a, Bounded a)

a finite type, whose values may be enumerated into a finite list.

type List a = [a]

alphanumeric alias

pattern (:*:) :: f a -> g a -> Product f g a

pattern P :: forall (a :: k). Proxy a

pattern C :: forall a b. a -> Const a b

pattern I :: a -> Identity a

type LazyBytes = ByteString

type StrictBytes = ByteString

type LazyText = Text

type StrictText = Text