Safe Haskell	Safe-Inferred
Language	Haskell2010

Tourney.Algebra.Unified

Contents

Base eDSL
- Operators
  - Overlays of tournaments
  - Sequencing tournaments
Extra Types

Synopsis

data Tournament :: Depth -> Type where
- One :: Match -> Tournament 'TOne
- Empty :: Tournament t
- Modify :: Mod -> Tournament t -> Tournament (TMod t)
- Overlay :: Tournament a -> Tournament a -> Tournament a
- Sequence :: (KnownDepth a, KnownDepth b) => Tournament a -> Tournament b -> Tournament TMany
- Sort :: SortMethod -> Tournament t -> Tournament t
- ByPlayerCount :: (PlayerCount -> Tournament t) -> Tournament t
- ByStandings :: (Standings -> Tournament t) -> Tournament t
- LiftTOne :: Tournament TOne -> Tournament TMany
- LiftTMod :: KnownDepth t => Tournament (TMod t) -> Tournament TMany
data Mod
- = SetFocus !(Focus -> [Focus])
- | SetOffset !Int
(+++) :: Tournament a -> Tournament a -> Tournament a
overlay :: Foldable f => f (Tournament a) -> Tournament a
(***) :: forall a b. (KnownDepth a, KnownDepth b) => Tournament a -> Tournament b -> Tournament TMany
sequence :: (Foldable f, KnownDepth a) => f (Tournament a) -> Tournament TMany
data SortMethod
- = WinnerTakesHigh
- | PointsAward
data Sorter = Sorter {
- sorterFocus :: !Focus
- sorterMethod :: !SortMethod
}
data Focus = Focus {
- focusStart :: !Slot
- focusLength :: !Int
}
data Depth
- = TOne
- | TMany
- | TMod Depth
class Typeable d => KnownDepth (d :: Depth) where
- depthVal :: proxy d -> Depth

Base eDSL

The core primitives and syntax of the journeyman tournament eDSL are defined here. For how these values can be transformed into a flattened stream of rounds, see Tourney.Stream

data Tournament :: Depth -> Type where Source #

A description of a tournament. The type-parameter gives an upper-bound on how many rounds this tournament has. It also ensures that the spine of a tournament is static, regardless of use of constructors such as ByStandings, that enable creating tournaments that depend on match results that are not yet known. Intuitively if you have a tournament with depth TMany, it means it contains multiple rounds, whereas if you have a tournament with depth TOne, then it is only one round.

Constructors

One :: Match -> Tournament 'TOne
Empty :: Tournament t
Modify :: Mod -> Tournament t -> Tournament (TMod t)	Modify a tournament by some `Mod`, such as setting the focus.
Overlay :: Tournament a -> Tournament a -> Tournament a	Overlay two tournaments, to describe running two sub-tournaments in parallel. The depth of the tournaments must be the same
Sequence :: (KnownDepth a, KnownDepth b) => Tournament a -> Tournament b -> Tournament TMany	Sequence two tournaments one after the other. The resulting tournament has a depth `TMany` which restricts what functions are able to manipulate it.
Sort :: SortMethod -> Tournament t -> Tournament t	Sort the inner tournament by some sorting method
ByPlayerCount :: (PlayerCount -> Tournament t) -> Tournament t	Depend on the player count to produce an inner tournament
ByStandings :: (Standings -> Tournament t) -> Tournament t	Depend on the current standings, at the outset of the current round, to run the tournament.
LiftTOne :: Tournament TOne -> Tournament TMany	Lift a single round of a tournament into having a depth `TMany`
LiftTMod :: KnownDepth t => Tournament (TMod t) -> Tournament TMany	Lift a modified round of a tournament into having a depth `TMany`

Instances

Instances details

Monoid (Tournament t) Source #
Instance details Defined in Tourney.Algebra.Unified Methods mempty :: Tournament t Source # mappend :: Tournament t -> Tournament t -> Tournament t Source # mconcat :: [Tournament t] -> Tournament t Source #
Semigroup (Tournament t) Source #
Instance details Defined in Tourney.Algebra.Unified Methods (<>) :: Tournament t -> Tournament t -> Tournament t Source # sconcat :: NonEmpty (Tournament t) -> Tournament t Source # stimes :: Integral b => b -> Tournament t -> Tournament t Source #
Show (Tournament t) Source #
Instance details Defined in Tourney.Algebra.Unified Methods showsPrec :: Int -> Tournament t -> ShowS Source # show :: Tournament t -> String Source # showList :: [Tournament t] -> ShowS Source #
t ~ 'TOne => AsRound (Tournament t) r Source #
Instance details Defined in Tourney.Algebra.Builder Methods toRound :: Tournament t -> Round r () Source #
t ~ 'TMany => AsSteps (Tournament t) r Source #
Instance details Defined in Tourney.Algebra.Builder Methods steps :: Tournament t -> Steps r () Source #

data Mod Source #

Constructors

SetFocus !(Focus -> [Focus])
SetOffset !Int

Operators

Overlays of tournaments

The verb overlay comes from algebraic graph theory, and means to combine two graphs by simply having them coexist in the same graph; no actual edges are drawn.

(+++) :: Tournament a -> Tournament a -> Tournament a infixl 2 Source #

Overlay two tournaments. See Overlay.

overlay :: Foldable f => f (Tournament a) -> Tournament a Source #

Overlay an arbitrary number of tournaments.

Sequencing tournaments

Sequencing means to connect two tournaments by having one happen before the other. A round means a single step of a tournament such as a group of matches.

