Hat.Data.List

Documentation

(!++) :: RefSrcPos -> RefExp -> R (Fun (List a) (Fun (List a) (List a)))

(+++) :: RefAtom

(*++) :: R (List a) -> R (List a) -> RefExp -> R (List a)

ghead :: RefSrcPos -> RefExp -> R (Fun (List a) a)

ahead :: RefAtom

hhead :: R (List a) -> RefExp -> R a

glast :: RefSrcPos -> RefExp -> R (Fun (List a) a)

alast :: RefAtom

hlast :: R (List a) -> RefExp -> R a

gtail :: RefSrcPos -> RefExp -> R (Fun (List a) (List a))

atail :: RefAtom

htail :: R (List a) -> RefExp -> R (List a)

ginit :: RefSrcPos -> RefExp -> R (Fun (List a) (List a))

ainit :: RefAtom

hinit :: R (List a) -> RefExp -> R (List a)

gnull :: RefSrcPos -> RefExp -> R (Fun (List a) Bool)

anull :: RefAtom

hnull :: R (List a) -> RefExp -> R Bool

glength :: RefSrcPos -> RefExp -> R (Fun (List a) Int)

alength :: RefAtom

hlength :: R (List a) -> RefExp -> R Int

gmap :: RefSrcPos -> RefExp -> R (Fun (Fun a b) (Fun (List a) (List b)))

amap :: RefAtom

hmap :: R (Fun a b) -> R (List a) -> RefExp -> R (List b)

greverse :: RefSrcPos -> RefExp -> R (Fun (List a) (List a))

gintersperse :: RefSrcPos -> RefExp -> R (Fun a (Fun (List a) (List a)))

aintersperse :: RefAtom

hintersperse :: R a -> R (List a) -> RefExp -> R (List a)

gintercalate :: RefSrcPos -> RefExp -> R (Fun (List a) (Fun (List (List a)) (List a)))

aintercalate :: RefAtom

hintercalate :: R (List a) -> R (List (List a)) -> RefExp -> R (List a)

gtranspose :: RefSrcPos -> RefExp -> R (Fun (List (List a)) (List (List a)))

atranspose :: RefAtom

htranspose :: R (List (List a)) -> RefExp -> R (List (List a))

gsubsequences :: RefSrcPos -> RefExp -> R (Fun (List a) (List (List a)))

asubsequences :: RefAtom

hsubsequences :: R (List a) -> RefExp -> R (List (List a))

gpermutations :: RefSrcPos -> RefExp -> R (Fun (List a) (List (List a)))

apermutations :: RefAtom

hpermutations :: R (List a) -> RefExp -> R (List (List a))

gfoldl :: RefSrcPos -> RefExp -> R (Fun (Fun a (Fun b a)) (Fun a (Fun (List b) a)))

afoldl :: RefAtom

hfoldl :: R (Fun a (Fun b a)) -> R a -> R (List b) -> RefExp -> R a

gfoldl' :: RefSrcPos -> RefExp -> R (Fun (Fun a (Fun b a)) (Fun a (Fun (List b) a)))

afoldl' :: RefAtom

hfoldl' :: R (Fun a (Fun b a)) -> R a -> R (List b) -> RefExp -> R a

gfoldl1 :: RefSrcPos -> RefExp -> R (Fun (Fun a (Fun a a)) (Fun (List a) a))

afoldl1 :: RefAtom

hfoldl1 :: R (Fun a (Fun a a)) -> R (List a) -> RefExp -> R a

gfoldl1' :: RefSrcPos -> RefExp -> R (Fun (Fun a (Fun a a)) (Fun (List a) a))

afoldl1' :: RefAtom

hfoldl1' :: R (Fun a (Fun a a)) -> R (List a) -> RefExp -> R a

gfoldr :: RefSrcPos -> RefExp -> R (Fun (Fun a (Fun b b)) (Fun b (Fun (List a) b)))

afoldr :: RefAtom

hfoldr :: R (Fun a (Fun b b)) -> R b -> R (List a) -> RefExp -> R b

gfoldr1 :: RefSrcPos -> RefExp -> R (Fun (Fun a (Fun a a)) (Fun (List a) a))

afoldr1 :: RefAtom

hfoldr1 :: R (Fun a (Fun a a)) -> R (List a) -> RefExp -> R a

gconcat :: RefSrcPos -> RefExp -> R (Fun (List (List a)) (List a))

