-- | Strand information. A newtyped version, complete with serialization,
-- pattern synonyms, being a @PrimitiveArray@ index type, etc. The strand
-- information includes @+@, @-@, as well as the (GFF3) @.@ not stranded, and
-- @?@ for unknown strand information.
--
-- TODO will be expanded to encode biological sense information more clearly:
-- <http://en.wikipedia.org/wiki/Sense_%28molecular_biology%29>.

module Biobase.Types.Strand where

import Control.DeepSeq
import Control.Lens hiding (Index)
import Control.Monad (guard)
import Data.Aeson
import Data.Binary
import Data.Data (Data)
import Data.Hashable (Hashable)
import Data.Serialize (Serialize)
import Data.Typeable (Typeable)
import Data.Vector.Fusion.Stream.Monadic (Step(..), flatten)
import Data.Vector.Unboxed.Deriving
import GHC.Generics
import Test.QuickCheck
import Text.Printf

import Data.PrimitiveArray.Index.Class



-- | Encode strand information. 'PlusStrand' is defined as the strand encoded
-- in, say, the FASTA file. 'MinusStrand' hence is the reverse complement.

newtype Strand = Strand { Strand -> Int
getStrand :: Int }
  deriving (Strand -> Strand -> Bool
(Strand -> Strand -> Bool)
-> (Strand -> Strand -> Bool) -> Eq Strand
forall a. (a -> a -> Bool) -> (a -> a -> Bool) -> Eq a
/= :: Strand -> Strand -> Bool
$c/= :: Strand -> Strand -> Bool
== :: Strand -> Strand -> Bool
$c== :: Strand -> Strand -> Bool
Eq,Eq Strand
Eq Strand
-> (Strand -> Strand -> Ordering)
-> (Strand -> Strand -> Bool)
-> (Strand -> Strand -> Bool)
-> (Strand -> Strand -> Bool)
-> (Strand -> Strand -> Bool)
-> (Strand -> Strand -> Strand)
-> (Strand -> Strand -> Strand)
-> Ord Strand
Strand -> Strand -> Bool
Strand -> Strand -> Ordering
Strand -> Strand -> Strand
forall a.
Eq a
-> (a -> a -> Ordering)
-> (a -> a -> Bool)
-> (a -> a -> Bool)
-> (a -> a -> Bool)
-> (a -> a -> Bool)
-> (a -> a -> a)
-> (a -> a -> a)
-> Ord a
min :: Strand -> Strand -> Strand
$cmin :: Strand -> Strand -> Strand
max :: Strand -> Strand -> Strand
$cmax :: Strand -> Strand -> Strand
>= :: Strand -> Strand -> Bool
$c>= :: Strand -> Strand -> Bool
> :: Strand -> Strand -> Bool
$c> :: Strand -> Strand -> Bool
<= :: Strand -> Strand -> Bool
$c<= :: Strand -> Strand -> Bool
< :: Strand -> Strand -> Bool
$c< :: Strand -> Strand -> Bool
compare :: Strand -> Strand -> Ordering
$ccompare :: Strand -> Strand -> Ordering
$cp1Ord :: Eq Strand
Ord,(forall x. Strand -> Rep Strand x)
-> (forall x. Rep Strand x -> Strand) -> Generic Strand
forall x. Rep Strand x -> Strand
forall x. Strand -> Rep Strand x
forall a.
(forall x. a -> Rep a x) -> (forall x. Rep a x -> a) -> Generic a
$cto :: forall x. Rep Strand x -> Strand
$cfrom :: forall x. Strand -> Rep Strand x
Generic,Typeable Strand
DataType
Constr
Typeable Strand
-> (forall (c :: * -> *).
    (forall d b. Data d => c (d -> b) -> d -> c b)
    -> (forall g. g -> c g) -> Strand -> c Strand)
-> (forall (c :: * -> *).
    (forall b r. Data b => c (b -> r) -> c r)
    -> (forall r. r -> c r) -> Constr -> c Strand)
-> (Strand -> Constr)
-> (Strand -> DataType)
-> (forall (t :: * -> *) (c :: * -> *).
    Typeable t =>
    (forall d. Data d => c (t d)) -> Maybe (c Strand))
-> (forall (t :: * -> * -> *) (c :: * -> *).
    Typeable t =>
    (forall d e. (Data d, Data e) => c (t d e)) -> Maybe (c Strand))
-> ((forall b. Data b => b -> b) -> Strand -> Strand)
-> (forall r r'.
    (r -> r' -> r)
    -> r -> (forall d. Data d => d -> r') -> Strand -> r)
-> (forall r r'.
    (r' -> r -> r)
    -> r -> (forall d. Data d => d -> r') -> Strand -> r)
-> (forall u. (forall d. Data d => d -> u) -> Strand -> [u])
-> (forall u. Int -> (forall d. Data d => d -> u) -> Strand -> u)
-> (forall (m :: * -> *).
    Monad m =>
    (forall d. Data d => d -> m d) -> Strand -> m Strand)
-> (forall (m :: * -> *).
    MonadPlus m =>
    (forall d. Data d => d -> m d) -> Strand -> m Strand)
-> (forall (m :: * -> *).
    MonadPlus m =>
    (forall d. Data d => d -> m d) -> Strand -> m Strand)
-> Data Strand
Strand -> DataType
Strand -> Constr
(forall b. Data b => b -> b) -> Strand -> Strand
(forall d b. Data d => c (d -> b) -> d -> c b)
-> (forall g. g -> c g) -> Strand -> c Strand
(forall b r. Data b => c (b -> r) -> c r)
-> (forall r. r -> c r) -> Constr -> c Strand
forall a.
Typeable a
-> (forall (c :: * -> *).
    (forall d b. Data d => c (d -> b) -> d -> c b)
    -> (forall g. g -> c g) -> a -> c a)
-> (forall (c :: * -> *).
    (forall b r. Data b => c (b -> r) -> c r)
    -> (forall r. r -> c r) -> Constr -> c a)
-> (a -> Constr)
-> (a -> DataType)
-> (forall (t :: * -> *) (c :: * -> *).
    Typeable t =>
    (forall d. Data d => c (t d)) -> Maybe (c a))
-> (forall (t :: * -> * -> *) (c :: * -> *).
    Typeable t =>
    (forall d e. (Data d, Data e) => c (t d e)) -> Maybe (c a))
-> ((forall b. Data b => b -> b) -> a -> a)
-> (forall r r'.
    (r -> r' -> r) -> r -> (forall d. Data d => d -> r') -> a -> r)
-> (forall r r'.
    (r' -> r -> r) -> r -> (forall d. Data d => d -> r') -> a -> r)
-> (forall u. (forall d. Data d => d -> u) -> a -> [u])
-> (forall u. Int -> (forall d. Data d => d -> u) -> a -> u)
-> (forall (m :: * -> *).
    Monad m =>
    (forall d. Data d => d -> m d) -> a -> m a)
-> (forall (m :: * -> *).
    MonadPlus m =>
    (forall d. Data d => d -> m d) -> a -> m a)
-> (forall (m :: * -> *).
    MonadPlus m =>
    (forall d. Data d => d -> m d) -> a -> m a)
-> Data a
forall u. Int -> (forall d. Data d => d -> u) -> Strand -> u
forall u. (forall d. Data d => d -> u) -> Strand -> [u]
forall r r'.
(r -> r' -> r) -> r -> (forall d. Data d => d -> r') -> Strand -> r
forall r r'.
(r' -> r -> r) -> r -> (forall d. Data d => d -> r') -> Strand -> r
forall (m :: * -> *).
Monad m =>
(forall d. Data d => d -> m d) -> Strand -> m Strand
forall (m :: * -> *).
MonadPlus m =>
(forall d. Data d => d -> m d) -> Strand -> m Strand
forall (c :: * -> *).
(forall b r. Data b => c (b -> r) -> c r)
-> (forall r. r -> c r) -> Constr -> c Strand
forall (c :: * -> *).
(forall d b. Data d => c (d -> b) -> d -> c b)
-> (forall g. g -> c g) -> Strand -> c Strand
forall (t :: * -> *) (c :: * -> *).
Typeable t =>
(forall d. Data d => c (t d)) -> Maybe (c Strand)
forall (t :: * -> * -> *) (c :: * -> *).
Typeable t =>
(forall d e. (Data d, Data e) => c (t d e)) -> Maybe (c Strand)
$cStrand :: Constr
$tStrand :: DataType
gmapMo :: (forall d. Data d => d -> m d) -> Strand -> m Strand
$cgmapMo :: forall (m :: * -> *).
MonadPlus m =>
(forall d. Data d => d -> m d) -> Strand -> m Strand
gmapMp :: (forall d. Data d => d -> m d) -> Strand -> m Strand
$cgmapMp :: forall (m :: * -> *).
MonadPlus m =>
(forall d. Data d => d -> m d) -> Strand -> m Strand
gmapM :: (forall d. Data d => d -> m d) -> Strand -> m Strand
$cgmapM :: forall (m :: * -> *).
Monad m =>
(forall d. Data d => d -> m d) -> Strand -> m Strand
gmapQi :: Int -> (forall d. Data d => d -> u) -> Strand -> u
$cgmapQi :: forall u. Int -> (forall d. Data d => d -> u) -> Strand -> u
gmapQ :: (forall d. Data d => d -> u) -> Strand -> [u]
$cgmapQ :: forall u. (forall d. Data d => d -> u) -> Strand -> [u]
gmapQr :: (r' -> r -> r) -> r -> (forall d. Data d => d -> r') -> Strand -> r
$cgmapQr :: forall r r'.
(r' -> r -> r) -> r -> (forall d. Data d => d -> r') -> Strand -> r
gmapQl :: (r -> r' -> r) -> r -> (forall d. Data d => d -> r') -> Strand -> r
$cgmapQl :: forall r r'.
(r -> r' -> r) -> r -> (forall d. Data d => d -> r') -> Strand -> r
gmapT :: (forall b. Data b => b -> b) -> Strand -> Strand
$cgmapT :: (forall b. Data b => b -> b) -> Strand -> Strand
dataCast2 :: (forall d e. (Data d, Data e) => c (t d e)) -> Maybe (c Strand)
$cdataCast2 :: forall (t :: * -> * -> *) (c :: * -> *).
Typeable t =>
(forall d e. (Data d, Data e) => c (t d e)) -> Maybe (c Strand)
dataCast1 :: (forall d. Data d => c (t d)) -> Maybe (c Strand)
$cdataCast1 :: forall (t :: * -> *) (c :: * -> *).
Typeable t =>
(forall d. Data d => c (t d)) -> Maybe (c Strand)
dataTypeOf :: Strand -> DataType
$cdataTypeOf :: Strand -> DataType
toConstr :: Strand -> Constr
$ctoConstr :: Strand -> Constr
gunfold :: (forall b r. Data b => c (b -> r) -> c r)
-> (forall r. r -> c r) -> Constr -> c Strand
$cgunfold :: forall (c :: * -> *).
(forall b r. Data b => c (b -> r) -> c r)
-> (forall r. r -> c r) -> Constr -> c Strand
gfoldl :: (forall d b. Data d => c (d -> b) -> d -> c b)
-> (forall g. g -> c g) -> Strand -> c Strand
$cgfoldl :: forall (c :: * -> *).
(forall d b. Data d => c (d -> b) -> d -> c b)
-> (forall g. g -> c g) -> Strand -> c Strand
$cp1Data :: Typeable Strand
Data,Typeable)

instance Show Strand where
  show :: Strand -> String
show Strand
PlusStrand    = String
"PlusStrand"
  show Strand
MinusStrand   = String
"MinusStrand"
  show Strand
NotStranded   = String
"NotStranded"
  show Strand
UnknownStrand = String
"UnknownStrand"

instance Read Strand where
  readsPrec :: Int -> ReadS Strand
readsPrec Int
_ String
xs = do
    (String
pm,String
s) <- ReadS String
lex String
xs
    case String
pm of
      String
"PlusStrand" -> (Strand, String) -> [(Strand, String)]
forall (m :: * -> *) a. Monad m => a -> m a
return (Strand
PlusStrand, String
s)
      String
"MinusStrand" -> (Strand, String) -> [(Strand, String)]
forall (m :: * -> *) a. Monad m => a -> m a
return (Strand
MinusStrand, String
s)
      String
"NotStranded" -> (Strand, String) -> [(Strand, String)]
forall (m :: * -> *) a. Monad m => a -> m a
return (Strand
NotStranded, String
s)
      String
"UnknownStrand" -> (Strand, String) -> [(Strand, String)]
forall (m :: * -> *) a. Monad m => a -> m a
return (Strand
UnknownStrand, String
s)
      [Char
x] | Char
x Char -> String -> Bool
forall (t :: * -> *) a. (Foldable t, Eq a) => a -> t a -> Bool
`elem` (String
"+Pp" :: String) -> (Strand, String) -> [(Strand, String)]
forall (m :: * -> *) a. Monad m => a -> m a
return (Strand
PlusStrand,String
s)
          | Char
x Char -> String -> Bool
forall (t :: * -> *) a. (Foldable t, Eq a) => a -> t a -> Bool
`elem` (String
"-Mm" :: String) -> (Strand, String) -> [(Strand, String)]
forall (m :: * -> *) a. Monad m => a -> m a
return (Strand
MinusStrand,String
s)
          | Char
x Char -> String -> Bool
forall (t :: * -> *) a. (Foldable t, Eq a) => a -> t a -> Bool
`elem` (String
"."   :: String) -> (Strand, String) -> [(Strand, String)]
forall (m :: * -> *) a. Monad m => a -> m a
return (Strand
NotStranded,String
s)
          | Char
x Char -> String -> Bool
forall (t :: * -> *) a. (Foldable t, Eq a) => a -> t a -> Bool
`elem` (String
"?"   :: String) -> (Strand, String) -> [(Strand, String)]
forall (m :: * -> *) a. Monad m => a -> m a
return (Strand
UnknownStrand,String
s)
      String
_ -> []

instance Bounded Strand where
  minBound :: Strand
minBound = Strand
PlusStrand
  maxBound :: Strand
maxBound = Strand
UnknownStrand

instance Enum Strand where
  succ :: Strand -> Strand
succ (Strand Int
k)
    | Int
k Int -> Int -> Bool
forall a. Ord a => a -> a -> Bool
<  Int
0 = String -> Strand
forall a. HasCallStack => String -> a
error String
"succ undefined strand"
    | Int
k Int -> Int -> Bool
forall a. Eq a => a -> a -> Bool
== Int
3 = String -> Strand
forall a. HasCallStack => String -> a
error String
"succ UnknownStrand"
    | Int
k Int -> Int -> Bool
forall a. Ord a => a -> a -> Bool
>  Int
3 = String -> Strand
forall a. HasCallStack => String -> a
error String
"succ undefined strand"
    | Bool
otherwise = Int -> Strand
Strand (Int
kInt -> Int -> Int
forall a. Num a => a -> a -> a
+Int
1)
  pred :: Strand -> Strand
pred (Strand Int
k)
    | Int
k Int -> Int -> Bool
forall a. Ord a => a -> a -> Bool
<  Int
0 = String -> Strand
forall a. HasCallStack => String -> a
error String
"pred undefined strand"
    | Int
k Int -> Int -> Bool
forall a. Eq a => a -> a -> Bool
== Int
0 = String -> Strand
forall a. HasCallStack => String -> a
error String
"pred UnknownStrand"
    | Int
k Int -> Int -> Bool
forall a. Ord a => a -> a -> Bool
>  Int
3 = String -> Strand
forall a. HasCallStack => String -> a
error String
"pred undefined strand"
    | Bool
otherwise = Int -> Strand
Strand (Int
kInt -> Int -> Int
forall a. Num a => a -> a -> a
-Int
1)
  toEnum :: Int -> Strand
toEnum Int
i | Int
iInt -> Int -> Bool
forall a. Ord a => a -> a -> Bool
>=Int
0 Bool -> Bool -> Bool
&& Int
iInt -> Int -> Bool
forall a. Ord a => a -> a -> Bool
<=Int
3 = Int -> Strand
Strand Int
i
  toEnum Int
i                = String -> Strand
forall a. HasCallStack => String -> a
error (String -> Strand) -> String -> Strand
forall a b. (a -> b) -> a -> b
$ String
"toEnum (Strand)" String -> ShowS
forall a. [a] -> [a] -> [a]
++ Int -> String
forall a. Show a => a -> String
show Int
i
  fromEnum :: Strand -> Int
fromEnum = Strand -> Int
getStrand

instance Reversing Strand where
  reversing :: Strand -> Strand
reversing Strand
PlusStrand  = Strand
MinusStrand
  reversing Strand
MinusStrand = Strand
PlusStrand
  reversing Strand
x           = Strand
x

pattern $bPlusStrand :: Strand
$mPlusStrand :: forall r. Strand -> (Void# -> r) -> (Void# -> r) -> r
PlusStrand    = Strand 0
pattern $bMinusStrand :: Strand
$mMinusStrand :: forall r. Strand -> (Void# -> r) -> (Void# -> r) -> r
MinusStrand   = Strand 1
pattern $bNotStranded :: Strand
$mNotStranded :: forall r. Strand -> (Void# -> r) -> (Void# -> r) -> r
NotStranded   = Strand 2
pattern $bUnknownStrand :: Strand
$mUnknownStrand :: forall r. Strand -> (Void# -> r) -> (Void# -> r) -> r
UnknownStrand = Strand 3

-- TODO Sense and Antisense are somewhat different

--pattern Sense     = P
--pattern AntiSense = M

instance Binary    Strand
instance Serialize Strand
instance ToJSON    Strand
instance FromJSON  Strand
instance Hashable  Strand
instance NFData    Strand

derivingUnbox "Strand"
  [t| Strand -> Int |]  [| getStrand |]  [| Strand |]

instance Index Strand where
  newtype (LimitType Strand) = LtStrand Strand
  linearIndex :: LimitType Strand -> Strand -> Int
linearIndex LimitType Strand
_ (Strand Int
z) = Int
z
  {-# INLINE linearIndex #-}
  size :: LimitType Strand -> Int
size (LtStrand (Strand h)) = Int
h Int -> Int -> Int
forall a. Num a => a -> a -> a
+ Int
1
  {-# INLINE size #-}
  inBounds :: LimitType Strand -> Strand -> Bool
inBounds (LtStrand (Strand h)) (Strand Int
x) = Int
0Int -> Int -> Bool
forall a. Ord a => a -> a -> Bool
<=Int
x Bool -> Bool -> Bool
&& Int
xInt -> Int -> Bool
forall a. Ord a => a -> a -> Bool
<=Int
h
  {-# INLINE inBounds #-}
  zeroBound :: Strand
zeroBound = Int -> Strand
Strand Int
0
  {-# Inline zeroBound #-}
  zeroBound' :: LimitType Strand
zeroBound' = Strand -> LimitType Strand
LtStrand Strand
forall i. Index i => i
zeroBound
  {-# Inline zeroBound' #-}
  totalSize :: LimitType Strand -> [Integer]
totalSize (LtStrand (Strand k)) = [ Int -> Integer
forall a b. (Integral a, Num b) => a -> b
fromIntegral (Int -> Int
forall a. Enum a => a -> Int
fromEnum Int
k Int -> Int -> Int
forall a. Num a => a -> a -> a
+ Int
1) ]
  {-# Inline totalSize #-}
  fromLinearIndex :: LimitType Strand -> Int -> Strand
fromLinearIndex LimitType Strand
_ = Int -> Strand
Strand
  {-# Inline [0] fromLinearIndex #-}
  showBound :: LimitType Strand -> [String]
showBound (LtStrand k) = [String
"LtStrand " String -> ShowS
forall a. [a] -> [a] -> [a]
++ Strand -> String
forall a. Show a => a -> String
show Strand
k]
  showIndex :: Strand -> [String]
showIndex (Strand Int
k) = [String
"Strand " String -> ShowS
forall a. [a] -> [a] -> [a]
++ Int -> String
forall a. Show a => a -> String
show Int
k]

instance IndexStream z => IndexStream (z:.Strand) where
  streamUp :: LimitType (z :. Strand)
-> LimitType (z :. Strand) -> Stream m (z :. Strand)
streamUp (ls:..LtStrand (Strand lf)) (hs:..LtStrand (Strand ht)) = (z -> m (z, Int))
-> ((z, Int) -> m (Step (z, Int) (z :. Strand)))
-> Stream m z
-> Stream m (z :. Strand)
forall (m :: * -> *) a s b.
Monad m =>
(a -> m s) -> (s -> m (Step s b)) -> Stream m a -> Stream m b
flatten z -> m (z, Int)
mk (z, Int) -> m (Step (z, Int) (z :. Strand))
step (Stream m z -> Stream m (z :. Strand))
-> Stream m z -> Stream m (z :. Strand)
forall a b. (a -> b) -> a -> b
$ LimitType z -> LimitType z -> Stream m z
forall i (m :: * -> *).
(IndexStream i, Monad m) =>
LimitType i -> LimitType i -> Stream m i
streamUp LimitType z
ls LimitType z
hs
    where mk :: z -> m (z, Int)
mk z
z = (z, Int) -> m (z, Int)
forall (m :: * -> *) a. Monad m => a -> m a
return (z
z,Int
lf)
          step :: (z, Int) -> m (Step (z, Int) (z :. Strand))
step (z
z,Int
k)
            | Int
k Int -> Int -> Bool
forall a. Ord a => a -> a -> Bool
> Int
ht    = Step (z, Int) (z :. Strand) -> m (Step (z, Int) (z :. Strand))
forall (m :: * -> *) a. Monad m => a -> m a
return (Step (z, Int) (z :. Strand) -> m (Step (z, Int) (z :. Strand)))
-> Step (z, Int) (z :. Strand) -> m (Step (z, Int) (z :. Strand))
forall a b. (a -> b) -> a -> b
$ Step (z, Int) (z :. Strand)
forall s a. Step s a
Done
            | Bool
otherwise = Step (z, Int) (z :. Strand) -> m (Step (z, Int) (z :. Strand))
forall (m :: * -> *) a. Monad m => a -> m a
return (Step (z, Int) (z :. Strand) -> m (Step (z, Int) (z :. Strand)))
-> Step (z, Int) (z :. Strand) -> m (Step (z, Int) (z :. Strand))
forall a b. (a -> b) -> a -> b
$ (z :. Strand) -> (z, Int) -> Step (z, Int) (z :. Strand)
forall a s. a -> s -> Step s a
Yield (z
zz -> Strand -> z :. Strand
forall a b. a -> b -> a :. b
:.Int -> Strand
Strand Int
k) (z
z,Int
kInt -> Int -> Int
forall a. Num a => a -> a -> a
+Int
1)
          {-# Inline [0] mk   #-}
          {-# Inline [0] step #-}
  {-# Inline streamUp #-}
  streamDown :: LimitType (z :. Strand)
-> LimitType (z :. Strand) -> Stream m (z :. Strand)
streamDown (ls:..LtStrand (Strand lf)) (hs:..LtStrand (Strand ht)) = (z -> m (z, Int))
-> ((z, Int) -> m (Step (z, Int) (z :. Strand)))
-> Stream m z
-> Stream m (z :. Strand)
forall (m :: * -> *) a s b.
Monad m =>
(a -> m s) -> (s -> m (Step s b)) -> Stream m a -> Stream m b
flatten z -> m (z, Int)
mk (z, Int) -> m (Step (z, Int) (z :. Strand))
step (Stream m z -> Stream m (z :. Strand))
-> Stream m z -> Stream m (z :. Strand)
forall a b. (a -> b) -> a -> b
$ LimitType z -> LimitType z -> Stream m z
forall i (m :: * -> *).
(IndexStream i, Monad m) =>
LimitType i -> LimitType i -> Stream m i
streamDown LimitType z
ls LimitType z
hs
    where mk :: z -> m (z, Int)
mk z
z = (z, Int) -> m (z, Int)
forall (m :: * -> *) a. Monad m => a -> m a
return (z
z,Int
ht)
          step :: (z, Int) -> m (Step (z, Int) (z :. Strand))
step (z
z,Int
k)
            | Int
k Int -> Int -> Bool
forall a. Ord a => a -> a -> Bool
< Int
lf    = Step (z, Int) (z :. Strand) -> m (Step (z, Int) (z :. Strand))
forall (m :: * -> *) a. Monad m => a -> m a
return (Step (z, Int) (z :. Strand) -> m (Step (z, Int) (z :. Strand)))
-> Step (z, Int) (z :. Strand) -> m (Step (z, Int) (z :. Strand))
forall a b. (a -> b) -> a -> b
$ Step (z, Int) (z :. Strand)
forall s a. Step s a
Done
            | Bool
otherwise = Step (z, Int) (z :. Strand) -> m (Step (z, Int) (z :. Strand))
forall (m :: * -> *) a. Monad m => a -> m a
return (Step (z, Int) (z :. Strand) -> m (Step (z, Int) (z :. Strand)))
-> Step (z, Int) (z :. Strand) -> m (Step (z, Int) (z :. Strand))
forall a b. (a -> b) -> a -> b
$ (z :. Strand) -> (z, Int) -> Step (z, Int) (z :. Strand)
forall a s. a -> s -> Step s a
Yield (z
zz -> Strand -> z :. Strand
forall a b. a -> b -> a :. b
:.Int -> Strand
Strand Int
k) (z
z,Int
kInt -> Int -> Int
forall a. Num a => a -> a -> a
-Int
1)
          {-# Inline [0] mk   #-}
          {-# Inline [0] step #-}
  {-# Inline streamDown #-}

-- instance IndexStream Strand

instance Arbitrary Strand where
  arbitrary :: Gen Strand
arbitrary = do
    Int
b <- (Int, Int) -> Gen Int
forall a. Random a => (a, a) -> Gen a
choose (Int
0,Int
3)
    Strand -> Gen Strand
forall (m :: * -> *) a. Monad m => a -> m a
return (Strand -> Gen Strand) -> Strand -> Gen Strand
forall a b. (a -> b) -> a -> b
$ Int -> Strand
Strand Int
b
  shrink :: Strand -> [Strand]
shrink (Strand Int
j)
    | Int
0Int -> Int -> Bool
forall a. Ord a => a -> a -> Bool
<Int
j = [Int -> Strand
Strand (Int -> Strand) -> Int -> Strand
forall a b. (a -> b) -> a -> b
$ Int
jInt -> Int -> Int
forall a. Num a => a -> a -> a
-Int
1]
    | Bool
otherwise = []