Overloaded

Overloaded* language extensions as a source plugin.

Plugin

plugin :: Plugin

Overloaded plugin.

To enable plugin put the following at top of the module:

{-# OPTIONS -fplugin=Overloaded -fplugin-opt=Overloaded:Symbols #-}

At least one option is required, multiple can given either using multiple -fplugin-opt options, or by separating options with colon:

{-# OPTIONS -fplugin=Overloaded -fplugin-opt=Overloaded:Symbols:Numerals #-}

Options also take optional desugaring names, for example

{-# OPTIONS -fplugin=Overloaded -fplugin-opt=Overloaded:Labels=Data.Generics.ProductFields.field #-}

to desugar OverloadedLabels directly into field from generics-lens (no need to import orphan instance!)

Supported options

• Symbols desugars literal strings to fromSymbol @sym
• Strings works like built-in OverloadedStrings (but you can use different method than fromString)
• Numerals desugars literal numbers to fromNumeral @nat
• Naturals desugars literal numbers to fromNatural nat (i.e. like fromString)
• Chars desugars literal characters to fromChars c. Note: there isn't type-level alternative: we cannot promote Chars.
• Lists is not like built-in OverloadedLists, but desugars explicit lists to cons and nil
• If desugars if-expressions to ifte b t e
• Labels works like built-in OverloadedLabels (you should enable OverloadedLabels so parser recognises the syntax)
• TypeNats and TypeSymbols desugar type-level literals into FromNat and FromTypeSymbol respectively.

Known limitations

• Doesn't desugar inside patterns

RecordFields

WARNING the type-checker plugin is experimental, it's adviced to use

{-# OPTIONS_GHC -ddump-simpl #-}

to avoid surprising segfaults.

Usage

{-# OPTIONS -fplugin=Overloaded -fplugin-opt=Overloaded:RecordFields #-}

Implementation bits

See Note [HasField instances] in ClsInst, the behavior of this plugin is similar.

The HasField class is defined in GHC.Records.Compat module of record-hasfield package:

class HasField {k} x r a | x r -> a where
    hasField :: r -> (a -> r, a)

Suppose we have

data R y = MkR { foo :: [y] }

and foo in scope. We will solve constraints like

HasField "foo" (R Int) a

by emitting a new wanted constraint

[Int] ~# a

and building a HasField dictionary out of selector foo appropriately cast.

Idiom brackets from TemplateHaskellQuotes

{-# LANGUAGE TemplateHaskellQuotes #-}
{-# OPTIONS_GHC -fplugin=Overloaded -fplugin-opt=Overloaded:IdiomBrackets #-}

data Tree a
    = Leaf a
    | Branch (Tree a) (Tree a)
  deriving (Show)

instance Functor Tree where
    fmap f (Leaf x)     = Leaf (f x)
    fmap f (Branch l r) = Branch (fmap f l) (fmap f r)

instance Traversable Tree where
    traverse f (Leaf x)     = [| Leaf (f x) |]
    traverse f (Branch l r) = [| Branch (traverse f l) (traverse f r) |]

Overloaded:Symbols

class FromSymbol (s :: Symbol) a where

Another way to desugar overloaded string literals using this class.

A string literal "example" is desugared to

fromSymbol @"example"

Enabled with:

{-# OPTIONS -fplugin=Overloaded -fplugin-opt=Overloaded:Symbols #-}

Methods

fromSymbol :: a

Instances

(KnownNat y, KnownNat m, KnownNat d, ParseDay s ~ (,,) y m d) => FromSymbol s Day

Defined in Overloaded.Symbols

Methods

fromSymbol :: Day

(KnownSymbol s, SeqList (ToList s)) => FromSymbol s ByteString

Defined in Overloaded.Symbols

Methods

fromSymbol :: ByteString

(KnownSymbol s, SeqList (ToList s)) => FromSymbol s ByteString

Defined in Overloaded.Symbols

Methods

fromSymbol :: ByteString

KnownSymbol s => FromSymbol s Text

Defined in Overloaded.Symbols

Methods

fromSymbol :: Text

KnownSymbol s => FromSymbol s Text

Defined in Overloaded.Symbols

Methods

fromSymbol :: Text

(KnownSymbol s, a ~ Char) => FromSymbol s [a]

Defined in Overloaded.Symbols

Methods

fromSymbol :: [a]

Overloaded:Strings

See Data.String for fromString.

Overloaded:Numerals

class FromNumeral (n :: Nat) a where

Another way to desugar numerals.

A numeric literal 123 is desugared to

fromNumeral @123

Enabled with:

{-# OPTIONS -fplugin=Overloaded -fplugin-opt=Overloaded:Numerals #-}

One can do type-level computations with this.

Methods

fromNumeral :: a

Instances

(KnownNat n, (1 <=? n) ~ True) => FromNumeral n BinP

Defined in Overloaded.Numerals

Methods

fromNumeral :: BinP

KnownNat n => FromNumeral n Bin

Defined in Overloaded.Numerals

Methods

fromNumeral :: Bin

KnownNat n => FromNumeral n Nat

Defined in Overloaded.Numerals

Methods

fromNumeral :: Nat

(KnownNat n, OverflowCheck n "Word8" (n <=? 18446744073709551615)) => FromNumeral n Word64

Defined in Overloaded.Numerals

Methods

fromNumeral :: Word64

(KnownNat n, OverflowCheck n "Word8" (n <=? 4294967295)) => FromNumeral n Word32

Defined in Overloaded.Numerals

Methods

fromNumeral :: Word32

(KnownNat n, OverflowCheck n "Word8" (n <=? 65535)) => FromNumeral n Word16

Defined in Overloaded.Numerals

Methods

fromNumeral :: Word16

(KnownNat n, OverflowCheck n "Word8" (n <=? 255)) => FromNumeral n Word8

Defined in Overloaded.Numerals

Methods

fromNumeral :: Word8

KnownNat n => FromNumeral n Int

TODO: currently there is no range check

Defined in Overloaded.Numerals

Methods

fromNumeral :: Int

KnownNat n => FromNumeral n Integer

Defined in Overloaded.Numerals

Methods

fromNumeral :: Integer

KnownNat n => FromNumeral n Natural

Defined in Overloaded.Numerals

Methods

fromNumeral :: Natural

(PosFromNumeral (FromGHC n) b, IsLess n (ToGHC b)) => FromNumeral n (Pos (BP b))

Defined in Overloaded.Numerals

Methods

fromNumeral :: Pos (BP b)

(PosFromNumeral (FromGHC n) b, IsLess n (ToGHC b)) => FromNumeral n (PosP b)

Defined in Overloaded.Numerals

Methods

fromNumeral :: PosP b

(FinFromNumeral (FromGHC n) m, IsLess n (ToGHC m)) => FromNumeral n (Fin m)

Defined in Overloaded.Numerals

Methods

fromNumeral :: Fin m

defaultFromNumeral :: forall n a. (KnownNat n, Integral a) => a

Default implementation of fromNumeral.

Usage example:

instance (KnownNat n, ...) => FromNumeral n MyType where
    fromNumeral = defaultFromNumeral @n

Overloaded:Naturals

class FromNatural a where

Class for Natural-like datastructures

A numeric literal 42 is desugared to

fromNatural 42

Methods

fromNatural :: Natural -> a

Instances

FromNatural Integer

Defined in Overloaded.Naturals

Methods

fromNatural :: Natural -> Integer

FromNatural Natural

Defined in Overloaded.Naturals

Methods

fromNatural :: Natural -> Natural

Overloaded:Chars

class FromChar a where

Class for Char-like datastructures

A character literal x is desugared to

fromChar 'x'

Methods

fromChar :: Char -> a

Instances

FromChar Char

Defined in Overloaded.Chars

Methods

fromChar :: Char -> Char

Overloaded:Lists

class Nil a where

Class for nil, []

See test-suite for ways to define instances for Map. There are at-least two-ways.

Methods

nil :: a

Instances

Nil IntSet

Since: 0.1.3

Defined in Overloaded.Lists

Methods

nil :: IntSet

Nil [a]

Defined in Overloaded.Lists

Methods

nil :: [a]

Nil (IntMap v)

Since: 0.2

Defined in Overloaded.Lists

Methods

nil :: IntMap v

Nil (Seq a)

Since: 0.2

Defined in Overloaded.Lists

Methods

nil :: Seq a

Nil (Set a)

Since: 0.1.3

Defined in Overloaded.Lists

Methods

nil :: Set a

Nil (RAList a)

Defined in Overloaded.Lists

Methods

nil :: RAList a

Nil (Map k v)

Since: 0.2

Defined in Overloaded.Lists

Methods

nil :: Map k v

b ~ BZ => Nil (RAVec b a)

Defined in Overloaded.Lists

Methods

nil :: RAVec b a

n ~ Z => Nil (Vec n a)

Defined in Overloaded.Lists

Methods

nil :: Vec n a

xs ~ ([] :: [k]) => Nil (NP f xs)

Defined in Overloaded.Lists

Methods

nil :: NP f xs

xs ~ ([] :: [[k]]) => Nil (POP f xs)

Defined in Overloaded.Lists

Methods

nil :: POP f xs

class Cons x ys zs | zs -> x ys where

Class for Cons :.

Methods

cons :: x -> ys -> zs infixr 5

Instances

Cons Int IntSet IntSet

Since: 0.1.3

Defined in Overloaded.Lists

Methods

cons :: Int -> IntSet -> IntSet

(a ~ b, a ~ c) => Cons a (RAList b) (NERAList c)

Defined in Overloaded.Lists

Methods

cons :: a -> RAList b -> NERAList c

(a ~ b, a ~ c) => Cons a (RAList b) (RAList c)

Defined in Overloaded.Lists

Methods

cons :: a -> RAList b -> RAList c

(a ~ b, b ~ c) => Cons a (Seq b) (Seq c)

Since: 0.2

Defined in Overloaded.Lists

Methods

cons :: a -> Seq b -> Seq c

(Ord a, a ~ b, b ~ c) => Cons a (Set b) (Set c)

Since: 0.1.3

Defined in Overloaded.Lists

Methods

cons :: a -> Set b -> Set c

(a ~ b, b ~ c) => Cons a [b] (NonEmpty c)

Defined in Overloaded.Lists

Methods

cons :: a -> [b] -> NonEmpty c

(a ~ b, b ~ c) => Cons a [b] [c]

Defined in Overloaded.Lists

Methods

cons :: a -> [b] -> [c]

(bp ~ Pred b, b ~ Succ' bp) => Cons a (RAVec bp a) (NERAVec b a)

Defined in Overloaded.Lists

Methods

cons :: a -> RAVec bp a -> NERAVec b a

(b ~ BP bb, bp ~ Pred bb, bb ~ Succ' bp) => Cons a (RAVec bp a) (RAVec b a)

Defined in Overloaded.Lists

Methods

cons :: a -> RAVec bp a -> RAVec b a

(a ~ b, b ~ c, m ~ S n) => Cons a (Vec n b) (Vec m c)

Defined in Overloaded.Lists

Methods

cons :: a -> Vec n b -> Vec m c

(f ~ g, g ~ h, xxs ~ (x ': xs)) => Cons (f x) (NP g xs) (NP h xxs)

Defined in Overloaded.Lists

Methods

cons :: f x -> NP g xs -> NP h xxs

(i ~ Int, a ~ b, b ~ c) => Cons (i, a) (IntMap b) (IntMap c)

Since: 0.2

Defined in Overloaded.Lists

Methods

cons :: (i, a) -> IntMap b -> IntMap c

(Ord k, k ~ k1, k ~ k2, v ~ v1, v ~ v2) => Cons (k, v) (Map k1 v1) (Map k2 v2)

Since: 0.2

Defined in Overloaded.Lists

Methods

cons :: (k, v) -> Map k1 v1 -> Map k2 v2

(f ~ g, g ~ h, xsxss ~ (xs ': xss)) => Cons (NP f xs) (POP g xss) (POP h xsxss)

Defined in Overloaded.Lists

Methods

cons :: NP f xs -> POP g xss -> POP h xsxss

Overloaded:If

class ToBool b where

Class for Bool-like datastrucutres

An if--expression if b then t else e is desugared to

ifte (toBool b) t e

Enabled with:

{-# OPTIONS -fplugin=Overloaded -fplugin-opt=Overloaded:If #-}

Methods

toBool :: b -> Bool

Instances

ToBool Bool

Defined in Overloaded.If

Methods

toBool :: Bool -> Bool

ToBool (Maybe a)

Just is True

Defined in Overloaded.If

Methods

toBool :: Maybe a -> Bool

ToBool (Either b a)

Right is True

Defined in Overloaded.If

Methods

toBool :: Either b a -> Bool

ifte :: ToBool b => b -> a -> a -> a

ToBool overloaded if-expression.

Overloaded:Labels

See GHC.OverloadedLabels for fromLabel.

Overloaded:TypeNats

class FromNatC a

A way to overload type level Nats.

A number type-literal 42 is desugared to

FromNat 42

Enabled with:

{-# OPTIONS -fplugin=Overloaded -fplugin-opt=Overloaded:TypeNats #-}

Associated Types

type FromNat (n :: Nat) :: a

Instances

FromNatC Nat

Defined in Overloaded.TypeNats

Associated Types

type FromNat n :: a

FromNatC Nat

Defined in Overloaded.TypeNats

Associated Types

type FromNat n :: a

FromNatC Bin

Defined in Overloaded.TypeNats

Associated Types

type FromNat n :: a

FromNatC BinP

Defined in Overloaded.TypeNats

Associated Types

type FromNat n :: a

Overloaded:TypeSymbols

class FromTypeSymbolC a

A way to overload type level Symbols.

A symbol type-literal "example" is desugared to

FromTypeSymbol "example"

Enabled with:

{-# OPTIONS -fplugin=Overloaded -fplugin-opt=Overloaded:TypeSymbols #-}

Associated Types

type FromTypeSymbol (s :: Symbol) :: a

Instances

FromTypeSymbolC Symbol

Defined in Overloaded.TypeSymbols

Associated Types

type FromTypeSymbol s :: a

Overloaded:RecordFields

See GHC.Records.Compat from record-hasfield package.