aconcat :: RefAtom

hconcat :: R (List (List a)) -> RefExp -> R (List a)

gconcatMap :: RefSrcPos -> RefExp -> R (Fun (Fun a (List b)) (Fun (List a) (List b)))

aconcatMap :: RefAtom

hconcatMap :: R (Fun a (List b)) -> RefExp -> R (Fun (List a) (List b))

gand :: RefSrcPos -> RefExp -> R (Fun (List Bool) Bool)

gor :: RefSrcPos -> RefExp -> R (Fun (List Bool) Bool)

gany :: RefSrcPos -> RefExp -> R (Fun (Fun a Bool) (Fun (List a) Bool))

aany :: RefAtom

hany :: R (Fun a Bool) -> RefExp -> R (Fun (List a) Bool)

gall :: RefSrcPos -> RefExp -> R (Fun (Fun a Bool) (Fun (List a) Bool))

aall :: RefAtom

hall :: R (Fun a Bool) -> RefExp -> R (Fun (List a) Bool)

gsum :: Num a => RefSrcPos -> RefExp -> R (Fun (List a) a)

gproduct :: Num a => RefSrcPos -> RefExp -> R (Fun (List a) a)

gmaximum :: Ord a => RefSrcPos -> RefExp -> R (Fun (List a) a)

amaximum :: RefAtom

hmaximum :: Ord a => R (List a) -> RefExp -> R a

gminimum :: Ord a => RefSrcPos -> RefExp -> R (Fun (List a) a)

aminimum :: RefAtom

hminimum :: Ord a => R (List a) -> RefExp -> R a

gscanl :: RefSrcPos -> RefExp -> R (Fun (Fun a (Fun b a)) (Fun a (Fun (List b) (List a))))

ascanl :: RefAtom

hscanl :: R (Fun a (Fun b a)) -> R a -> R (List b) -> RefExp -> R (List a)

gscanl1 :: RefSrcPos -> RefExp -> R (Fun (Fun a (Fun a a)) (Fun (List a) (List a)))

ascanl1 :: RefAtom

hscanl1 :: R (Fun a (Fun a a)) -> R (List a) -> RefExp -> R (List a)

gscanr :: RefSrcPos -> RefExp -> R (Fun (Fun a (Fun b b)) (Fun b (Fun (List a) (List b))))

ascanr :: RefAtom

hscanr :: R (Fun a (Fun b b)) -> R b -> R (List a) -> RefExp -> R (List b)

gscanr1 :: RefSrcPos -> RefExp -> R (Fun (Fun a (Fun a a)) (Fun (List a) (List a)))

ascanr1 :: RefAtom

hscanr1 :: R (Fun a (Fun a a)) -> R (List a) -> RefExp -> R (List a)

gmapAccumL :: RefSrcPos -> RefExp -> R (Fun (Fun a (Fun b (Tuple2 a c))) (Fun a (Fun (List b) (Tuple2 a (List c)))))

amapAccumL :: RefAtom

hmapAccumL :: R (Fun a (Fun b (Tuple2 a c))) -> R a -> R (List b) -> RefExp -> R (Tuple2 a (List c))

gmapAccumR :: RefSrcPos -> RefExp -> R (Fun (Fun a (Fun b (Tuple2 a c))) (Fun a (Fun (List b) (Tuple2 a (List c)))))

amapAccumR :: RefAtom

hmapAccumR :: R (Fun a (Fun b (Tuple2 a c))) -> R a -> R (List b) -> RefExp -> R (Tuple2 a (List c))

giterate :: RefSrcPos -> RefExp -> R (Fun (Fun a a) (Fun a (List a)))

aiterate :: RefAtom

hiterate :: R (Fun a a) -> R a -> RefExp -> R (List a)

grepeat :: RefSrcPos -> RefExp -> R (Fun a (List a))

arepeat :: RefAtom

hrepeat :: R a -> RefExp -> R (List a)

greplicate :: RefSrcPos -> RefExp -> R (Fun Int (Fun a (List a)))

areplicate :: RefAtom

hreplicate :: R Int -> R a -> RefExp -> R (List a)

gcycle :: RefSrcPos -> RefExp -> R (Fun (List a) (List a))

acycle :: RefAtom

hcycle :: R (List a) -> RefExp -> R (List a)

gunfoldr :: RefSrcPos -> RefExp -> R (Fun (Fun b (Maybe (Tuple2 a b))) (Fun b (List a)))