(***) :: forall a b. (KnownDepth a, KnownDepth b) => Tournament a -> Tournament b -> Tournament TMany infixl 1 Source #

Sequence two tournaments, running them one after the other. See Sequence.

sequence :: (Foldable f, KnownDepth a) => f (Tournament a) -> Tournament TMany Source #

Extra Types

data SortMethod Source #

Constructors

WinnerTakesHigh
PointsAward	Award points and use that to sort the results in the end

Instances

Instances details

Show SortMethod Source #
Instance details Defined in Tourney.Common Methods showsPrec :: Int -> SortMethod -> ShowS Source # show :: SortMethod -> String Source # showList :: [SortMethod] -> ShowS Source #
Default SortMethod Source #
Instance details Defined in Tourney.Common Methods def :: SortMethod Source #
Eq SortMethod Source #
Instance details Defined in Tourney.Common Methods (==) :: SortMethod -> SortMethod -> Bool Source # (/=) :: SortMethod -> SortMethod -> Bool Source #
Ord SortMethod Source #
Instance details Defined in Tourney.Common Methods compare :: SortMethod -> SortMethod -> Ordering Source # (<) :: SortMethod -> SortMethod -> Bool Source # (<=) :: SortMethod -> SortMethod -> Bool Source # (>) :: SortMethod -> SortMethod -> Bool Source # (>=) :: SortMethod -> SortMethod -> Bool Source # max :: SortMethod -> SortMethod -> SortMethod Source # min :: SortMethod -> SortMethod -> SortMethod Source #

data Sorter Source #

Constructors

Sorter
Fields sorterFocus :: !Focus sorterMethod :: !SortMethod

Instances

Instances details

Generic Sorter Source #
Instance details Defined in Tourney.Common Associated Types type Rep Sorter :: Type -> Type Source # Methods from :: Sorter -> Rep Sorter x Source # to :: Rep Sorter x -> Sorter Source #
Show Sorter Source #
Instance details Defined in Tourney.Common Methods showsPrec :: Int -> Sorter -> ShowS Source # show :: Sorter -> String Source # showList :: [Sorter] -> ShowS Source #
Eq Sorter Source #
Instance details Defined in Tourney.Common Methods (==) :: Sorter -> Sorter -> Bool Source # (/=) :: Sorter -> Sorter -> Bool Source #
type Rep Sorter Source #
Instance details Defined in Tourney.Common type Rep Sorter = D1 ('MetaData "Sorter" "Tourney.Common" "journeyman-0.1.0.0-inplace" 'False) (C1 ('MetaCons "Sorter" 'PrefixI 'True) (S1 ('MetaSel ('Just "sorterFocus") 'NoSourceUnpackedness 'SourceStrict 'DecidedStrict) (Rec0 Focus) :*: S1 ('MetaSel ('Just "sorterMethod") 'NoSourceUnpackedness 'SourceStrict 'DecidedStrict) (Rec0 SortMethod)))

data Focus Source #

The focus of a tournament over a sorting network. A good intuition is that a Focus is basically an array slice over a round.

Constructors

Focus
Fields focusStart :: !Slot focusLength :: !Int

Instances

Instances details

Generic Focus Source #
Instance details Defined in Tourney.Common Associated Types type Rep Focus :: Type -> Type Source # Methods from :: Focus -> Rep Focus x Source # to :: Rep Focus x -> Focus Source #
Show Focus Source #
Instance details Defined in Tourney.Common Methods showsPrec :: Int -> Focus -> ShowS Source # show :: Focus -> String Source # showList :: [Focus] -> ShowS Source #
Eq Focus Source #
Instance details Defined in Tourney.Common Methods (==) :: Focus -> Focus -> Bool Source # (/=) :: Focus -> Focus -> Bool Source #
Ord Focus Source #
Instance details Defined in Tourney.Common Methods compare :: Focus -> Focus -> Ordering Source # (<) :: Focus -> Focus -> Bool Source # (<=) :: Focus -> Focus -> Bool Source # (>) :: Focus -> Focus -> Bool Source # (>=) :: Focus -> Focus -> Bool Source # max :: Focus -> Focus -> Focus Source # min :: Focus -> Focus -> Focus Source #
type Rep Focus Source #
Instance details Defined in Tourney.Common type Rep Focus = D1 ('MetaData "Focus" "Tourney.Common" "journeyman-0.1.0.0-inplace" 'False) (C1 ('MetaCons "Focus" 'PrefixI 'True) (S1 ('MetaSel ('Just "focusStart") 'NoSourceUnpackedness 'SourceStrict 'DecidedStrict) (Rec0 Slot) :*: S1 ('MetaSel ('Just "focusLength") 'NoSourceUnpackedness 'SourceStrict 'DecidedStrict) (Rec0 Int)))

data Depth Source #

The depth of a tournament. Since we only care about distinguishing single rounds from sequences of rounds, that is the only information stored here.

Constructors

TOne
TMany
TMod Depth

class Typeable d => KnownDepth (d :: Depth) where Source #

Methods

depthVal :: proxy d -> Depth Source #

Instances

Instances details

KnownDepth 'TMany Source #
Instance details Defined in Tourney.Algebra.Unified Methods depthVal :: proxy 'TMany -> Depth Source #
KnownDepth 'TOne Source #
Instance details Defined in Tourney.Algebra.Unified Methods depthVal :: proxy 'TOne -> Depth Source #
KnownDepth d => KnownDepth ('TMod d) Source #
Instance details Defined in Tourney.Algebra.Unified Methods depthVal :: proxy ('TMod d) -> Depth Source #