Ideas.Common.Classes

Type classes and instances.

Type class Apply

class Apply t where

A type class for functors that can be applied to a value. Transformation, Rule, and Strategy are all instances of this type class.

Minimal complete definition

applyAll

Methods

applyAll :: t a -> a -> [a]

Instances

Apply RewriteRule

Methods

applyAll :: RewriteRule a -> a -> [a]

Apply Rule

Methods

applyAll :: Rule a -> a -> [a]

Apply Dynamic

Methods

applyAll :: Dynamic a -> a -> [a]

Apply Leaf

Methods

applyAll :: Leaf a -> a -> [a]

Apply LabeledStrategy

Methods

applyAll :: LabeledStrategy a -> a -> [a]

Apply Strategy

Methods

applyAll :: Strategy a -> a -> [a]

Apply Exercise

Methods

applyAll :: Exercise a -> a -> [a]

apply :: Apply t => t a -> a -> Maybe a

Returns zero or one results

applicable :: Apply t => t a -> a -> Bool

Checks whether the functor is applicable (at least one result)

applyD :: Apply t => t a -> a -> a

If not applicable, return the current value (as default)

applyM :: (Apply t, Monad m) => t a -> a -> m a

Same as apply, except that the result (at most one) is returned in some monad

applyList :: Apply t => [t a] -> a -> Maybe a

Type class Container

class Container f where

Instances should satisfy the following law: getSingleton . singleton == Just

Minimal complete definition

singleton, getSingleton

Methods

singleton :: a -> f a

getSingleton :: f a -> Maybe a

Instances

Container []

Methods

singleton :: a -> [a]

getSingleton :: [a] -> Maybe a

Container Set

Methods

singleton :: a -> Set a

getSingleton :: Set a -> Maybe a

Type class BiArrow

class Arrow arr => BiArrow arr where

Type class for bi-directional arrows. - should be used instead of arr from the arrow interface. Minimal complete definition: -.

Minimal complete definition

(<->)

Methods

(<->) :: (a -> b) -> (b -> a) -> arr a b infix 1

(!->) :: (a -> b) -> arr a b

(<-!) :: (b -> a) -> arr a b

Instances

BiArrow Isomorphism

Methods

(<->) :: (a -> b) -> (b -> a) -> Isomorphism a b

(!->) :: (a -> b) -> Isomorphism a b

(<-!) :: (b -> a) -> Isomorphism a b

BiArrow View

Methods

(<->) :: (a -> b) -> (b -> a) -> View a b

(!->) :: (a -> b) -> View a b

(<-!) :: (b -> a) -> View a b

Type class BiFunctor

class BiFunctor f where

Minimal complete definition

biMap

Methods

biMap :: (a -> c) -> (b -> d) -> f a b -> f c d

mapFirst :: (a -> b) -> f a c -> f b c

mapSecond :: (b -> c) -> f a b -> f a c

Instances

BiFunctor Either

Methods

biMap :: (a -> c) -> (b -> d) -> Either a b -> Either c d

mapFirst :: (a -> b) -> Either a c -> Either b c

mapSecond :: (b -> c) -> Either a b -> Either a c

BiFunctor (,)

Methods

biMap :: (a -> c) -> (b -> d) -> (a, b) -> (c, d)

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

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

BiFunctor Derivation

Methods

biMap :: (a -> c) -> (b -> d) -> Derivation a b -> Derivation c d

mapFirst :: (a -> b) -> Derivation a c -> Derivation b c

mapSecond :: (b -> c) -> Derivation a b -> Derivation a c

BiFunctor DerivationTree

Methods

biMap :: (a -> c) -> (b -> d) -> DerivationTree a b -> DerivationTree c d

mapFirst :: (a -> b) -> DerivationTree a c -> DerivationTree b c

mapSecond :: (b -> c) -> DerivationTree a b -> DerivationTree a c

BiFunctor CyclicTree

Methods

biMap :: (a -> c) -> (b -> d) -> CyclicTree a b -> CyclicTree c d

mapFirst :: (a -> b) -> CyclicTree a c -> CyclicTree b c

mapSecond :: (b -> c) -> CyclicTree a b -> CyclicTree a c

mapBoth :: BiFunctor f => (a -> b) -> f a a -> f b b

Type class Fix

class Fix a where

Methods

fix :: (a -> a) -> a

Instances

Fix (Process a)

Methods

fix :: (Process a -> Process a) -> Process a

Fix (Strategy a)

Methods

fix :: (Strategy a -> Strategy a) -> Strategy a

Fix (CyclicTree a b)

Methods

fix :: (CyclicTree a b -> CyclicTree a b) -> CyclicTree a b

Boolean Algebra

class BoolValue a where

Minimal complete definition

isTrue, isFalse

Methods

true :: a

false :: a

fromBool :: Bool -> a

isTrue :: a -> Bool

isFalse :: a -> Bool

Instances

BoolValue Bool

Methods

true :: Bool

false :: Bool

fromBool :: Bool -> Bool

isTrue :: Bool -> Bool

isFalse :: Bool -> Bool

BoolValue (Predicate a)

Methods

true :: Predicate a

false :: Predicate a

fromBool :: Bool -> Predicate a

isTrue :: Predicate a -> Bool

isFalse :: Predicate a -> Bool

BoolValue b => BoolValue (a -> b)

Methods

true :: a -> b

false :: a -> b

fromBool :: Bool -> a -> b

isTrue :: (a -> b) -> Bool

isFalse :: (a -> b) -> Bool

class BoolValue a => Boolean a where

Minimal complete definition

(<&&>), (<||>), complement

Methods

(<&&>) :: a -> a -> a

(<||>) :: a -> a -> a

complement :: a -> a

Instances

Boolean Bool

Methods

(<&&>) :: Bool -> Bool -> Bool

(<||>) :: Bool -> Bool -> Bool

complement :: Bool -> Bool

Boolean (Predicate a)

Methods

(<&&>) :: Predicate a -> Predicate a -> Predicate a

(<||>) :: Predicate a -> Predicate a -> Predicate a

complement :: Predicate a -> Predicate a

Boolean b => Boolean (a -> b)

Methods

(<&&>) :: (a -> b) -> (a -> b) -> a -> b

(<||>) :: (a -> b) -> (a -> b) -> a -> b

complement :: (a -> b) -> a -> b

ands :: Boolean a => [a] -> a

ors :: Boolean a => [a] -> a

implies :: Boolean a => a -> a -> a

equivalent :: Boolean a => a -> a -> a

Buggy and Minor properties

class Buggy a where

Minimal complete definition

setBuggy, isBuggy

Methods

buggy :: a -> a

setBuggy :: Bool -> a -> a

isBuggy :: a -> Bool

Instances

Buggy (Rule a)

Methods

buggy :: Rule a -> Rule a

setBuggy :: Bool -> Rule a -> Rule a

isBuggy :: Rule a -> Bool

class Minor a where

Minimal complete definition

setMinor, isMinor

Methods

minor :: a -> a

setMinor :: Bool -> a -> a

isMinor :: a -> Bool

isMajor :: a -> Bool

Instances

Minor (Rule a)

Methods

minor :: Rule a -> Rule a

setMinor :: Bool -> Rule a -> Rule a

isMinor :: Rule a -> Bool

isMajor :: Rule a -> Bool

Minor (Leaf a)

Methods

minor :: Leaf a -> Leaf a

setMinor :: Bool -> Leaf a -> Leaf a

isMinor :: Leaf a -> Bool

isMajor :: Leaf a -> Bool