aunfoldr :: RefAtom

hunfoldr :: R (Fun b (Maybe (Tuple2 a b))) -> R b -> RefExp -> R (List a)

gtake :: RefSrcPos -> RefExp -> R (Fun Int (Fun (List a) (List a)))

atake :: RefAtom

htake :: R Int -> R (List a) -> RefExp -> R (List a)

gdrop :: RefSrcPos -> RefExp -> R (Fun Int (Fun (List a) (List a)))

adrop :: RefAtom

hdrop :: R Int -> R (List a) -> RefExp -> R (List a)

gsplitAt :: RefSrcPos -> RefExp -> R (Fun Int (Fun (List a) (Tuple2 (List a) (List a))))

asplitAt :: RefAtom

hsplitAt :: R Int -> R (List a) -> RefExp -> R (Tuple2 (List a) (List a))

gtakeWhile :: RefSrcPos -> RefExp -> R (Fun (Fun a Bool) (Fun (List a) (List a)))

atakeWhile :: RefAtom

htakeWhile :: R (Fun a Bool) -> R (List a) -> RefExp -> R (List a)

gdropWhile :: RefSrcPos -> RefExp -> R (Fun (Fun a Bool) (Fun (List a) (List a)))

adropWhile :: RefAtom

hdropWhile :: R (Fun a Bool) -> R (List a) -> RefExp -> R (List a)

gspan :: RefSrcPos -> RefExp -> R (Fun (Fun a Bool) (Fun (List a) (Tuple2 (List a) (List a))))

aspan :: RefAtom

hspan :: R (Fun a Bool) -> R (List a) -> RefExp -> R (Tuple2 (List a) (List a))

gbreak :: RefSrcPos -> RefExp -> R (Fun (Fun a Bool) (Fun (List a) (Tuple2 (List a) (List a))))

abreak :: RefAtom

hbreak :: R (Fun a Bool) -> RefExp -> R (Fun (List a) (Tuple2 (List a) (List a)))

gstripPrefix :: Eq a => RefSrcPos -> RefExp -> R (Fun (List a) (Fun (List a) (Maybe (List a))))

astripPrefix :: RefAtom

hstripPrefix :: Eq a => R (List a) -> R (List a) -> RefExp -> R (Maybe (List a))

ggroup :: Eq a => RefSrcPos -> RefExp -> R (Fun (List a) (List (List a)))

ginits :: RefSrcPos -> RefExp -> R (Fun (List a) (List (List a)))

ainits :: RefAtom

hinits :: R (List a) -> RefExp -> R (List (List a))

gtails :: RefSrcPos -> RefExp -> R (Fun (List a) (List (List a)))

atails :: RefAtom

htails :: R (List a) -> RefExp -> R (List (List a))

gisPrefixOf :: Eq a => RefSrcPos -> RefExp -> R (Fun (List a) (Fun (List a) Bool))

aisPrefixOf :: RefAtom

hisPrefixOf :: Eq a => R (List a) -> R (List a) -> RefExp -> R Bool

gisSuffixOf :: Eq a => RefSrcPos -> RefExp -> R (Fun (List a) (Fun (List a) Bool))

aisSuffixOf :: RefAtom

hisSuffixOf :: Eq a => R (List a) -> R (List a) -> RefExp -> R Bool

gisInfixOf :: Eq a => RefSrcPos -> RefExp -> R (Fun (List a) (Fun (List a) Bool))

aisInfixOf :: RefAtom

hisInfixOf :: Eq a => R (List a) -> R (List a) -> RefExp -> R Bool

gelem :: Eq a => RefSrcPos -> RefExp -> R (Fun a (Fun (List a) Bool))

aelem :: RefAtom

helem :: Eq a => R a -> RefExp -> R (Fun (List a) Bool)

gnotElem :: Eq a => RefSrcPos -> RefExp -> R (Fun a (Fun (List a) Bool))

anotElem :: RefAtom

hnotElem :: Eq a => R a -> RefExp -> R (Fun (List a) Bool)

glookup :: Eq a => RefSrcPos -> RefExp -> R (Fun a (Fun (List (Tuple2 a b)) (Maybe b)))

alookup :: RefAtom

hlookup :: Eq a => R a -> R (List (Tuple2 a b)) -> RefExp -> R (Maybe b)

