SubHask.Compatibility.Containers

Bindings to make the popular containers library compatible with subhask

Documentation

newtype Seq a

This is a thin wrapper around Data.Sequence

Constructors

Seq (Seq a)

Instances

Read a => Read (Seq a)

Show a => Show (Seq a)

(Eq a, Arbitrary a) => Arbitrary (Seq a)

NFData a => NFData (Seq a)

IsMutable (Seq a)

ValidEq a => Foldable (Seq a)

Eq a => Container (Seq a)

Constructible (Seq a)

Normed (Seq a)

Monoid (Seq a)

Semigroup (Seq a)

POrd a => MinBound_ (Seq a)

POrd a => POrd_ (Seq a)

Eq a => Eq_ (Seq a)

ValidEq a => Partitionable (Seq a)

data Mutable m (Seq a0) = Mutable_AppT__ConT_SubHask_Compatibility_Containers_Seq___VarT_a_1628103216_ (PrimRef m (Seq a))

type Elem (Seq a) = a

type Scalar (Seq a) = Int

type Logic (Seq a) = Bool

type SetElem (Seq a) b = Seq b

newtype Map i e

This is a thin wrapper around Data.Map

Constructors

Map (Map (WithPreludeOrd i) (WithPreludeOrd e))

Instances

(Show i, Show e) => Show (Map i e)

(Eq e, Ord i, Semigroup e, Arbitrary i, Arbitrary e) => Arbitrary (Map i e)

(NFData i, NFData e) => NFData (Map i e)

IsMutable (Map i e)

(Ord i, Eq e) => IxConstructible (Map i e)

(Ord i, Eq e) => IxContainer (Map i e)

Normed (Map i e)

Ord i => Monoid (Map i e)

Ord i => Semigroup (Map i e)

(Ord i, POrd e) => MinBound_ (Map i e)

(Ord i, Eq e) => POrd_ (Map i e)

(Eq i, Eq e) => Eq_ (Map i e)

data Mutable m (Map i0 e0) = Mutable_AppT__AppT__ConT_SubHask_Compatibility_Containers_Map___VarT_i_1628104360____VarT_e_1628104361_ (PrimRef m (Map i e))

type Index (Map i e) = i

type Elem (Map i e) = e

type Scalar (Map i e) = Int

type Logic (Map i e) = Bool

type ValidElem (Map i e1) e = ()

type SetIndex (Map i e) i' = Map i' e

type SetElem (Map i e) e' = Map i e'

newtype Map' i e

This is a thin wrapper around Data.Map.Strict

Constructors

Map' (Map (WithPreludeOrd i) (WithPreludeOrd e))

Instances

