bioshake-0.1.0.0: Bioinformatics pipelines with shake

Safe HaskellNone
LanguageHaskell2010

Bioshake.Types

Description

Core data types the pipeline abstraction.

Synopsis

Documentation

data a :-> b where infixl 1 Source #

Pipes output of phase a into phase b, i.e., forms a pipeline.

Constructors

(:->) :: a -> b -> a :-> b infixl 1 

Instances

(Show a, Show b) => Show ((:->) a b) Source # 

Methods

showsPrec :: Int -> (a :-> b) -> ShowS #

show :: (a :-> b) -> String #

showList :: [a :-> b] -> ShowS #

(Pathable a, Pathable ((:->) a b), Compilable a, Buildable ((:->) a b)) => Compilable ((:->) a b) Source #

A pipeline a :-> b is Compilable to Rules if a is Compilable and we can generate an Action to build a:->b (i.e., a:->b is Buildable). This generates a Rules which builds the paths of a:->b and needs the paths of a.

Methods

compile :: (a :-> b) -> Compiler () Source #

PairedEnd a => PairedEnd ((:->) a b) Source # 
(HasRG a, IsBam ((:->) a b)) => HasRG ((:->) a b) Source # 
DeDuped a => DeDuped ((:->) a b) Source # 
Capture a => Capture ((:->) a b) Source # 

Methods

getBED :: (a :-> b) -> FilePath Source #

Referenced a => Referenced ((:->) a b) Source #

References flows down the pipeline regardless of the phase

Methods

getRef :: (a :-> b) -> FilePath Source #

name :: (a :-> b) -> String Source #

dbnsfp :: (a :-> b) -> FilePath Source #

GC a => GC ((:->) a b) Source # 

Methods

getGC :: (a :-> b) -> FilePath Source #

class Buildable a where Source #

Buildable abstracts things that can be turned into shake Actions.

Minimal complete definition

build

Methods

build :: Implicit Resource => a -> Action () Source #

type Compiler = StateT (Set [FilePath]) Rules Source #

The compiler tracks the set of output files to ensure duplicate Rules are not generated. This allows multiple potentially overlapping pipelines to be compiled down to a set of unique Rules.

compileRules :: Compiler () -> Rules () Source #

Compile pipelines to Rules.

class Compilable a where Source #

Pipelines are Compilable when they can be compiled down to a set of Rules that build a list of output paths.

Methods

compile :: Implicit Resource => a -> Compiler () Source #

Instances

Compilable a => Compilable (All a) Source # 

Methods

compile :: All a -> Compiler () Source #

(Pathable a, Pathable ((:->) a b), Compilable a, Buildable ((:->) a b)) => Compilable ((:->) a b) Source #

A pipeline a :-> b is Compilable to Rules if a is Compilable and we can generate an Action to build a:->b (i.e., a:->b is Buildable). This generates a Rules which builds the paths of a:->b and needs the paths of a.

Methods

compile :: (a :-> b) -> Compiler () Source #

class Pathable a where Source #

Things are pathable if they can be mapped to a list of file paths. This is used to make the files for a phase concrete in the build system.

Minimal complete definition

paths

Methods

paths :: a -> [FilePath] Source #

Instances

Pathable a => Pathable (All a) Source # 

Methods

paths :: All a -> [FilePath] Source #

data Nuc Source #

Constructors

A 
C 
G 
T 

Instances

Eq Nuc Source # 

Methods

(==) :: Nuc -> Nuc -> Bool #

(/=) :: Nuc -> Nuc -> Bool #

Show Nuc Source # 

Methods

showsPrec :: Int -> Nuc -> ShowS #

show :: Nuc -> String #

showList :: [Nuc] -> ShowS #

newtype Seq Source #

Constructors

Seq [Nuc] 

Instances

Eq Seq Source # 

Methods

(==) :: Seq -> Seq -> Bool #

(/=) :: Seq -> Seq -> Bool #

Show Seq Source # 

Methods

showsPrec :: Int -> Seq -> ShowS #

show :: Seq -> String #

showList :: [Seq] -> ShowS #

IsString Seq Source # 

Methods

fromString :: String -> Seq #

data Threads Source #

Constructors

Threads Int 

Instances