gfind :: RefSrcPos -> RefExp -> R (Fun (Fun a Bool) (Fun (List a) (Maybe a)))

afind :: RefAtom

hfind :: R (Fun a Bool) -> RefExp -> R (Fun (List a) (Maybe a))

gfilter :: RefSrcPos -> RefExp -> R (Fun (Fun a Bool) (Fun (List a) (List a)))

afilter :: RefAtom

hfilter :: R (Fun a Bool) -> R (List a) -> RefExp -> R (List a)

gpartition :: RefSrcPos -> RefExp -> R (Fun (Fun a Bool) (Fun (List a) (Tuple2 (List a) (List a))))

apartition :: RefAtom

hpartition :: R (Fun a Bool) -> R (List a) -> RefExp -> R (Tuple2 (List a) (List a))

(!!!) :: RefSrcPos -> RefExp -> R (Fun (List a) (Fun Int a))

(+!!) :: RefAtom

(*!!) :: R (List a) -> R Int -> RefExp -> R a

gelemIndex :: Eq a => RefSrcPos -> RefExp -> R (Fun a (Fun (List a) (Maybe Int)))

aelemIndex :: RefAtom

helemIndex :: Eq a => R a -> RefExp -> R (Fun (List a) (Maybe Int))

gelemIndices :: Eq a => RefSrcPos -> RefExp -> R (Fun a (Fun (List a) (List Int)))

aelemIndices :: RefAtom

helemIndices :: Eq a => R a -> RefExp -> R (Fun (List a) (List Int))

gfindIndex :: RefSrcPos -> RefExp -> R (Fun (Fun a Bool) (Fun (List a) (Maybe Int)))

afindIndex :: RefAtom

hfindIndex :: R (Fun a Bool) -> RefExp -> R (Fun (List a) (Maybe Int))

gfindIndices :: RefSrcPos -> RefExp -> R (Fun (Fun a Bool) (Fun (List a) (List Int)))

afindIndices :: RefAtom

hfindIndices :: R (Fun a Bool) -> R (List a) -> RefExp -> R (List Int)

gzip :: RefSrcPos -> RefExp -> R (Fun (List a) (Fun (List b) (List (Tuple2 a b))))

gzip3 :: RefSrcPos -> RefExp -> R (Fun (List a) (Fun (List b) (Fun (List c) (List (Tuple3 a b c)))))

gzip4 :: RefSrcPos -> RefExp -> R (Fun (List a) (Fun (List b) (Fun (List c) (Fun (List d) (List (Tuple4 a b c d))))))

gzip5 :: RefSrcPos -> RefExp -> R (Fun (List a) (Fun (List b) (Fun (List c) (Fun (List d) (Fun (List e) (List (Tuple5 a b c d e)))))))

gzip6 :: RefSrcPos -> RefExp -> R (Fun (List a) (Fun (List b) (Fun (List c) (Fun (List d) (Fun (List e) (Fun (List f) (List (Tuple6 a b c d e f))))))))

gzip7 :: RefSrcPos -> RefExp -> R (Fun (List a) (Fun (List b) (Fun (List c) (Fun (List d) (Fun (List e) (Fun (List f) (Fun (List g) (List (Tuple7 a b c d e f g)))))))))

gzipWith :: RefSrcPos -> RefExp -> R (Fun (Fun a (Fun b c)) (Fun (List a) (Fun (List b) (List c))))

azipWith :: RefAtom

hzipWith :: R (Fun a (Fun b c)) -> R (List a) -> R (List b) -> RefExp -> R (List c)

gzipWith3 :: RefSrcPos -> RefExp -> R (Fun (Fun a (Fun b (Fun c d))) (Fun (List a) (Fun (List b) (Fun (List c) (List d)))))

azipWith3 :: RefAtom

hzipWith3 :: R (Fun a (Fun b (Fun c d))) -> R (List a) -> R (List b) -> R (List c) -> RefExp -> R (List d)

gzipWith4 :: RefSrcPos -> RefExp -> R (Fun (Fun a (Fun b (Fun c (Fun d e)))) (Fun (List a) (Fun (List b) (Fun (List c) (Fun (List d) (List e))))))

azipWith4 :: RefAtom

hzipWith4 :: R (Fun a (Fun b (Fun c (Fun d e)))) -> R (List a) -> R (List b) -> R (List c) -> R (List d) -> RefExp -> R (List e)