(Show i, Show e) => Show (Map' i e)

(Eq e, Ord i, Semigroup e, Arbitrary i, Arbitrary e) => Arbitrary (Map' i e)

(NFData i, NFData e) => NFData (Map' i e)

IsMutable (Map' i e)

(Ord i, Eq e) => IxConstructible (Map' i e)

(Ord i, Eq e) => IxContainer (Map' i e)

Normed (Map' i e)

Ord i => Monoid (Map' i e)

Ord i => Semigroup (Map' i e)

(Ord i, POrd e) => MinBound_ (Map' i e)

(Ord i, Eq e) => POrd_ (Map' i e)

(Eq i, Eq e) => Eq_ (Map' i e)

data Mutable m (Map' i0 e0) = Mutable_AppT__AppT__ConT_SubHask_Compatibility_Containers_Map'___VarT_i_1628105501____VarT_e_1628105502_ (PrimRef m (Map' i e))

type Index (Map' i e) = i

type Elem (Map' i e) = e

type Scalar (Map' i e) = Int

type Logic (Map' i e) = Bool

type ValidElem (Map' i e1) e = ()

type SetIndex (Map' i e) i' = Map' i' e

type SetElem (Map' i e) e' = Map' i e'

newtype IntMap e

This is a thin wrapper around Data.IntMap

Constructors

IntMap (IntMap (WithPreludeOrd e))

Instances

Read e => Read (IntMap e)

Show e => Show (IntMap e)

(Eq e, Semigroup e, Arbitrary e) => Arbitrary (IntMap e)

NFData e => NFData (IntMap e)

IsMutable (IntMap a)

Eq e => IxConstructible (IntMap e)

Eq e => IxContainer (IntMap e)

Normed (IntMap e)

Monoid (IntMap e)

Semigroup (IntMap e)

POrd e => MinBound_ (IntMap e)

Eq e => POrd_ (IntMap e)

Eq e => Eq_ (IntMap e)

data Mutable m (IntMap a0) = Mutable_AppT__ConT_SubHask_Compatibility_Containers_IntMap___VarT_a_1628106664_ (PrimRef m (IntMap a))

type Index (IntMap e) = Key

type Elem (IntMap e) = e

type Scalar (IntMap e) = Int

type Logic (IntMap e) = Bool

type ValidElem (IntMap e1) e = ()

type SetElem (IntMap e) e' = IntMap e'

newtype IntMap' e

This is a thin wrapper around Data.IntMap.Strict

Constructors

IntMap' (IntMap (WithPreludeOrd e))

Instances

Read e => Read (IntMap' e)

Show e => Show (IntMap' e)

(Eq e, Semigroup e, Arbitrary e) => Arbitrary (IntMap' e)

NFData e => NFData (IntMap' e)

IsMutable (IntMap' a)

Eq e => IxConstructible (IntMap' e)

Eq e => IxContainer (IntMap' e)

Normed (IntMap' e)

Monoid (IntMap' e)

Semigroup (IntMap' e)

POrd e => MinBound_ (IntMap' e)

Eq e => POrd_ (IntMap' e)

Eq e => Eq_ (IntMap' e)

data Mutable m (IntMap' a0) = Mutable_AppT__ConT_SubHask_Compatibility_Containers_IntMap'___VarT_a_1628107561_ (PrimRef m (IntMap' a))

type Index (IntMap' e) = Key

type Elem (IntMap' e) = e

type Scalar (IntMap' e) = Int

type Logic (IntMap' e) = Bool

type ValidElem (IntMap' e1) e = ()

type SetElem (IntMap' e) e' = IntMap' e'

newtype Set a

This is a thin wrapper around the container's set type

Constructors

Set (Set (WithPreludeOrd a))

Instances

Show a => Show (Set a)

(Ord a, Arbitrary a) => Arbitrary (Set a)

NFData a => NFData (Set a)

IsMutable (Set a)

Ord a => Foldable (Set a)

Ord a => Container (Set a)

Ord a => Constructible (Set a)

Normed (Set a)

Ord a => Abelian (Set a)

Ord a => Monoid (Set a)

Ord a => Semigroup (Set a)

Ord a => Lattice_ (Set a)

Ord a => MinBound_ (Set a)

Ord a => POrd_ (Set a)

Eq a => Eq_ (Set a)

data Mutable m (Set a0) = Mutable_AppT__ConT_SubHask_Compatibility_Containers_Set___VarT_a_1628108370_ (PrimRef m (Set a))

type Elem (Set a) = a

type Scalar (Set a) = Int

type Logic (Set a) = Logic a

type SetElem (Set a) b = Set b

data LexSet a where

FIXME: implement this in terms of Lexical and Set

FIXME: add the Constrained Monad

Constructors

LexSet :: Ord a => Set a -> LexSet a

Instances

Monad OrdHask LexSet

Monad Mon LexSet

FIXME: is there a more efficient implementation?

Then * LexSet

Functor * OrdHask LexSet

Functor * Mon LexSet

Show a => Show (LexSet a)

IsMutable (LexSet a)

Ord a => Foldable (LexSet a)

Ord a => Container (LexSet a)

Ord a => Constructible (LexSet a)

Ord a => Normed (LexSet a)

Ord a => Monoid (LexSet a)

Semigroup (LexSet a)

Ord_ (LexSet a)

Lattice_ (LexSet a)

Ord a => MinBound_ (LexSet a)

POrd_ (LexSet a)

Eq_ (LexSet a)

data Mutable m (LexSet a0) = Mutable_AppT__ConT_SubHask_Compatibility_Containers_LexSet___VarT_a_1628109321_ (PrimRef m (LexSet a))

type Elem (LexSet a) = a

type Scalar (LexSet a) = Int

type Logic (LexSet a) = Bool

type SetElem (LexSet a) b = LexSet b

liftPreludeOrd :: (a -> b) -> WithPreludeOrd a -> WithPreludeOrd b