{-# LANGUAGE OverloadedStrings #-}
{-# LANGUAGE TemplateHaskell #-}
{-# LANGUAGE StrictData #-}
{-# LANGUAGE DeriveGeneric, DeriveAnyClass #-}

module Bio.Data.Bed.Types
    ( BEDLike(..)
    , BEDConvert(..)
    , BED(..)
    , BED3(..)
    , BEDGraph(..)
    , bdgValue
    , NarrowPeak(..)
    , npSignal
    , npPvalue
    , npQvalue
    , npPeak
    , BroadPeak(..)
    , bpSignal
    , bpPvalue
    , bpQvalue
    , BEDExt(..)
    , _bed
    , _data
    , BEDTree
    , Sorted(..)
    ) where

import Lens.Micro
import Lens.Micro.TH (makeLensesFor)
import qualified Data.ByteString.Char8             as B
import           Data.ByteString.Lex.Integral      (packDecimal)
import           Data.Double.Conversion.ByteString (toShortest)
import qualified Data.HashMap.Strict               as M
import qualified Data.IntervalMap.Strict           as IM
import           Data.Maybe                        (fromJust, fromMaybe)
import GHC.Generics (Generic)
import Control.DeepSeq (NFData)

import           Bio.Utils.Misc                    (readDouble, readInt)

readDoubleNonnegative :: B.ByteString -> Maybe Double
readDoubleNonnegative :: ByteString -> Maybe Double
readDoubleNonnegative ByteString
x | Double
v Double -> Double -> Bool
forall a. Ord a => a -> a -> Bool
< Double
0 = Maybe Double
forall a. Maybe a
Nothing
                        | Bool
otherwise = Double -> Maybe Double
forall a. a -> Maybe a
Just Double
v
  where
    v :: Double
v = ByteString -> Double
readDouble ByteString
x
{-# INLINE readDoubleNonnegative #-}

readIntNonnegative :: B.ByteString -> Maybe Int
readIntNonnegative :: ByteString -> Maybe Int
readIntNonnegative ByteString
x | Int
v Int -> Int -> Bool
forall a. Ord a => a -> a -> Bool
< Int
0 = Maybe Int
forall a. Maybe a
Nothing
                     | Bool
otherwise = Int -> Maybe Int
forall a. a -> Maybe a
Just Int
v
  where
    v :: Int
v = ByteString -> Int
readInt ByteString
x
{-# INLINE readIntNonnegative #-}

-- | A class representing BED-like data, e.g., BED3, BED6 and BED12. BED format
-- uses 0-based index (see documentation).
class BEDLike b where
    -- | Field lens
    chrom :: Lens' b B.ByteString
    chromStart :: Lens' b Int
    chromEnd :: Lens' b Int
    name :: Lens' b (Maybe B.ByteString)
    score :: Lens' b (Maybe Int)
    strand :: Lens' b (Maybe Bool)

    -- | Return the size of a bed region.
    size :: b -> Int
    size b
bed = b
bedb -> Getting Int b Int -> Int
forall s a. s -> Getting a s a -> a
^.Getting Int b Int
forall b. BEDLike b => Lens' b Int
chromEnd Int -> Int -> Int
forall a. Num a => a -> a -> a
- b
bedb -> Getting Int b Int -> Int
forall s a. s -> Getting a s a -> a
^.Getting Int b Int
forall b. BEDLike b => Lens' b Int
chromStart
    {-# INLINE size #-}

    {-# MINIMAL chrom, chromStart, chromEnd, name, score, strand #-}

class BEDLike b => BEDConvert b where
    -- | Construct bed record from chromsomoe, start location and end location
    asBed :: B.ByteString -> Int -> Int -> b

    -- | Convert bytestring to bed format
    fromLine :: B.ByteString -> b

    -- | Convert bed to bytestring
    toLine :: b -> B.ByteString

    convert :: BEDLike b' => b' -> b
    convert b'
bed = ByteString -> Int -> Int -> b
forall b. BEDConvert b => ByteString -> Int -> Int -> b
asBed (b'
bedb' -> Getting ByteString b' ByteString -> ByteString
forall s a. s -> Getting a s a -> a
^.Getting ByteString b' ByteString
forall b. BEDLike b => Lens' b ByteString
chrom) (b'
bedb' -> Getting Int b' Int -> Int
forall s a. s -> Getting a s a -> a
^.Getting Int b' Int
forall b. BEDLike b => Lens' b Int
chromStart) (b'
bedb' -> Getting Int b' Int -> Int
forall s a. s -> Getting a s a -> a
^.Getting Int b' Int
forall b. BEDLike b => Lens' b Int
chromEnd)
    {-# INLINE convert #-}

    {-# MINIMAL asBed, fromLine, toLine #-}

-- * BED6 format

-- | BED6 format, as described in http://genome.ucsc.edu/FAQ/FAQformat.html#format1.7
data BED = BED
    { BED -> ByteString
_bed_chrom      :: B.ByteString
    , BED -> Int
_bed_chromStart :: Int
    , BED -> Int
_bed_chromEnd   :: Int
    , BED -> Maybe ByteString
_bed_name       :: Maybe B.ByteString
    , BED -> Maybe Int
_bed_score      :: Maybe Int
    , BED -> Maybe Bool
_bed_strand     :: Maybe Bool  -- ^ True: "+", False: "-"
    } deriving (BED -> BED -> Bool
(BED -> BED -> Bool) -> (BED -> BED -> Bool) -> Eq BED
forall a. (a -> a -> Bool) -> (a -> a -> Bool) -> Eq a
/= :: BED -> BED -> Bool
$c/= :: BED -> BED -> Bool
== :: BED -> BED -> Bool
$c== :: BED -> BED -> Bool
Eq, Int -> BED -> ShowS
[BED] -> ShowS
BED -> String
(Int -> BED -> ShowS)
-> (BED -> String) -> ([BED] -> ShowS) -> Show BED
forall a.
(Int -> a -> ShowS) -> (a -> String) -> ([a] -> ShowS) -> Show a
showList :: [BED] -> ShowS
$cshowList :: [BED] -> ShowS
show :: BED -> String
$cshow :: BED -> String
showsPrec :: Int -> BED -> ShowS
$cshowsPrec :: Int -> BED -> ShowS
Show, ReadPrec [BED]
ReadPrec BED
Int -> ReadS BED
ReadS [BED]
(Int -> ReadS BED)
-> ReadS [BED] -> ReadPrec BED -> ReadPrec [BED] -> Read BED
forall a.
(Int -> ReadS a)
-> ReadS [a] -> ReadPrec a -> ReadPrec [a] -> Read a
readListPrec :: ReadPrec [BED]
$creadListPrec :: ReadPrec [BED]
readPrec :: ReadPrec BED
$creadPrec :: ReadPrec BED
readList :: ReadS [BED]
$creadList :: ReadS [BED]
readsPrec :: Int -> ReadS BED
$creadsPrec :: Int -> ReadS BED
Read, (forall x. BED -> Rep BED x)
-> (forall x. Rep BED x -> BED) -> Generic BED
forall x. Rep BED x -> BED
forall x. BED -> Rep BED x
forall a.
(forall x. a -> Rep a x) -> (forall x. Rep a x -> a) -> Generic a
$cto :: forall x. Rep BED x -> BED
$cfrom :: forall x. BED -> Rep BED x
Generic, BED -> ()
(BED -> ()) -> NFData BED
forall a. (a -> ()) -> NFData a
rnf :: BED -> ()
$crnf :: BED -> ()
NFData)

instance Ord BED where
    compare :: BED -> BED -> Ordering
compare (BED ByteString
x1 Int
x2 Int
x3 Maybe ByteString
x4 Maybe Int
x5 Maybe Bool
x6) (BED ByteString
y1 Int
y2 Int
y3 Maybe ByteString
y4 Maybe Int
y5 Maybe Bool
y6) =
        (ByteString, Int, Int, Maybe ByteString, Maybe Int, Maybe Bool)
-> (ByteString, Int, Int, Maybe ByteString, Maybe Int, Maybe Bool)
-> Ordering
forall a. Ord a => a -> a -> Ordering
compare (ByteString
x1,Int
x2,Int
x3,Maybe ByteString
x4,Maybe Int
x5,Maybe Bool
x6) (ByteString
y1,Int
y2,Int
y3,Maybe ByteString
y4,Maybe Int
y5,Maybe Bool
y6)

instance BEDLike BED where
    chrom :: (ByteString -> f ByteString) -> BED -> f BED
chrom = (BED -> ByteString)
-> (BED -> ByteString -> BED) -> Lens' BED ByteString
forall s a b t. (s -> a) -> (s -> b -> t) -> Lens s t a b
lens BED -> ByteString
_bed_chrom (\BED
bed ByteString
x -> BED
bed { _bed_chrom :: ByteString
_bed_chrom = ByteString
x })
    chromStart :: (Int -> f Int) -> BED -> f BED
chromStart = (BED -> Int) -> (BED -> Int -> BED) -> Lens' BED Int
forall s a b t. (s -> a) -> (s -> b -> t) -> Lens s t a b
lens BED -> Int
_bed_chromStart (\BED
bed Int
x -> BED
bed { _bed_chromStart :: Int
_bed_chromStart = Int
x })
    chromEnd :: (Int -> f Int) -> BED -> f BED
chromEnd = (BED -> Int) -> (BED -> Int -> BED) -> Lens' BED Int
forall s a b t. (s -> a) -> (s -> b -> t) -> Lens s t a b
lens BED -> Int
_bed_chromEnd (\BED
bed Int
x -> BED
bed { _bed_chromEnd :: Int
_bed_chromEnd = Int
x })
    name :: (Maybe ByteString -> f (Maybe ByteString)) -> BED -> f BED
name = (BED -> Maybe ByteString)
-> (BED -> Maybe ByteString -> BED) -> Lens' BED (Maybe ByteString)
forall s a b t. (s -> a) -> (s -> b -> t) -> Lens s t a b
lens BED -> Maybe ByteString
_bed_name (\BED
bed Maybe ByteString
x -> BED
bed { _bed_name :: Maybe ByteString
_bed_name = Maybe ByteString
x })
    score :: (Maybe Int -> f (Maybe Int)) -> BED -> f BED
score = (BED -> Maybe Int)
-> (BED -> Maybe Int -> BED) -> Lens' BED (Maybe Int)
forall s a b t. (s -> a) -> (s -> b -> t) -> Lens s t a b
lens BED -> Maybe Int
_bed_score (\BED
bed Maybe Int
x -> BED
bed { _bed_score :: Maybe Int
_bed_score = Maybe Int
x })
    strand :: (Maybe Bool -> f (Maybe Bool)) -> BED -> f BED
strand = (BED -> Maybe Bool)
-> (BED -> Maybe Bool -> BED) -> Lens' BED (Maybe Bool)
forall s a b t. (s -> a) -> (s -> b -> t) -> Lens s t a b
lens BED -> Maybe Bool
_bed_strand (\BED
bed Maybe Bool
x -> BED
bed { _bed_strand :: Maybe Bool
_bed_strand = Maybe Bool
x })

instance BEDConvert BED where
    asBed :: ByteString -> Int -> Int -> BED
asBed ByteString
chr Int
s Int
e = ByteString
-> Int -> Int -> Maybe ByteString -> Maybe Int -> Maybe Bool -> BED
BED ByteString
chr Int
s Int
e Maybe ByteString
forall a. Maybe a
Nothing Maybe Int
forall a. Maybe a
Nothing Maybe Bool
forall a. Maybe a
Nothing

    fromLine :: ByteString -> BED
fromLine ByteString
l = [ByteString] -> BED
f ([ByteString] -> BED) -> [ByteString] -> BED
forall a b. (a -> b) -> a -> b
$ Int -> [ByteString] -> [ByteString]
forall a. Int -> [a] -> [a]
take Int
6 ([ByteString] -> [ByteString]) -> [ByteString] -> [ByteString]
forall a b. (a -> b) -> a -> b
$ Char -> ByteString -> [ByteString]
B.split Char
'\t' ByteString
l
      where
        f :: [ByteString] -> BED
f [ByteString
f1,ByteString
f2,ByteString
f3,ByteString
f4,ByteString
f5,ByteString
f6] = ByteString
-> Int -> Int -> Maybe ByteString -> Maybe Int -> Maybe Bool -> BED
BED ByteString
f1 (ByteString -> Int
readInt ByteString
f2) (ByteString -> Int
readInt ByteString
f3) (ByteString -> Maybe ByteString
forall a. (Eq a, IsString a) => a -> Maybe a
getName ByteString
f4)
            (ByteString -> Maybe Int
getScore ByteString
f5) (ByteString -> Maybe Bool
forall a. (Eq a, IsString a) => a -> Maybe Bool
getStrand ByteString
f6)
        f [ByteString
f1,ByteString
f2,ByteString
f3,ByteString
f4,ByteString
f5] = ByteString
-> Int -> Int -> Maybe ByteString -> Maybe Int -> Maybe Bool -> BED
BED ByteString
f1 (ByteString -> Int
readInt ByteString
f2) (ByteString -> Int
readInt ByteString
f3) (ByteString -> Maybe ByteString
forall a. (Eq a, IsString a) => a -> Maybe a
getName ByteString
f4)
            (ByteString -> Maybe Int
getScore ByteString
f5) Maybe Bool
forall a. Maybe a
Nothing
        f [ByteString
f1,ByteString
f2,ByteString
f3,ByteString
f4] = ByteString
-> Int -> Int -> Maybe ByteString -> Maybe Int -> Maybe Bool -> BED
BED ByteString
f1 (ByteString -> Int
readInt ByteString
f2) (ByteString -> Int
readInt ByteString
f3) (ByteString -> Maybe ByteString
forall a. (Eq a, IsString a) => a -> Maybe a
getName ByteString
f4)
            Maybe Int
forall a. Maybe a
Nothing Maybe Bool
forall a. Maybe a
Nothing
        f [ByteString
f1,ByteString
f2,ByteString
f3] = ByteString -> Int -> Int -> BED
forall b. BEDConvert b => ByteString -> Int -> Int -> b
asBed ByteString
f1 (ByteString -> Int
readInt ByteString
f2) (ByteString -> Int
readInt ByteString
f3)
        f [ByteString]
_ = String -> BED
forall a. HasCallStack => String -> a
error String
"Read BED fail: Not enough fields!"
        getName :: a -> Maybe a
getName a
x | a
x a -> a -> Bool
forall a. Eq a => a -> a -> Bool
== a
"." = Maybe a
forall a. Maybe a
Nothing
                  | Bool
otherwise = a -> Maybe a
forall a. a -> Maybe a
Just a
x
        getScore :: ByteString -> Maybe Int
getScore ByteString
x | ByteString
x ByteString -> ByteString -> Bool
forall a. Eq a => a -> a -> Bool
== ByteString
"." = Maybe Int
forall a. Maybe a
Nothing
                   | Int
s Int -> Int -> Bool
forall a. Ord a => a -> a -> Bool
>= Int
0 = Int -> Maybe Int
forall a. a -> Maybe a
Just Int
s
                   | Bool
otherwise = String -> Maybe Int
forall a. HasCallStack => String -> a
error String
"Read BED fail: score must be greater than 0"
          where
            s :: Int
s = ByteString -> Int
readInt ByteString
x
        getStrand :: a -> Maybe Bool
getStrand a
str | a
str a -> a -> Bool
forall a. Eq a => a -> a -> Bool
== a
"-" = Bool -> Maybe Bool
forall a. a -> Maybe a
Just Bool
False
                      | a
str a -> a -> Bool
forall a. Eq a => a -> a -> Bool
== a
"+" = Bool -> Maybe Bool
forall a. a -> Maybe a
Just Bool
True
                      | Bool
otherwise = Maybe Bool
forall a. Maybe a
Nothing
    {-# INLINE fromLine #-}

    toLine :: BED -> ByteString
toLine (BED ByteString
f1 Int
f2 Int
f3 Maybe ByteString
f4 Maybe Int
f5 Maybe Bool
f6) = ByteString -> [ByteString] -> ByteString
B.intercalate ByteString
"\t"
        [ ByteString
f1, Maybe ByteString -> ByteString
forall a. HasCallStack => Maybe a -> a
fromJust (Maybe ByteString -> ByteString) -> Maybe ByteString -> ByteString
forall a b. (a -> b) -> a -> b
$ Int -> Maybe ByteString
forall a. Integral a => a -> Maybe ByteString
packDecimal Int
f2, Maybe ByteString -> ByteString
forall a. HasCallStack => Maybe a -> a
fromJust (Maybe ByteString -> ByteString) -> Maybe ByteString -> ByteString
forall a b. (a -> b) -> a -> b
$ Int -> Maybe ByteString
forall a. Integral a => a -> Maybe ByteString
packDecimal Int
f3
        , ByteString -> Maybe ByteString -> ByteString
forall a. a -> Maybe a -> a
fromMaybe ByteString
"." Maybe ByteString
f4, ByteString
score', ByteString
strand' ]
      where
        strand' :: ByteString
strand' | Maybe Bool
f6 Maybe Bool -> Maybe Bool -> Bool
forall a. Eq a => a -> a -> Bool
== Bool -> Maybe Bool
forall a. a -> Maybe a
Just Bool
True = ByteString
"+"
                | Maybe Bool
f6 Maybe Bool -> Maybe Bool -> Bool
forall a. Eq a => a -> a -> Bool
== Bool -> Maybe Bool
forall a. a -> Maybe a
Just Bool
False = ByteString
"-"
                | Bool
otherwise = ByteString
"."
        score' :: ByteString
score' = case Maybe Int
f5 of
                     Just Int
x -> Maybe ByteString -> ByteString
forall a. HasCallStack => Maybe a -> a
fromJust (Maybe ByteString -> ByteString) -> Maybe ByteString -> ByteString
forall a b. (a -> b) -> a -> b
$ Int -> Maybe ByteString
forall a. Integral a => a -> Maybe ByteString
packDecimal Int
x
                     Maybe Int
_      -> ByteString
"."
    {-# INLINE toLine #-}

    convert :: b' -> BED
convert b'
bed = ByteString
-> Int -> Int -> Maybe ByteString -> Maybe Int -> Maybe Bool -> BED
BED (b'
bedb' -> Getting ByteString b' ByteString -> ByteString
forall s a. s -> Getting a s a -> a
^.Getting ByteString b' ByteString
forall b. BEDLike b => Lens' b ByteString
chrom) (b'
bedb' -> Getting Int b' Int -> Int
forall s a. s -> Getting a s a -> a
^.Getting Int b' Int
forall b. BEDLike b => Lens' b Int
chromStart) (b'
bedb' -> Getting Int b' Int -> Int
forall s a. s -> Getting a s a -> a
^.Getting Int b' Int
forall b. BEDLike b => Lens' b Int
chromEnd) (b'
bedb'
-> Getting (Maybe ByteString) b' (Maybe ByteString)
-> Maybe ByteString
forall s a. s -> Getting a s a -> a
^.Getting (Maybe ByteString) b' (Maybe ByteString)
forall b. BEDLike b => Lens' b (Maybe ByteString)
name)
                      (b'
bedb' -> Getting (Maybe Int) b' (Maybe Int) -> Maybe Int
forall s a. s -> Getting a s a -> a
^.Getting (Maybe Int) b' (Maybe Int)
forall b. BEDLike b => Lens' b (Maybe Int)
score) (b'
bedb' -> Getting (Maybe Bool) b' (Maybe Bool) -> Maybe Bool
forall s a. s -> Getting a s a -> a
^.Getting (Maybe Bool) b' (Maybe Bool)
forall b. BEDLike b => Lens' b (Maybe Bool)
strand)

-- | BED3 format
data BED3 = BED3
    { BED3 -> ByteString
_bed3_chrom       :: B.ByteString
    , BED3 -> Int
_bed3_chrom_start :: Int
    , BED3 -> Int
_bed3_chrom_end   :: Int
    } deriving (BED3 -> BED3 -> Bool
(BED3 -> BED3 -> Bool) -> (BED3 -> BED3 -> Bool) -> Eq BED3
forall a. (a -> a -> Bool) -> (a -> a -> Bool) -> Eq a
/= :: BED3 -> BED3 -> Bool
$c/= :: BED3 -> BED3 -> Bool
== :: BED3 -> BED3 -> Bool
$c== :: BED3 -> BED3 -> Bool
Eq, Int -> BED3 -> ShowS
[BED3] -> ShowS
BED3 -> String
(Int -> BED3 -> ShowS)
-> (BED3 -> String) -> ([BED3] -> ShowS) -> Show BED3
forall a.
(Int -> a -> ShowS) -> (a -> String) -> ([a] -> ShowS) -> Show a
showList :: [BED3] -> ShowS
$cshowList :: [BED3] -> ShowS
show :: BED3 -> String
$cshow :: BED3 -> String
showsPrec :: Int -> BED3 -> ShowS
$cshowsPrec :: Int -> BED3 -> ShowS
Show, ReadPrec [BED3]
ReadPrec BED3
Int -> ReadS BED3
ReadS [BED3]
(Int -> ReadS BED3)
-> ReadS [BED3] -> ReadPrec BED3 -> ReadPrec [BED3] -> Read BED3
forall a.
(Int -> ReadS a)
-> ReadS [a] -> ReadPrec a -> ReadPrec [a] -> Read a
readListPrec :: ReadPrec [BED3]
$creadListPrec :: ReadPrec [BED3]
readPrec :: ReadPrec BED3
$creadPrec :: ReadPrec BED3
readList :: ReadS [BED3]
$creadList :: ReadS [BED3]
readsPrec :: Int -> ReadS BED3
$creadsPrec :: Int -> ReadS BED3
Read, (forall x. BED3 -> Rep BED3 x)
-> (forall x. Rep BED3 x -> BED3) -> Generic BED3
forall x. Rep BED3 x -> BED3
forall x. BED3 -> Rep BED3 x
forall a.
(forall x. a -> Rep a x) -> (forall x. Rep a x -> a) -> Generic a
$cto :: forall x. Rep BED3 x -> BED3
$cfrom :: forall x. BED3 -> Rep BED3 x
Generic, BED3 -> ()
(BED3 -> ()) -> NFData BED3
forall a. (a -> ()) -> NFData a
rnf :: BED3 -> ()
$crnf :: BED3 -> ()
NFData)

instance Ord BED3 where
    compare :: BED3 -> BED3 -> Ordering
compare (BED3 ByteString
x1 Int
x2 Int
x3) (BED3 ByteString
y1 Int
y2 Int
y3) = (ByteString, Int, Int) -> (ByteString, Int, Int) -> Ordering
forall a. Ord a => a -> a -> Ordering
compare (ByteString
x1,Int
x2,Int
x3) (ByteString
y1,Int
y2,Int
y3)

instance BEDLike BED3 where
    chrom :: (ByteString -> f ByteString) -> BED3 -> f BED3
chrom = (BED3 -> ByteString)
-> (BED3 -> ByteString -> BED3) -> Lens' BED3 ByteString
forall s a b t. (s -> a) -> (s -> b -> t) -> Lens s t a b
lens BED3 -> ByteString
_bed3_chrom (\BED3
bed ByteString
x -> BED3
bed { _bed3_chrom :: ByteString
_bed3_chrom = ByteString
x })
    chromStart :: (Int -> f Int) -> BED3 -> f BED3
chromStart = (BED3 -> Int) -> (BED3 -> Int -> BED3) -> Lens' BED3 Int
forall s a b t. (s -> a) -> (s -> b -> t) -> Lens s t a b
lens BED3 -> Int
_bed3_chrom_start (\BED3
bed Int
x -> BED3
bed { _bed3_chrom_start :: Int
_bed3_chrom_start = Int
x })
    chromEnd :: (Int -> f Int) -> BED3 -> f BED3
chromEnd = (BED3 -> Int) -> (BED3 -> Int -> BED3) -> Lens' BED3 Int
forall s a b t. (s -> a) -> (s -> b -> t) -> Lens s t a b
lens BED3 -> Int
_bed3_chrom_end (\BED3
bed Int
x -> BED3
bed { _bed3_chrom_end :: Int
_bed3_chrom_end = Int
x })
    name :: (Maybe ByteString -> f (Maybe ByteString)) -> BED3 -> f BED3
name = (BED3 -> Maybe ByteString)
-> (BED3 -> Maybe ByteString -> BED3)
-> Lens' BED3 (Maybe ByteString)
forall s a b t. (s -> a) -> (s -> b -> t) -> Lens s t a b
lens (Maybe ByteString -> BED3 -> Maybe ByteString
forall a b. a -> b -> a
const Maybe ByteString
forall a. Maybe a
Nothing) (\BED3
bed Maybe ByteString
_ -> BED3
bed)
    score :: (Maybe Int -> f (Maybe Int)) -> BED3 -> f BED3
score = (BED3 -> Maybe Int)
-> (BED3 -> Maybe Int -> BED3) -> Lens' BED3 (Maybe Int)
forall s a b t. (s -> a) -> (s -> b -> t) -> Lens s t a b
lens (Maybe Int -> BED3 -> Maybe Int
forall a b. a -> b -> a
const Maybe Int
forall a. Maybe a
Nothing) (\BED3
bed Maybe Int
_ -> BED3
bed)
    strand :: (Maybe Bool -> f (Maybe Bool)) -> BED3 -> f BED3
strand = (BED3 -> Maybe Bool)
-> (BED3 -> Maybe Bool -> BED3) -> Lens' BED3 (Maybe Bool)
forall s a b t. (s -> a) -> (s -> b -> t) -> Lens s t a b
lens (Maybe Bool -> BED3 -> Maybe Bool
forall a b. a -> b -> a
const Maybe Bool
forall a. Maybe a
Nothing) (\BED3
bed Maybe Bool
_ -> BED3
bed)

instance BEDConvert BED3 where
    asBed :: ByteString -> Int -> Int -> BED3
asBed = ByteString -> Int -> Int -> BED3
BED3

    fromLine :: ByteString -> BED3
fromLine ByteString
l = case Char -> ByteString -> [ByteString]
B.split Char
'\t' ByteString
l of
                    (ByteString
a:ByteString
b:ByteString
c:[ByteString]
_) -> ByteString -> Int -> Int -> BED3
BED3 ByteString
a (ByteString -> Int
readInt ByteString
b) (Int -> BED3) -> Int -> BED3
forall a b. (a -> b) -> a -> b
$ ByteString -> Int
readInt ByteString
c
                    [ByteString]
_ -> String -> BED3
forall a. HasCallStack => String -> a
error String
"Read BED fail: Incorrect number of fields"
    {-# INLINE fromLine #-}

    toLine :: BED3 -> ByteString
toLine (BED3 ByteString
a Int
b Int
c) = ByteString -> [ByteString] -> ByteString
B.intercalate ByteString
"\t"
        [ByteString
a, Maybe ByteString -> ByteString
forall a. HasCallStack => Maybe a -> a
fromJust (Maybe ByteString -> ByteString) -> Maybe ByteString -> ByteString
forall a b. (a -> b) -> a -> b
$ Int -> Maybe ByteString
forall a. Integral a => a -> Maybe ByteString
packDecimal Int
b, Maybe ByteString -> ByteString
forall a. HasCallStack => Maybe a -> a
fromJust (Maybe ByteString -> ByteString) -> Maybe ByteString -> ByteString
forall a b. (a -> b) -> a -> b
$ Int -> Maybe ByteString
forall a. Integral a => a -> Maybe ByteString
packDecimal Int
c]
    {-# INLINE toLine #-}

-- | Bedgraph format.
data BEDGraph = BEDGraph
    { BEDGraph -> ByteString
_bdg_chrom       :: B.ByteString
    , BEDGraph -> Int
_bdg_chrom_start :: Int
    , BEDGraph -> Int
_bdg_chrom_end   :: Int
    , BEDGraph -> Double
_bdg_value       :: Double
    } deriving (BEDGraph -> BEDGraph -> Bool
(BEDGraph -> BEDGraph -> Bool)
-> (BEDGraph -> BEDGraph -> Bool) -> Eq BEDGraph
forall a. (a -> a -> Bool) -> (a -> a -> Bool) -> Eq a
/= :: BEDGraph -> BEDGraph -> Bool
$c/= :: BEDGraph -> BEDGraph -> Bool
== :: BEDGraph -> BEDGraph -> Bool
$c== :: BEDGraph -> BEDGraph -> Bool
Eq, Int -> BEDGraph -> ShowS
[BEDGraph] -> ShowS
BEDGraph -> String
(Int -> BEDGraph -> ShowS)
-> (BEDGraph -> String) -> ([BEDGraph] -> ShowS) -> Show BEDGraph
forall a.
(Int -> a -> ShowS) -> (a -> String) -> ([a] -> ShowS) -> Show a
showList :: [BEDGraph] -> ShowS
$cshowList :: [BEDGraph] -> ShowS
show :: BEDGraph -> String
$cshow :: BEDGraph -> String
showsPrec :: Int -> BEDGraph -> ShowS
$cshowsPrec :: Int -> BEDGraph -> ShowS
Show, ReadPrec [BEDGraph]
ReadPrec BEDGraph
Int -> ReadS BEDGraph
ReadS [BEDGraph]
(Int -> ReadS BEDGraph)
-> ReadS [BEDGraph]
-> ReadPrec BEDGraph
-> ReadPrec [BEDGraph]
-> Read BEDGraph
forall a.
(Int -> ReadS a)
-> ReadS [a] -> ReadPrec a -> ReadPrec [a] -> Read a
readListPrec :: ReadPrec [BEDGraph]
$creadListPrec :: ReadPrec [BEDGraph]
readPrec :: ReadPrec BEDGraph
$creadPrec :: ReadPrec BEDGraph
readList :: ReadS [BEDGraph]
$creadList :: ReadS [BEDGraph]
readsPrec :: Int -> ReadS BEDGraph
$creadsPrec :: Int -> ReadS BEDGraph
Read, (forall x. BEDGraph -> Rep BEDGraph x)
-> (forall x. Rep BEDGraph x -> BEDGraph) -> Generic BEDGraph
forall x. Rep BEDGraph x -> BEDGraph
forall x. BEDGraph -> Rep BEDGraph x
forall a.
(forall x. a -> Rep a x) -> (forall x. Rep a x -> a) -> Generic a
$cto :: forall x. Rep BEDGraph x -> BEDGraph
$cfrom :: forall x. BEDGraph -> Rep BEDGraph x
Generic, BEDGraph -> ()
(BEDGraph -> ()) -> NFData BEDGraph
forall a. (a -> ()) -> NFData a
rnf :: BEDGraph -> ()
$crnf :: BEDGraph -> ()
NFData)

makeLensesFor [("_bdg_value", "bdgValue")] ''BEDGraph

instance Ord BEDGraph where
    compare :: BEDGraph -> BEDGraph -> Ordering
compare (BEDGraph ByteString
x1 Int
x2 Int
x3 Double
x4) (BEDGraph ByteString
y1 Int
y2 Int
y3 Double
y4) =
        (ByteString, Int, Int, Double)
-> (ByteString, Int, Int, Double) -> Ordering
forall a. Ord a => a -> a -> Ordering
compare (ByteString
x1,Int
x2,Int
x3,Double
x4) (ByteString
y1,Int
y2,Int
y3,Double
y4)

instance BEDLike BEDGraph where
    chrom :: (ByteString -> f ByteString) -> BEDGraph -> f BEDGraph
chrom = (BEDGraph -> ByteString)
-> (BEDGraph -> ByteString -> BEDGraph)
-> Lens' BEDGraph ByteString
forall s a b t. (s -> a) -> (s -> b -> t) -> Lens s t a b
lens BEDGraph -> ByteString
_bdg_chrom (\BEDGraph
bed ByteString
x -> BEDGraph
bed { _bdg_chrom :: ByteString
_bdg_chrom = ByteString
x })
    chromStart :: (Int -> f Int) -> BEDGraph -> f BEDGraph
chromStart = (BEDGraph -> Int)
-> (BEDGraph -> Int -> BEDGraph) -> Lens' BEDGraph Int
forall s a b t. (s -> a) -> (s -> b -> t) -> Lens s t a b
lens BEDGraph -> Int
_bdg_chrom_start (\BEDGraph
bed Int
x -> BEDGraph
bed { _bdg_chrom_start :: Int
_bdg_chrom_start = Int
x })
    chromEnd :: (Int -> f Int) -> BEDGraph -> f BEDGraph
chromEnd = (BEDGraph -> Int)
-> (BEDGraph -> Int -> BEDGraph) -> Lens' BEDGraph Int
forall s a b t. (s -> a) -> (s -> b -> t) -> Lens s t a b
lens BEDGraph -> Int
_bdg_chrom_end (\BEDGraph
bed Int
x -> BEDGraph
bed { _bdg_chrom_end :: Int
_bdg_chrom_end = Int
x })
    name :: (Maybe ByteString -> f (Maybe ByteString))
-> BEDGraph -> f BEDGraph
name = (BEDGraph -> Maybe ByteString)
-> (BEDGraph -> Maybe ByteString -> BEDGraph)
-> Lens' BEDGraph (Maybe ByteString)
forall s a b t. (s -> a) -> (s -> b -> t) -> Lens s t a b
lens (Maybe ByteString -> BEDGraph -> Maybe ByteString
forall a b. a -> b -> a
const Maybe ByteString
forall a. Maybe a
Nothing) (\BEDGraph
bed Maybe ByteString
_ -> BEDGraph
bed)
    score :: (Maybe Int -> f (Maybe Int)) -> BEDGraph -> f BEDGraph
score = (BEDGraph -> Maybe Int)
-> (BEDGraph -> Maybe Int -> BEDGraph)
-> Lens' BEDGraph (Maybe Int)
forall s a b t. (s -> a) -> (s -> b -> t) -> Lens s t a b
lens (Maybe Int -> BEDGraph -> Maybe Int
forall a b. a -> b -> a
const Maybe Int
forall a. Maybe a
Nothing) (\BEDGraph
bed Maybe Int
_ -> BEDGraph
bed)
    strand :: (Maybe Bool -> f (Maybe Bool)) -> BEDGraph -> f BEDGraph
strand = (BEDGraph -> Maybe Bool)
-> (BEDGraph -> Maybe Bool -> BEDGraph)
-> Lens' BEDGraph (Maybe Bool)
forall s a b t. (s -> a) -> (s -> b -> t) -> Lens s t a b
lens (Maybe Bool -> BEDGraph -> Maybe Bool
forall a b. a -> b -> a
const Maybe Bool
forall a. Maybe a
Nothing) (\BEDGraph
bed Maybe Bool
_ -> BEDGraph
bed)

instance BEDConvert BEDGraph where
    asBed :: ByteString -> Int -> Int -> BEDGraph
asBed ByteString
a Int
b Int
c = ByteString -> Int -> Int -> Double -> BEDGraph
BEDGraph ByteString
a Int
b Int
c Double
0
    {-# INLINE asBed #-}

    fromLine :: ByteString -> BEDGraph
fromLine ByteString
l = case Char -> ByteString -> [ByteString]
B.split Char
'\t' ByteString
l of
        (ByteString
a:ByteString
b:ByteString
c:ByteString
d:[ByteString]
_) -> ByteString -> Int -> Int -> Double -> BEDGraph
BEDGraph ByteString
a (ByteString -> Int
readInt ByteString
b) (ByteString -> Int
readInt ByteString
c) (Double -> BEDGraph) -> Double -> BEDGraph
forall a b. (a -> b) -> a -> b
$ ByteString -> Double
readDouble ByteString
d
        [ByteString]
_ -> String -> BEDGraph
forall a. HasCallStack => String -> a
error String
"Read BEDGraph fail: Incorrect number of fields"
    {-# INLINE fromLine #-}

    toLine :: BEDGraph -> ByteString
toLine (BEDGraph ByteString
a Int
b Int
c Double
d) = ByteString -> [ByteString] -> ByteString
B.intercalate ByteString
"\t"
        [ByteString
a, Maybe ByteString -> ByteString
forall a. HasCallStack => Maybe a -> a
fromJust (Maybe ByteString -> ByteString) -> Maybe ByteString -> ByteString
forall a b. (a -> b) -> a -> b
$ Int -> Maybe ByteString
forall a. Integral a => a -> Maybe ByteString
packDecimal Int
b, Maybe ByteString -> ByteString
forall a. HasCallStack => Maybe a -> a
fromJust (Maybe ByteString -> ByteString) -> Maybe ByteString -> ByteString
forall a b. (a -> b) -> a -> b
$ Int -> Maybe ByteString
forall a. Integral a => a -> Maybe ByteString
packDecimal Int
c, Double -> ByteString
toShortest Double
d]
    {-# INLINE toLine #-}


-- | ENCODE narrowPeak format: https://genome.ucsc.edu/FAQ/FAQformat.html#format12
data NarrowPeak = NarrowPeak
    { NarrowPeak -> ByteString
_npChrom  :: B.ByteString
    , NarrowPeak -> Int
_npStart  :: Int
    , NarrowPeak -> Int
_npEnd    :: Int
    , NarrowPeak -> Maybe ByteString
_npName   :: Maybe B.ByteString
    , NarrowPeak -> Int
_npScore  :: Int
    , NarrowPeak -> Maybe Bool
_npStrand :: Maybe Bool
    , NarrowPeak -> Double
_npSignal :: Double
    , NarrowPeak -> Maybe Double
_npPvalue :: Maybe Double
    , NarrowPeak -> Maybe Double
_npQvalue :: Maybe Double
    , NarrowPeak -> Maybe Int
_npPeak   :: Maybe Int
    } deriving (NarrowPeak -> NarrowPeak -> Bool
(NarrowPeak -> NarrowPeak -> Bool)
-> (NarrowPeak -> NarrowPeak -> Bool) -> Eq NarrowPeak
forall a. (a -> a -> Bool) -> (a -> a -> Bool) -> Eq a
/= :: NarrowPeak -> NarrowPeak -> Bool
$c/= :: NarrowPeak -> NarrowPeak -> Bool
== :: NarrowPeak -> NarrowPeak -> Bool
$c== :: NarrowPeak -> NarrowPeak -> Bool
Eq, Int -> NarrowPeak -> ShowS
[NarrowPeak] -> ShowS
NarrowPeak -> String
(Int -> NarrowPeak -> ShowS)
-> (NarrowPeak -> String)
-> ([NarrowPeak] -> ShowS)
-> Show NarrowPeak
forall a.
(Int -> a -> ShowS) -> (a -> String) -> ([a] -> ShowS) -> Show a
showList :: [NarrowPeak] -> ShowS
$cshowList :: [NarrowPeak] -> ShowS
show :: NarrowPeak -> String
$cshow :: NarrowPeak -> String
showsPrec :: Int -> NarrowPeak -> ShowS
$cshowsPrec :: Int -> NarrowPeak -> ShowS
Show, ReadPrec [NarrowPeak]
ReadPrec NarrowPeak
Int -> ReadS NarrowPeak
ReadS [NarrowPeak]
(Int -> ReadS NarrowPeak)
-> ReadS [NarrowPeak]
-> ReadPrec NarrowPeak
-> ReadPrec [NarrowPeak]
-> Read NarrowPeak
forall a.
(Int -> ReadS a)
-> ReadS [a] -> ReadPrec a -> ReadPrec [a] -> Read a
readListPrec :: ReadPrec [NarrowPeak]
$creadListPrec :: ReadPrec [NarrowPeak]
readPrec :: ReadPrec NarrowPeak
$creadPrec :: ReadPrec NarrowPeak
readList :: ReadS [NarrowPeak]
$creadList :: ReadS [NarrowPeak]
readsPrec :: Int -> ReadS NarrowPeak
$creadsPrec :: Int -> ReadS NarrowPeak
Read, (forall x. NarrowPeak -> Rep NarrowPeak x)
-> (forall x. Rep NarrowPeak x -> NarrowPeak) -> Generic NarrowPeak
forall x. Rep NarrowPeak x -> NarrowPeak
forall x. NarrowPeak -> Rep NarrowPeak x
forall a.
(forall x. a -> Rep a x) -> (forall x. Rep a x -> a) -> Generic a
$cto :: forall x. Rep NarrowPeak x -> NarrowPeak
$cfrom :: forall x. NarrowPeak -> Rep NarrowPeak x
Generic, NarrowPeak -> ()
(NarrowPeak -> ()) -> NFData NarrowPeak
forall a. (a -> ()) -> NFData a
rnf :: NarrowPeak -> ()
$crnf :: NarrowPeak -> ()
NFData)

makeLensesFor [ ("_npSignal", "npSignal")
              , ("_npPvalue", "npPvalue")
              , ("_npQvalue", "npQvalue")
              , ("_npPeak", "npPeak")
              ] ''NarrowPeak

instance BEDLike NarrowPeak where
    chrom :: (ByteString -> f ByteString) -> NarrowPeak -> f NarrowPeak
chrom = (NarrowPeak -> ByteString)
-> (NarrowPeak -> ByteString -> NarrowPeak)
-> Lens' NarrowPeak ByteString
forall s a b t. (s -> a) -> (s -> b -> t) -> Lens s t a b
lens NarrowPeak -> ByteString
_npChrom (\NarrowPeak
bed ByteString
x -> NarrowPeak
bed { _npChrom :: ByteString
_npChrom = ByteString
x })
    chromStart :: (Int -> f Int) -> NarrowPeak -> f NarrowPeak
chromStart = (NarrowPeak -> Int)
-> (NarrowPeak -> Int -> NarrowPeak) -> Lens' NarrowPeak Int
forall s a b t. (s -> a) -> (s -> b -> t) -> Lens s t a b
lens NarrowPeak -> Int
_npStart (\NarrowPeak
bed Int
x -> NarrowPeak
bed { _npStart :: Int
_npStart = Int
x })
    chromEnd :: (Int -> f Int) -> NarrowPeak -> f NarrowPeak
chromEnd = (NarrowPeak -> Int)
-> (NarrowPeak -> Int -> NarrowPeak) -> Lens' NarrowPeak Int
forall s a b t. (s -> a) -> (s -> b -> t) -> Lens s t a b
lens NarrowPeak -> Int
_npEnd (\NarrowPeak
bed Int
x -> NarrowPeak
bed { _npEnd :: Int
_npEnd = Int
x })
    name :: (Maybe ByteString -> f (Maybe ByteString))
-> NarrowPeak -> f NarrowPeak
name = (NarrowPeak -> Maybe ByteString)
-> (NarrowPeak -> Maybe ByteString -> NarrowPeak)
-> Lens' NarrowPeak (Maybe ByteString)
forall s a b t. (s -> a) -> (s -> b -> t) -> Lens s t a b
lens NarrowPeak -> Maybe ByteString
_npName (\NarrowPeak
bed Maybe ByteString
x -> NarrowPeak
bed { _npName :: Maybe ByteString
_npName = Maybe ByteString
x })
    score :: (Maybe Int -> f (Maybe Int)) -> NarrowPeak -> f NarrowPeak
score = (NarrowPeak -> Maybe Int)
-> (NarrowPeak -> Maybe Int -> NarrowPeak)
-> Lens' NarrowPeak (Maybe Int)
forall s a b t. (s -> a) -> (s -> b -> t) -> Lens s t a b
lens (Int -> Maybe Int
forall a. a -> Maybe a
Just (Int -> Maybe Int)
-> (NarrowPeak -> Int) -> NarrowPeak -> Maybe Int
forall b c a. (b -> c) -> (a -> b) -> a -> c
. NarrowPeak -> Int
_npScore) (\NarrowPeak
bed Maybe Int
x -> NarrowPeak
bed { _npScore :: Int
_npScore = Maybe Int -> Int
forall a. HasCallStack => Maybe a -> a
fromJust Maybe Int
x })
    strand :: (Maybe Bool -> f (Maybe Bool)) -> NarrowPeak -> f NarrowPeak
strand = (NarrowPeak -> Maybe Bool)
-> (NarrowPeak -> Maybe Bool -> NarrowPeak)
-> Lens' NarrowPeak (Maybe Bool)
forall s a b t. (s -> a) -> (s -> b -> t) -> Lens s t a b
lens NarrowPeak -> Maybe Bool
_npStrand (\NarrowPeak
bed Maybe Bool
x -> NarrowPeak
bed { _npStrand :: Maybe Bool
_npStrand = Maybe Bool
x })

instance BEDConvert NarrowPeak where
    asBed :: ByteString -> Int -> Int -> NarrowPeak
asBed ByteString
chr Int
s Int
e = ByteString
-> Int
-> Int
-> Maybe ByteString
-> Int
-> Maybe Bool
-> Double
-> Maybe Double
-> Maybe Double
-> Maybe Int
-> NarrowPeak
NarrowPeak ByteString
chr Int
s Int
e Maybe ByteString
forall a. Maybe a
Nothing Int
0 Maybe Bool
forall a. Maybe a
Nothing Double
0 Maybe Double
forall a. Maybe a
Nothing Maybe Double
forall a. Maybe a
Nothing Maybe Int
forall a. Maybe a
Nothing

    fromLine :: ByteString -> NarrowPeak
fromLine = [ByteString] -> NarrowPeak
go ([ByteString] -> NarrowPeak)
-> (ByteString -> [ByteString]) -> ByteString -> NarrowPeak
forall b c a. (b -> c) -> (a -> b) -> a -> c
. Char -> ByteString -> [ByteString]
B.split Char
'\t'
      where
        go :: [ByteString] -> NarrowPeak
go [ByteString
a,ByteString
b,ByteString
c] = BED3 -> NarrowPeak
forall b b'. (BEDConvert b, BEDLike b') => b' -> b
convert (BED3 -> NarrowPeak) -> BED3 -> NarrowPeak
forall a b. (a -> b) -> a -> b
$ ByteString -> Int -> Int -> BED3
BED3 ByteString
a (ByteString -> Int
readInt ByteString
b) (Int -> BED3) -> Int -> BED3
forall a b. (a -> b) -> a -> b
$ ByteString -> Int
readInt ByteString
c
        go (ByteString
a:ByteString
b:ByteString
c:ByteString
d:ByteString
e:ByteString
f:ByteString
g:ByteString
h:ByteString
i:ByteString
j:[ByteString]
_) = ByteString
-> Int
-> Int
-> Maybe ByteString
-> Int
-> Maybe Bool
-> Double
-> Maybe Double
-> Maybe Double
-> Maybe Int
-> NarrowPeak
NarrowPeak ByteString
a (ByteString -> Int
readInt ByteString
b) (ByteString -> Int
readInt ByteString
c)
            (if ByteString
d ByteString -> ByteString -> Bool
forall a. Eq a => a -> a -> Bool
== ByteString
"." then Maybe ByteString
forall a. Maybe a
Nothing else ByteString -> Maybe ByteString
forall a. a -> Maybe a
Just ByteString
d)
            (ByteString -> Int
readInt ByteString
e)
            (if ByteString
f ByteString -> ByteString -> Bool
forall a. Eq a => a -> a -> Bool
== ByteString
"." then Maybe Bool
forall a. Maybe a
Nothing else if ByteString
f ByteString -> ByteString -> Bool
forall a. Eq a => a -> a -> Bool
== ByteString
"+" then Bool -> Maybe Bool
forall a. a -> Maybe a
Just Bool
True else Bool -> Maybe Bool
forall a. a -> Maybe a
Just Bool
False)
            (ByteString -> Double
readDouble ByteString
g)
            (ByteString -> Maybe Double
readDoubleNonnegative ByteString
h)
            (ByteString -> Maybe Double
readDoubleNonnegative ByteString
i)
            (ByteString -> Maybe Int
readIntNonnegative ByteString
j)
        go [ByteString]
x = String -> NarrowPeak
forall a. HasCallStack => String -> a
error (String -> NarrowPeak) -> String -> NarrowPeak
forall a b. (a -> b) -> a -> b
$ String
"Cannot parse line: " String -> ShowS
forall a. Semigroup a => a -> a -> a
<> [ByteString] -> String
forall a. Show a => a -> String
show [ByteString]
x
    {-# INLINE fromLine #-}

    toLine :: NarrowPeak -> ByteString
toLine (NarrowPeak ByteString
a Int
b Int
c Maybe ByteString
d Int
e Maybe Bool
f Double
g Maybe Double
h Maybe Double
i Maybe Int
j) = ByteString -> [ByteString] -> ByteString
B.intercalate ByteString
"\t"
        [ ByteString
a, Maybe ByteString -> ByteString
forall a. HasCallStack => Maybe a -> a
fromJust (Maybe ByteString -> ByteString) -> Maybe ByteString -> ByteString
forall a b. (a -> b) -> a -> b
$ Int -> Maybe ByteString
forall a. Integral a => a -> Maybe ByteString
packDecimal Int
b, Maybe ByteString -> ByteString
forall a. HasCallStack => Maybe a -> a
fromJust (Maybe ByteString -> ByteString) -> Maybe ByteString -> ByteString
forall a b. (a -> b) -> a -> b
$ Int -> Maybe ByteString
forall a. Integral a => a -> Maybe ByteString
packDecimal Int
c, ByteString -> Maybe ByteString -> ByteString
forall a. a -> Maybe a -> a
fromMaybe ByteString
"." Maybe ByteString
d
        , Maybe ByteString -> ByteString
forall a. HasCallStack => Maybe a -> a
fromJust (Maybe ByteString -> ByteString) -> Maybe ByteString -> ByteString
forall a b. (a -> b) -> a -> b
$ Int -> Maybe ByteString
forall a. Integral a => a -> Maybe ByteString
packDecimal Int
e
        , case Maybe Bool
f of
            Maybe Bool
Nothing   -> ByteString
"."
            Just Bool
True -> ByteString
"+"
            Maybe Bool
_         -> ByteString
"-"
        , Double -> ByteString
toShortest Double
g, ByteString -> Maybe ByteString -> ByteString
forall a. a -> Maybe a -> a
fromMaybe ByteString
"-1" (Maybe ByteString -> ByteString) -> Maybe ByteString -> ByteString
forall a b. (a -> b) -> a -> b
$ (Double -> ByteString) -> Maybe Double -> Maybe ByteString
forall (f :: * -> *) a b. Functor f => (a -> b) -> f a -> f b
fmap Double -> ByteString
toShortest Maybe Double
h
        , ByteString -> Maybe ByteString -> ByteString
forall a. a -> Maybe a -> a
fromMaybe ByteString
"-1" (Maybe ByteString -> ByteString) -> Maybe ByteString -> ByteString
forall a b. (a -> b) -> a -> b
$ (Double -> ByteString) -> Maybe Double -> Maybe ByteString
forall (f :: * -> *) a b. Functor f => (a -> b) -> f a -> f b
fmap Double -> ByteString
toShortest Maybe Double
i
        , ByteString -> Maybe ByteString -> ByteString
forall a. a -> Maybe a -> a
fromMaybe ByteString
"-1" (Maybe ByteString -> ByteString) -> Maybe ByteString -> ByteString
forall a b. (a -> b) -> a -> b
$ (Int -> ByteString) -> Maybe Int -> Maybe ByteString
forall (f :: * -> *) a b. Functor f => (a -> b) -> f a -> f b
fmap (Maybe ByteString -> ByteString
forall a. HasCallStack => Maybe a -> a
fromJust (Maybe ByteString -> ByteString)
-> (Int -> Maybe ByteString) -> Int -> ByteString
forall b c a. (b -> c) -> (a -> b) -> a -> c
. Int -> Maybe ByteString
forall a. Integral a => a -> Maybe ByteString
packDecimal) Maybe Int
j
        ]
    {-# INLINE toLine #-}

    convert :: b' -> NarrowPeak
convert b'
bed = ByteString
-> Int
-> Int
-> Maybe ByteString
-> Int
-> Maybe Bool
-> Double
-> Maybe Double
-> Maybe Double
-> Maybe Int
-> NarrowPeak
NarrowPeak (b'
bedb' -> Getting ByteString b' ByteString -> ByteString
forall s a. s -> Getting a s a -> a
^.Getting ByteString b' ByteString
forall b. BEDLike b => Lens' b ByteString
chrom) (b'
bedb' -> Getting Int b' Int -> Int
forall s a. s -> Getting a s a -> a
^.Getting Int b' Int
forall b. BEDLike b => Lens' b Int
chromStart) (b'
bedb' -> Getting Int b' Int -> Int
forall s a. s -> Getting a s a -> a
^.Getting Int b' Int
forall b. BEDLike b => Lens' b Int
chromEnd) (b'
bedb'
-> Getting (Maybe ByteString) b' (Maybe ByteString)
-> Maybe ByteString
forall s a. s -> Getting a s a -> a
^.Getting (Maybe ByteString) b' (Maybe ByteString)
forall b. BEDLike b => Lens' b (Maybe ByteString)
name)
        (Int -> Maybe Int -> Int
forall a. a -> Maybe a -> a
fromMaybe Int
0 (Maybe Int -> Int) -> Maybe Int -> Int
forall a b. (a -> b) -> a -> b
$ b'
bedb' -> Getting (Maybe Int) b' (Maybe Int) -> Maybe Int
forall s a. s -> Getting a s a -> a
^.Getting (Maybe Int) b' (Maybe Int)
forall b. BEDLike b => Lens' b (Maybe Int)
score) (b'
bedb' -> Getting (Maybe Bool) b' (Maybe Bool) -> Maybe Bool
forall s a. s -> Getting a s a -> a
^.Getting (Maybe Bool) b' (Maybe Bool)
forall b. BEDLike b => Lens' b (Maybe Bool)
strand) Double
0 Maybe Double
forall a. Maybe a
Nothing Maybe Double
forall a. Maybe a
Nothing Maybe Int
forall a. Maybe a
Nothing

-- | ENCODE broadPeak format: https://genome.ucsc.edu/FAQ/FAQformat.html#format13
data BroadPeak = BroadPeak
    { BroadPeak -> ByteString
_bpChrom  :: B.ByteString
    , BroadPeak -> Int
_bpStart  :: Int
    , BroadPeak -> Int
_bpEnd    :: Int
    , BroadPeak -> Maybe ByteString
_bpName   :: Maybe B.ByteString
    , BroadPeak -> Int
_bpScore  :: Int
    , BroadPeak -> Maybe Bool
_bpStrand :: Maybe Bool
    , BroadPeak -> Double
_bpSignal :: Double
    , BroadPeak -> Maybe Double
_bpPvalue :: Maybe Double
    , BroadPeak -> Maybe Double
_bpQvalue :: Maybe Double
    } deriving (BroadPeak -> BroadPeak -> Bool
(BroadPeak -> BroadPeak -> Bool)
-> (BroadPeak -> BroadPeak -> Bool) -> Eq BroadPeak
forall a. (a -> a -> Bool) -> (a -> a -> Bool) -> Eq a
/= :: BroadPeak -> BroadPeak -> Bool
$c/= :: BroadPeak -> BroadPeak -> Bool
== :: BroadPeak -> BroadPeak -> Bool
$c== :: BroadPeak -> BroadPeak -> Bool
Eq, Int -> BroadPeak -> ShowS
[BroadPeak] -> ShowS
BroadPeak -> String
(Int -> BroadPeak -> ShowS)
-> (BroadPeak -> String)
-> ([BroadPeak] -> ShowS)
-> Show BroadPeak
forall a.
(Int -> a -> ShowS) -> (a -> String) -> ([a] -> ShowS) -> Show a
showList :: [BroadPeak] -> ShowS
$cshowList :: [BroadPeak] -> ShowS
show :: BroadPeak -> String
$cshow :: BroadPeak -> String
showsPrec :: Int -> BroadPeak -> ShowS
$cshowsPrec :: Int -> BroadPeak -> ShowS
Show, ReadPrec [BroadPeak]
ReadPrec BroadPeak
Int -> ReadS BroadPeak
ReadS [BroadPeak]
(Int -> ReadS BroadPeak)
-> ReadS [BroadPeak]
-> ReadPrec BroadPeak
-> ReadPrec [BroadPeak]
-> Read BroadPeak
forall a.
(Int -> ReadS a)
-> ReadS [a] -> ReadPrec a -> ReadPrec [a] -> Read a
readListPrec :: ReadPrec [BroadPeak]
$creadListPrec :: ReadPrec [BroadPeak]
readPrec :: ReadPrec BroadPeak
$creadPrec :: ReadPrec BroadPeak
readList :: ReadS [BroadPeak]
$creadList :: ReadS [BroadPeak]
readsPrec :: Int -> ReadS BroadPeak
$creadsPrec :: Int -> ReadS BroadPeak
Read, (forall x. BroadPeak -> Rep BroadPeak x)
-> (forall x. Rep BroadPeak x -> BroadPeak) -> Generic BroadPeak
forall x. Rep BroadPeak x -> BroadPeak
forall x. BroadPeak -> Rep BroadPeak x
forall a.
(forall x. a -> Rep a x) -> (forall x. Rep a x -> a) -> Generic a
$cto :: forall x. Rep BroadPeak x -> BroadPeak
$cfrom :: forall x. BroadPeak -> Rep BroadPeak x
Generic, BroadPeak -> ()
(BroadPeak -> ()) -> NFData BroadPeak
forall a. (a -> ()) -> NFData a
rnf :: BroadPeak -> ()
$crnf :: BroadPeak -> ()
NFData)

makeLensesFor [ ("_bpSignal", "bpSignal")
              , ("_bpPvalue", "bpPvalue")
              , ("_bpQvalue", "bpQvalue")
              ] ''BroadPeak

instance BEDLike BroadPeak where
    chrom :: (ByteString -> f ByteString) -> BroadPeak -> f BroadPeak
chrom = (BroadPeak -> ByteString)
-> (BroadPeak -> ByteString -> BroadPeak)
-> Lens' BroadPeak ByteString
forall s a b t. (s -> a) -> (s -> b -> t) -> Lens s t a b
lens BroadPeak -> ByteString
_bpChrom (\BroadPeak
bed ByteString
x -> BroadPeak
bed { _bpChrom :: ByteString
_bpChrom = ByteString
x })
    chromStart :: (Int -> f Int) -> BroadPeak -> f BroadPeak
chromStart = (BroadPeak -> Int)
-> (BroadPeak -> Int -> BroadPeak) -> Lens' BroadPeak Int
forall s a b t. (s -> a) -> (s -> b -> t) -> Lens s t a b
lens BroadPeak -> Int
_bpStart (\BroadPeak
bed Int
x -> BroadPeak
bed { _bpStart :: Int
_bpStart = Int
x })
    chromEnd :: (Int -> f Int) -> BroadPeak -> f BroadPeak
chromEnd = (BroadPeak -> Int)
-> (BroadPeak -> Int -> BroadPeak) -> Lens' BroadPeak Int
forall s a b t. (s -> a) -> (s -> b -> t) -> Lens s t a b
lens BroadPeak -> Int
_bpEnd (\BroadPeak
bed Int
x -> BroadPeak
bed { _bpEnd :: Int
_bpEnd = Int
x })
    name :: (Maybe ByteString -> f (Maybe ByteString))
-> BroadPeak -> f BroadPeak
name = (BroadPeak -> Maybe ByteString)
-> (BroadPeak -> Maybe ByteString -> BroadPeak)
-> Lens' BroadPeak (Maybe ByteString)
forall s a b t. (s -> a) -> (s -> b -> t) -> Lens s t a b
lens BroadPeak -> Maybe ByteString
_bpName (\BroadPeak
bed Maybe ByteString
x -> BroadPeak
bed { _bpName :: Maybe ByteString
_bpName = Maybe ByteString
x })
    score :: (Maybe Int -> f (Maybe Int)) -> BroadPeak -> f BroadPeak
score = (BroadPeak -> Maybe Int)
-> (BroadPeak -> Maybe Int -> BroadPeak)
-> Lens' BroadPeak (Maybe Int)
forall s a b t. (s -> a) -> (s -> b -> t) -> Lens s t a b
lens (Int -> Maybe Int
forall a. a -> Maybe a
Just (Int -> Maybe Int) -> (BroadPeak -> Int) -> BroadPeak -> Maybe Int
forall b c a. (b -> c) -> (a -> b) -> a -> c
. BroadPeak -> Int
_bpScore) (\BroadPeak
bed Maybe Int
x -> BroadPeak
bed { _bpScore :: Int
_bpScore = Maybe Int -> Int
forall a. HasCallStack => Maybe a -> a
fromJust Maybe Int
x })
    strand :: (Maybe Bool -> f (Maybe Bool)) -> BroadPeak -> f BroadPeak
strand = (BroadPeak -> Maybe Bool)
-> (BroadPeak -> Maybe Bool -> BroadPeak)
-> Lens' BroadPeak (Maybe Bool)
forall s a b t. (s -> a) -> (s -> b -> t) -> Lens s t a b
lens BroadPeak -> Maybe Bool
_bpStrand (\BroadPeak
bed Maybe Bool
x -> BroadPeak
bed { _bpStrand :: Maybe Bool
_bpStrand = Maybe Bool
x })

instance BEDConvert BroadPeak where
    asBed :: ByteString -> Int -> Int -> BroadPeak
asBed ByteString
chr Int
s Int
e = ByteString
-> Int
-> Int
-> Maybe ByteString
-> Int
-> Maybe Bool
-> Double
-> Maybe Double
-> Maybe Double
-> BroadPeak
BroadPeak ByteString
chr Int
s Int
e Maybe ByteString
forall a. Maybe a
Nothing Int
0 Maybe Bool
forall a. Maybe a
Nothing Double
0 Maybe Double
forall a. Maybe a
Nothing Maybe Double
forall a. Maybe a
Nothing

    fromLine :: ByteString -> BroadPeak
fromLine ByteString
l = ByteString
-> Int
-> Int
-> Maybe ByteString
-> Int
-> Maybe Bool
-> Double
-> Maybe Double
-> Maybe Double
-> BroadPeak
BroadPeak ByteString
a (ByteString -> Int
readInt ByteString
b) (ByteString -> Int
readInt ByteString
c)
        (if ByteString
d ByteString -> ByteString -> Bool
forall a. Eq a => a -> a -> Bool
== ByteString
"." then Maybe ByteString
forall a. Maybe a
Nothing else ByteString -> Maybe ByteString
forall a. a -> Maybe a
Just ByteString
d)
        (ByteString -> Int
readInt ByteString
e)
        (if ByteString
f ByteString -> ByteString -> Bool
forall a. Eq a => a -> a -> Bool
== ByteString
"." then Maybe Bool
forall a. Maybe a
Nothing else if ByteString
f ByteString -> ByteString -> Bool
forall a. Eq a => a -> a -> Bool
== ByteString
"+" then Bool -> Maybe Bool
forall a. a -> Maybe a
Just Bool
True else Bool -> Maybe Bool
forall a. a -> Maybe a
Just Bool
False)
        (ByteString -> Double
readDouble ByteString
g)
        (ByteString -> Maybe Double
readDoubleNonnegative ByteString
h)
        (ByteString -> Maybe Double
readDoubleNonnegative ByteString
i)
      where
        (ByteString
a:ByteString
b:ByteString
c:ByteString
d:ByteString
e:ByteString
f:ByteString
g:ByteString
h:ByteString
i:[ByteString]
_) = Char -> ByteString -> [ByteString]
B.split Char
'\t' ByteString
l
    {-# INLINE fromLine #-}

    toLine :: BroadPeak -> ByteString
toLine (BroadPeak ByteString
a Int
b Int
c Maybe ByteString
d Int
e Maybe Bool
f Double
g Maybe Double
h Maybe Double
i) = ByteString -> [ByteString] -> ByteString
B.intercalate ByteString
"\t"
        [ ByteString
a, Maybe ByteString -> ByteString
forall a. HasCallStack => Maybe a -> a
fromJust (Maybe ByteString -> ByteString) -> Maybe ByteString -> ByteString
forall a b. (a -> b) -> a -> b
$ Int -> Maybe ByteString
forall a. Integral a => a -> Maybe ByteString
packDecimal Int
b, Maybe ByteString -> ByteString
forall a. HasCallStack => Maybe a -> a
fromJust (Maybe ByteString -> ByteString) -> Maybe ByteString -> ByteString
forall a b. (a -> b) -> a -> b
$ Int -> Maybe ByteString
forall a. Integral a => a -> Maybe ByteString
packDecimal Int
c, ByteString -> Maybe ByteString -> ByteString
forall a. a -> Maybe a -> a
fromMaybe ByteString
"." Maybe ByteString
d
        , Maybe ByteString -> ByteString
forall a. HasCallStack => Maybe a -> a
fromJust (Maybe ByteString -> ByteString) -> Maybe ByteString -> ByteString
forall a b. (a -> b) -> a -> b
$ Int -> Maybe ByteString
forall a. Integral a => a -> Maybe ByteString
packDecimal Int
e
        , case Maybe Bool
f of
            Maybe Bool
Nothing   -> ByteString
"."
            Just Bool
True -> ByteString
"+"
            Maybe Bool
_         -> ByteString
"-"
        , Double -> ByteString
toShortest Double
g, ByteString -> Maybe ByteString -> ByteString
forall a. a -> Maybe a -> a
fromMaybe ByteString
"-1" (Maybe ByteString -> ByteString) -> Maybe ByteString -> ByteString
forall a b. (a -> b) -> a -> b
$ (Double -> ByteString) -> Maybe Double -> Maybe ByteString
forall (f :: * -> *) a b. Functor f => (a -> b) -> f a -> f b
fmap Double -> ByteString
toShortest Maybe Double
h
        , ByteString -> Maybe ByteString -> ByteString
forall a. a -> Maybe a -> a
fromMaybe ByteString
"-1" (Maybe ByteString -> ByteString) -> Maybe ByteString -> ByteString
forall a b. (a -> b) -> a -> b
$ (Double -> ByteString) -> Maybe Double -> Maybe ByteString
forall (f :: * -> *) a b. Functor f => (a -> b) -> f a -> f b
fmap Double -> ByteString
toShortest Maybe Double
i
        ]
    {-# INLINE toLine #-}

    convert :: b' -> BroadPeak
convert b'
bed = ByteString
-> Int
-> Int
-> Maybe ByteString
-> Int
-> Maybe Bool
-> Double
-> Maybe Double
-> Maybe Double
-> BroadPeak
BroadPeak (b'
bedb' -> Getting ByteString b' ByteString -> ByteString
forall s a. s -> Getting a s a -> a
^.Getting ByteString b' ByteString
forall b. BEDLike b => Lens' b ByteString
chrom) (b'
bedb' -> Getting Int b' Int -> Int
forall s a. s -> Getting a s a -> a
^.Getting Int b' Int
forall b. BEDLike b => Lens' b Int
chromStart) (b'
bedb' -> Getting Int b' Int -> Int
forall s a. s -> Getting a s a -> a
^.Getting Int b' Int
forall b. BEDLike b => Lens' b Int
chromEnd) (b'
bedb'
-> Getting (Maybe ByteString) b' (Maybe ByteString)
-> Maybe ByteString
forall s a. s -> Getting a s a -> a
^.Getting (Maybe ByteString) b' (Maybe ByteString)
forall b. BEDLike b => Lens' b (Maybe ByteString)
name)
        (Int -> Maybe Int -> Int
forall a. a -> Maybe a -> a
fromMaybe Int
0 (Maybe Int -> Int) -> Maybe Int -> Int
forall a b. (a -> b) -> a -> b
$ b'
bedb' -> Getting (Maybe Int) b' (Maybe Int) -> Maybe Int
forall s a. s -> Getting a s a -> a
^.Getting (Maybe Int) b' (Maybe Int)
forall b. BEDLike b => Lens' b (Maybe Int)
score) (b'
bedb' -> Getting (Maybe Bool) b' (Maybe Bool) -> Maybe Bool
forall s a. s -> Getting a s a -> a
^.Getting (Maybe Bool) b' (Maybe Bool)
forall b. BEDLike b => Lens' b (Maybe Bool)
strand) Double
0 Maybe Double
forall a. Maybe a
Nothing Maybe Double
forall a. Maybe a
Nothing


data BEDExt bed a = BEDExt
    { BEDExt bed a -> bed
_ext_bed :: bed
    , BEDExt bed a -> a
_ext_data :: a
    } deriving (BEDExt bed a -> BEDExt bed a -> Bool
(BEDExt bed a -> BEDExt bed a -> Bool)
-> (BEDExt bed a -> BEDExt bed a -> Bool) -> Eq (BEDExt bed a)
forall a. (a -> a -> Bool) -> (a -> a -> Bool) -> Eq a
forall bed a.
(Eq bed, Eq a) =>
BEDExt bed a -> BEDExt bed a -> Bool
/= :: BEDExt bed a -> BEDExt bed a -> Bool
$c/= :: forall bed a.
(Eq bed, Eq a) =>
BEDExt bed a -> BEDExt bed a -> Bool
== :: BEDExt bed a -> BEDExt bed a -> Bool
$c== :: forall bed a.
(Eq bed, Eq a) =>
BEDExt bed a -> BEDExt bed a -> Bool
Eq, Int -> BEDExt bed a -> ShowS
[BEDExt bed a] -> ShowS
BEDExt bed a -> String
(Int -> BEDExt bed a -> ShowS)
-> (BEDExt bed a -> String)
-> ([BEDExt bed a] -> ShowS)
-> Show (BEDExt bed a)
forall a.
(Int -> a -> ShowS) -> (a -> String) -> ([a] -> ShowS) -> Show a
forall bed a. (Show bed, Show a) => Int -> BEDExt bed a -> ShowS
forall bed a. (Show bed, Show a) => [BEDExt bed a] -> ShowS
forall bed a. (Show bed, Show a) => BEDExt bed a -> String
showList :: [BEDExt bed a] -> ShowS
$cshowList :: forall bed a. (Show bed, Show a) => [BEDExt bed a] -> ShowS
show :: BEDExt bed a -> String
$cshow :: forall bed a. (Show bed, Show a) => BEDExt bed a -> String
showsPrec :: Int -> BEDExt bed a -> ShowS
$cshowsPrec :: forall bed a. (Show bed, Show a) => Int -> BEDExt bed a -> ShowS
Show, ReadPrec [BEDExt bed a]
ReadPrec (BEDExt bed a)
Int -> ReadS (BEDExt bed a)
ReadS [BEDExt bed a]
(Int -> ReadS (BEDExt bed a))
-> ReadS [BEDExt bed a]
-> ReadPrec (BEDExt bed a)
-> ReadPrec [BEDExt bed a]
-> Read (BEDExt bed a)
forall a.
(Int -> ReadS a)
-> ReadS [a] -> ReadPrec a -> ReadPrec [a] -> Read a
forall bed a. (Read bed, Read a) => ReadPrec [BEDExt bed a]
forall bed a. (Read bed, Read a) => ReadPrec (BEDExt bed a)
forall bed a. (Read bed, Read a) => Int -> ReadS (BEDExt bed a)
forall bed a. (Read bed, Read a) => ReadS [BEDExt bed a]
readListPrec :: ReadPrec [BEDExt bed a]
$creadListPrec :: forall bed a. (Read bed, Read a) => ReadPrec [BEDExt bed a]
readPrec :: ReadPrec (BEDExt bed a)
$creadPrec :: forall bed a. (Read bed, Read a) => ReadPrec (BEDExt bed a)
readList :: ReadS [BEDExt bed a]
$creadList :: forall bed a. (Read bed, Read a) => ReadS [BEDExt bed a]
readsPrec :: Int -> ReadS (BEDExt bed a)
$creadsPrec :: forall bed a. (Read bed, Read a) => Int -> ReadS (BEDExt bed a)
Read, (forall x. BEDExt bed a -> Rep (BEDExt bed a) x)
-> (forall x. Rep (BEDExt bed a) x -> BEDExt bed a)
-> Generic (BEDExt bed a)
forall x. Rep (BEDExt bed a) x -> BEDExt bed a
forall x. BEDExt bed a -> Rep (BEDExt bed a) x
forall a.
(forall x. a -> Rep a x) -> (forall x. Rep a x -> a) -> Generic a
forall bed a x. Rep (BEDExt bed a) x -> BEDExt bed a
forall bed a x. BEDExt bed a -> Rep (BEDExt bed a) x
$cto :: forall bed a x. Rep (BEDExt bed a) x -> BEDExt bed a
$cfrom :: forall bed a x. BEDExt bed a -> Rep (BEDExt bed a) x
Generic, BEDExt bed a -> ()
(BEDExt bed a -> ()) -> NFData (BEDExt bed a)
forall a. (a -> ()) -> NFData a
forall bed a. (NFData bed, NFData a) => BEDExt bed a -> ()
rnf :: BEDExt bed a -> ()
$crnf :: forall bed a. (NFData bed, NFData a) => BEDExt bed a -> ()
NFData)

makeLensesFor [("_ext_bed", "_bed"), ("_ext_data", "_data")] ''BEDExt

instance BEDLike bed => BEDLike (BEDExt bed a) where
    chrom :: (ByteString -> f ByteString) -> BEDExt bed a -> f (BEDExt bed a)
chrom = (bed -> f bed) -> BEDExt bed a -> f (BEDExt bed a)
forall bed a bed. Lens (BEDExt bed a) (BEDExt bed a) bed bed
_bed ((bed -> f bed) -> BEDExt bed a -> f (BEDExt bed a))
-> ((ByteString -> f ByteString) -> bed -> f bed)
-> (ByteString -> f ByteString)
-> BEDExt bed a
-> f (BEDExt bed a)
forall b c a. (b -> c) -> (a -> b) -> a -> c
. (ByteString -> f ByteString) -> bed -> f bed
forall b. BEDLike b => Lens' b ByteString
chrom
    chromStart :: (Int -> f Int) -> BEDExt bed a -> f (BEDExt bed a)
chromStart = (bed -> f bed) -> BEDExt bed a -> f (BEDExt bed a)
forall bed a bed. Lens (BEDExt bed a) (BEDExt bed a) bed bed
_bed ((bed -> f bed) -> BEDExt bed a -> f (BEDExt bed a))
-> ((Int -> f Int) -> bed -> f bed)
-> (Int -> f Int)
-> BEDExt bed a
-> f (BEDExt bed a)
forall b c a. (b -> c) -> (a -> b) -> a -> c
. (Int -> f Int) -> bed -> f bed
forall b. BEDLike b => Lens' b Int
chromStart
    chromEnd :: (Int -> f Int) -> BEDExt bed a -> f (BEDExt bed a)
chromEnd = (bed -> f bed) -> BEDExt bed a -> f (BEDExt bed a)
forall bed a bed. Lens (BEDExt bed a) (BEDExt bed a) bed bed
_bed ((bed -> f bed) -> BEDExt bed a -> f (BEDExt bed a))
-> ((Int -> f Int) -> bed -> f bed)
-> (Int -> f Int)
-> BEDExt bed a
-> f (BEDExt bed a)
forall b c a. (b -> c) -> (a -> b) -> a -> c
. (Int -> f Int) -> bed -> f bed
forall b. BEDLike b => Lens' b Int
chromEnd
    name :: (Maybe ByteString -> f (Maybe ByteString))
-> BEDExt bed a -> f (BEDExt bed a)
name = (bed -> f bed) -> BEDExt bed a -> f (BEDExt bed a)
forall bed a bed. Lens (BEDExt bed a) (BEDExt bed a) bed bed
_bed ((bed -> f bed) -> BEDExt bed a -> f (BEDExt bed a))
-> ((Maybe ByteString -> f (Maybe ByteString)) -> bed -> f bed)
-> (Maybe ByteString -> f (Maybe ByteString))
-> BEDExt bed a
-> f (BEDExt bed a)
forall b c a. (b -> c) -> (a -> b) -> a -> c
. (Maybe ByteString -> f (Maybe ByteString)) -> bed -> f bed
forall b. BEDLike b => Lens' b (Maybe ByteString)
name
    score :: (Maybe Int -> f (Maybe Int)) -> BEDExt bed a -> f (BEDExt bed a)
score = (bed -> f bed) -> BEDExt bed a -> f (BEDExt bed a)
forall bed a bed. Lens (BEDExt bed a) (BEDExt bed a) bed bed
_bed ((bed -> f bed) -> BEDExt bed a -> f (BEDExt bed a))
-> ((Maybe Int -> f (Maybe Int)) -> bed -> f bed)
-> (Maybe Int -> f (Maybe Int))
-> BEDExt bed a
-> f (BEDExt bed a)
forall b c a. (b -> c) -> (a -> b) -> a -> c
. (Maybe Int -> f (Maybe Int)) -> bed -> f bed
forall b. BEDLike b => Lens' b (Maybe Int)
score
    strand :: (Maybe Bool -> f (Maybe Bool)) -> BEDExt bed a -> f (BEDExt bed a)
strand = (bed -> f bed) -> BEDExt bed a -> f (BEDExt bed a)
forall bed a bed. Lens (BEDExt bed a) (BEDExt bed a) bed bed
_bed ((bed -> f bed) -> BEDExt bed a -> f (BEDExt bed a))
-> ((Maybe Bool -> f (Maybe Bool)) -> bed -> f bed)
-> (Maybe Bool -> f (Maybe Bool))
-> BEDExt bed a
-> f (BEDExt bed a)
forall b c a. (b -> c) -> (a -> b) -> a -> c
. (Maybe Bool -> f (Maybe Bool)) -> bed -> f bed
forall b. BEDLike b => Lens' b (Maybe Bool)
strand

instance (Read a, Show a, BEDConvert bed) => BEDConvert (BEDExt bed a) where
    asBed :: ByteString -> Int -> Int -> BEDExt bed a
asBed ByteString
_ Int
_ Int
_ = String -> BEDExt bed a
forall a. HasCallStack => String -> a
error String
"Unable to transform arbitrary record to BEDExt"

    fromLine :: ByteString -> BEDExt bed a
fromLine ByteString
l = let (ByteString
a, ByteString
b) = (Char -> Bool) -> ByteString -> (ByteString, ByteString)
B.breakEnd (Char -> Char -> Bool
forall a. Eq a => a -> a -> Bool
==Char
'\t') ByteString
l
                 in bed -> a -> BEDExt bed a
forall bed a. bed -> a -> BEDExt bed a
BEDExt (ByteString -> bed
forall b. BEDConvert b => ByteString -> b
fromLine (ByteString -> bed) -> ByteString -> bed
forall a b. (a -> b) -> a -> b
$ ByteString -> ByteString
B.init ByteString
a) (a -> BEDExt bed a) -> a -> BEDExt bed a
forall a b. (a -> b) -> a -> b
$ String -> a
forall a. Read a => String -> a
read (String -> a) -> String -> a
forall a b. (a -> b) -> a -> b
$ ByteString -> String
B.unpack ByteString
b
    {-# INLINE fromLine #-}

    toLine :: BEDExt bed a -> ByteString
toLine (BEDExt bed
bed a
a) = bed -> ByteString
forall b. BEDConvert b => b -> ByteString
toLine bed
bed ByteString -> ByteString -> ByteString
forall a. Semigroup a => a -> a -> a
<> ByteString
"\t" ByteString -> ByteString -> ByteString
forall a. Semigroup a => a -> a -> a
<> String -> ByteString
B.pack (a -> String
forall a. Show a => a -> String
show a
a)
    {-# INLINE toLine #-}

type BEDTree a = M.HashMap B.ByteString (IM.IntervalMap Int a)

-- | a type to imply that underlying data structure is sorted
newtype Sorted b = Sorted {Sorted b -> b
fromSorted :: b} deriving (Int -> Sorted b -> ShowS
[Sorted b] -> ShowS
Sorted b -> String
(Int -> Sorted b -> ShowS)
-> (Sorted b -> String) -> ([Sorted b] -> ShowS) -> Show (Sorted b)
forall b. Show b => Int -> Sorted b -> ShowS
forall b. Show b => [Sorted b] -> ShowS
forall b. Show b => Sorted b -> String
forall a.
(Int -> a -> ShowS) -> (a -> String) -> ([a] -> ShowS) -> Show a
showList :: [Sorted b] -> ShowS
$cshowList :: forall b. Show b => [Sorted b] -> ShowS
show :: Sorted b -> String
$cshow :: forall b. Show b => Sorted b -> String
showsPrec :: Int -> Sorted b -> ShowS
$cshowsPrec :: forall b. Show b => Int -> Sorted b -> ShowS
Show, ReadPrec [Sorted b]
ReadPrec (Sorted b)
Int -> ReadS (Sorted b)
ReadS [Sorted b]
(Int -> ReadS (Sorted b))
-> ReadS [Sorted b]
-> ReadPrec (Sorted b)
-> ReadPrec [Sorted b]
-> Read (Sorted b)
forall b. Read b => ReadPrec [Sorted b]
forall b. Read b => ReadPrec (Sorted b)
forall b. Read b => Int -> ReadS (Sorted b)
forall b. Read b => ReadS [Sorted b]
forall a.
(Int -> ReadS a)
-> ReadS [a] -> ReadPrec a -> ReadPrec [a] -> Read a
readListPrec :: ReadPrec [Sorted b]
$creadListPrec :: forall b. Read b => ReadPrec [Sorted b]
readPrec :: ReadPrec (Sorted b)
$creadPrec :: forall b. Read b => ReadPrec (Sorted b)
readList :: ReadS [Sorted b]
$creadList :: forall b. Read b => ReadS [Sorted b]
readsPrec :: Int -> ReadS (Sorted b)
$creadsPrec :: forall b. Read b => Int -> ReadS (Sorted b)
Read, Sorted b -> Sorted b -> Bool
(Sorted b -> Sorted b -> Bool)
-> (Sorted b -> Sorted b -> Bool) -> Eq (Sorted b)
forall b. Eq b => Sorted b -> Sorted b -> Bool
forall a. (a -> a -> Bool) -> (a -> a -> Bool) -> Eq a
/= :: Sorted b -> Sorted b -> Bool
$c/= :: forall b. Eq b => Sorted b -> Sorted b -> Bool
== :: Sorted b -> Sorted b -> Bool
$c== :: forall b. Eq b => Sorted b -> Sorted b -> Bool
Eq)