gzipWith5 :: RefSrcPos -> RefExp -> R (Fun (Fun a (Fun b (Fun c (Fun d (Fun e f))))) (Fun (List a) (Fun (List b) (Fun (List c) (Fun (List d) (Fun (List e) (List f)))))))

azipWith5 :: RefAtom

hzipWith5 :: R (Fun a (Fun b (Fun c (Fun d (Fun e f))))) -> R (List a) -> R (List b) -> R (List c) -> R (List d) -> R (List e) -> RefExp -> R (List f)

gzipWith6 :: RefSrcPos -> RefExp -> R (Fun (Fun a (Fun b (Fun c (Fun d (Fun e (Fun f g)))))) (Fun (List a) (Fun (List b) (Fun (List c) (Fun (List d) (Fun (List e) (Fun (List f) (List g))))))))

azipWith6 :: RefAtom

hzipWith6 :: R (Fun a (Fun b (Fun c (Fun d (Fun e (Fun f g)))))) -> R (List a) -> R (List b) -> R (List c) -> R (List d) -> R (List e) -> R (List f) -> RefExp -> R (List g)

gzipWith7 :: RefSrcPos -> RefExp -> R (Fun (Fun a (Fun b (Fun c (Fun d (Fun e (Fun f (Fun g h))))))) (Fun (List a) (Fun (List b) (Fun (List c) (Fun (List d) (Fun (List e) (Fun (List f) (Fun (List g) (List h)))))))))

azipWith7 :: RefAtom

hzipWith7 :: R (Fun a (Fun b (Fun c (Fun d (Fun e (Fun f (Fun g h))))))) -> R (List a) -> R (List b) -> R (List c) -> R (List d) -> R (List e) -> R (List f) -> R (List g) -> RefExp -> R (List h)

gunzip :: RefSrcPos -> RefExp -> R (Fun (List (Tuple2 a b)) (Tuple2 (List a) (List b)))

gunzip3 :: RefSrcPos -> RefExp -> R (Fun (List (Tuple3 a b c)) (Tuple3 (List a) (List b) (List c)))

gunzip4 :: RefSrcPos -> RefExp -> R (Fun (List (Tuple4 a b c d)) (Tuple4 (List a) (List b) (List c) (List d)))

gunzip5 :: RefSrcPos -> RefExp -> R (Fun (List (Tuple5 a b c d e)) (Tuple5 (List a) (List b) (List c) (List d) (List e)))

gunzip6 :: RefSrcPos -> RefExp -> R (Fun (List (Tuple6 a b c d e f)) (Tuple6 (List a) (List b) (List c) (List d) (List e) (List f)))

gunzip7 :: RefSrcPos -> RefExp -> R (Fun (List (Tuple7 a b c d e f g)) (Tuple7 (List a) (List b) (List c) (List d) (List e) (List f) (List g)))

glines :: RefSrcPos -> RefExp -> R (Fun String (List String))

alines :: RefAtom

hlines :: R String -> RefExp -> R (List String)

gwords :: RefSrcPos -> RefExp -> R (Fun String (List String))

awords :: RefAtom

hwords :: R String -> RefExp -> R (List String)

gunlines :: RefSrcPos -> RefExp -> R (Fun (List String) String)

gunwords :: RefSrcPos -> RefExp -> R (Fun (List String) String)

aunwords :: RefAtom

hunwords :: R (List String) -> RefExp -> R String

gnub :: Eq a => RefSrcPos -> RefExp -> R (Fun (List a) (List a))

gdelete :: Eq a => RefSrcPos -> RefExp -> R (Fun a (Fun (List a) (List a)))

(!\\) :: Eq a => RefSrcPos -> RefExp -> R (Fun (List a) (Fun (List a) (List a)))

gunion :: Eq a => RefSrcPos -> RefExp -> R (Fun (List a) (Fun (List a) (List a)))

gintersect :: Eq a => RefSrcPos -> RefExp -> R (Fun (List a) (Fun (List a) (List a)))

gsort :: Ord a => RefSrcPos -> RefExp -> R (Fun (List a) (List a))

ginsert :: Ord a => RefSrcPos -> RefExp -> R (Fun a (Fun (List a) (List a)))

gnubBy :: RefSrcPos -> RefExp -> R (Fun (Fun a (Fun a Bool)) (Fun (List a) (List a)))

anubBy :: RefAtom

