Graphula.Dependencies

Documentation

class HasDependencies a where

Minimal complete definition

Nothing

Associated Types

type Dependencies a

A data type declaring the model's dependencies

Models with no dependencies can declare an empty instance,

instance HasDependencies School

Models with one dependency must use the Only 1-tuple constructor,

instance HasDependencies Teacher where
  type Dependencies Teacher = Only SchoolId

Models with multiple dependencies use tuple syntax,

instance HasDependencies Course where
  type Dependencies Course = (SchoolId, TeacherId)

type Dependencies _a = ()

type KeySource a :: KeySourceType

Specify the method for resolving a node's key

This can be

'SourceDefault   -- automatically generate keys from the database
'SourceArbitrary -- automatically generate keys using Arbitrary
'SourceExternal  -- explicitly pass a key using nodeKeyed

Most types will use SourceDefault or SourceArbitrary. Only use SourceExternal if the key for a value is always defined externally.

type KeySource _a = 'SourceDefault

Methods

dependsOn :: a -> Dependencies a -> a

Assign values from the Dependencies collection to a value

This must be an idempotent operation. Law:

(\x d -> x `dependsOn` d `dependsOn` d) = dependsOn

The default, Generic-based implementation will assign values by the order of the fields in the model's type.

default dependsOn :: (HasEot a, HasEot (Dependencies a), GHasDependencies (Proxy a) (Proxy (Dependencies a)) (Eot a) (Eot (Dependencies a))) => a -> Dependencies a -> a

newtype Only a

For entities that only have singular Dependencies

Constructors

Only

Fields

• fromOnly :: a

Instances

Functor Only

Defined in Graphula.Dependencies

Methods

fmap :: (a -> b) -> Only a -> Only b

(<$) :: a -> Only b -> Only a

Foldable Only

Defined in Graphula.Dependencies

Methods

fold :: Monoid m => Only m -> m

foldMap :: Monoid m => (a -> m) -> Only a -> m

foldMap' :: Monoid m => (a -> m) -> Only a -> m

foldr :: (a -> b -> b) -> b -> Only a -> b

foldr' :: (a -> b -> b) -> b -> Only a -> b

foldl :: (b -> a -> b) -> b -> Only a -> b

foldl' :: (b -> a -> b) -> b -> Only a -> b

foldr1 :: (a -> a -> a) -> Only a -> a

foldl1 :: (a -> a -> a) -> Only a -> a

toList :: Only a -> [a]

null :: Only a -> Bool

length :: Only a -> Int

elem :: Eq a => a -> Only a -> Bool

maximum :: Ord a => Only a -> a

minimum :: Ord a => Only a -> a

sum :: Num a => Only a -> a

product :: Num a => Only a -> a

Traversable Only

Defined in Graphula.Dependencies

Methods

traverse :: Applicative f => (a -> f b) -> Only a -> f (Only b)

sequenceA :: Applicative f => Only (f a) -> f (Only a)

mapM :: Monad m => (a -> m b) -> Only a -> m (Only b)

sequence :: Monad m => Only (m a) -> m (Only a)

Eq a => Eq (Only a)

Defined in Graphula.Dependencies

Methods

(==) :: Only a -> Only a -> Bool

(/=) :: Only a -> Only a -> Bool

Ord a => Ord (Only a)

Defined in Graphula.Dependencies

Methods

compare :: Only a -> Only a -> Ordering

(<) :: Only a -> Only a -> Bool

(<=) :: Only a -> Only a -> Bool

(>) :: Only a -> Only a -> Bool

(>=) :: Only a -> Only a -> Bool

max :: Only a -> Only a -> Only a

min :: Only a -> Only a -> Only a

Show a => Show (Only a)

Defined in Graphula.Dependencies

Methods

showsPrec :: Int -> Only a -> ShowS

show :: Only a -> String

showList :: [Only a] -> ShowS

Generic (Only a)

Defined in Graphula.Dependencies

Associated Types

type Rep (Only a) :: Type -> Type

Methods

from :: Only a -> Rep (Only a) x

to :: Rep (Only a) x -> Only a

type Rep (Only a)

Defined in Graphula.Dependencies

type Rep (Only a) = D1 ('MetaData "Only" "Graphula.Dependencies" "graphula-2.0.1.0-1bcslTrN0Du5XbplEVgBP2" 'True) (C1 ('MetaCons "Only" 'PrefixI 'True) (S1 ('MetaSel ('Just "fromOnly") 'NoSourceUnpackedness 'NoSourceStrictness 'DecidedLazy) (Rec0 a)))

type Keys (Only (Entity a))

Defined in Graphula.Key

type Keys (Only (Entity a)) = Only (Key a)

only :: a -> Only a

Non-serial keys

data KeySourceType

Constructors

SourceDefault

Generate keys using the database's DEFAULT strategy

SourceArbitrary

Generate keys using the Arbitrary instance for the Key

SourceExternal

Always explicitly pass an external key

See nodeKeyed.

class (GenerateKeyInternal (KeySource a) a, KeyConstraint (KeySource a) a) => GenerateKey a

Abstract constraint that some a can generate a key

This is part of ensuring better error messages.

Instances

(GenerateKeyInternal (KeySource a) a, KeyConstraint (KeySource a) a) => GenerateKey a

Defined in Graphula.Dependencies

generateKey :: (GenerateKeyInternal s a, KeyConstraint s a) => Gen (Maybe (Key a))