hnubBy :: R (Fun a (Fun a Bool)) -> R (List a) -> RefExp -> R (List a)

gdeleteBy :: RefSrcPos -> RefExp -> R (Fun (Fun a (Fun a Bool)) (Fun a (Fun (List a) (List a))))

adeleteBy :: RefAtom

hdeleteBy :: R (Fun a (Fun a Bool)) -> R a -> R (List a) -> RefExp -> R (List a)

gdeleteFirstsBy :: RefSrcPos -> RefExp -> R (Fun (Fun a (Fun a Bool)) (Fun (List a) (Fun (List a) (List a))))

adeleteFirstsBy :: RefAtom

hdeleteFirstsBy :: R (Fun a (Fun a Bool)) -> RefExp -> R (Fun (List a) (Fun (List a) (List a)))

gunionBy :: RefSrcPos -> RefExp -> R (Fun (Fun a (Fun a Bool)) (Fun (List a) (Fun (List a) (List a))))

aunionBy :: RefAtom

hunionBy :: R (Fun a (Fun a Bool)) -> R (List a) -> R (List a) -> RefExp -> R (List a)

gintersectBy :: RefSrcPos -> RefExp -> R (Fun (Fun a (Fun a Bool)) (Fun (List a) (Fun (List a) (List a))))

aintersectBy :: RefAtom

hintersectBy :: R (Fun a (Fun a Bool)) -> R (List a) -> R (List a) -> RefExp -> R (List a)

ggroupBy :: RefSrcPos -> RefExp -> R (Fun (Fun a (Fun a Bool)) (Fun (List a) (List (List a))))

agroupBy :: RefAtom

hgroupBy :: R (Fun a (Fun a Bool)) -> R (List a) -> RefExp -> R (List (List a))

gsortBy :: RefSrcPos -> RefExp -> R (Fun (Fun a (Fun a Ordering)) (Fun (List a) (List a)))

asortBy :: RefAtom

hsortBy :: R (Fun a (Fun a Ordering)) -> RefExp -> R (Fun (List a) (List a))

ginsertBy :: RefSrcPos -> RefExp -> R (Fun (Fun a (Fun a Ordering)) (Fun a (Fun (List a) (List a))))

ainsertBy :: RefAtom

hinsertBy :: R (Fun a (Fun a Ordering)) -> R a -> R (List a) -> RefExp -> R (List a)

gmaximumBy :: RefSrcPos -> RefExp -> R (Fun (Fun a (Fun a Ordering)) (Fun (List a) a))

amaximumBy :: RefAtom

hmaximumBy :: R (Fun a (Fun a Ordering)) -> R (List a) -> RefExp -> R a

gminimumBy :: RefSrcPos -> RefExp -> R (Fun (Fun a (Fun a Ordering)) (Fun (List a) a))

aminimumBy :: RefAtom

hminimumBy :: R (Fun a (Fun a Ordering)) -> R (List a) -> RefExp -> R a

ggenericLength :: Integral a => RefSrcPos -> RefExp -> R (Fun (List b) a)

agenericLength :: RefAtom

hgenericLength :: Integral a => R (List b) -> RefExp -> R a

ggenericTake :: Integral a => RefSrcPos -> RefExp -> R (Fun a (Fun (List b) (List b)))

agenericTake :: RefAtom

hgenericTake :: Integral a => R a -> R (List b) -> RefExp -> R (List b)

ggenericDrop :: Integral a => RefSrcPos -> RefExp -> R (Fun a (Fun (List b) (List b)))

agenericDrop :: RefAtom

hgenericDrop :: Integral a => R a -> R (List b) -> RefExp -> R (List b)

ggenericSplitAt :: Integral a => RefSrcPos -> RefExp -> R (Fun a (Fun (List b) (Tuple2 (List b) (List b))))

agenericSplitAt :: RefAtom

hgenericSplitAt :: Integral a => R a -> R (List b) -> RefExp -> R (Tuple2 (List b) (List b))

ggenericIndex :: Integral a => RefSrcPos -> RefExp -> R (Fun (List b) (Fun a b))

agenericIndex :: RefAtom

hgenericIndex :: Integral a => R (List b) -> R a -> RefExp -> R b

ggenericReplicate :: Integral a => RefSrcPos -> RefExp -> R (Fun a (Fun b (List b)))

agenericReplicate :: RefAtom

hgenericReplicate :: Integral a => R a -> R b -> RefExp -> R (List b)