Safe Haskell	None
Language	Haskell98

Hat.List

Documentation

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

aelemIndex :: RefAtom Source

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

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

aelemIndices :: RefAtom Source

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

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

afind :: RefAtom Source

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

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

afindIndex :: RefAtom Source

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

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

afindIndices :: RefAtom Source

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

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

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

anubBy :: RefAtom Source

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

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

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

adeleteBy :: RefAtom Source

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

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

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

adeleteFirstsBy :: RefAtom Source

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

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

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

aunionBy :: RefAtom Source

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

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

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

aintersectBy :: RefAtom Source

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

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

aintersperse :: RefAtom Source

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

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

atranspose :: RefAtom Source

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

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

apartition :: RefAtom Source

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

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

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

agroupBy :: RefAtom Source

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

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

ainits :: RefAtom Source

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

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

atails :: RefAtom Source

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

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

aisPrefixOf :: RefAtom Source

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

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

aisSuffixOf :: RefAtom Source

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

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

amapAccumL :: RefAtom Source

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

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

amapAccumR :: RefAtom Source

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

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

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

asortBy :: RefAtom Source

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

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

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

ainsertBy :: RefAtom Source

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

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

amaximumBy :: RefAtom Source

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

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

aminimumBy :: RefAtom Source

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

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

agenericLength :: RefAtom Source

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

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

agenericTake :: RefAtom Source

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

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

agenericDrop :: RefAtom Source

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

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

agenericSplitAt :: RefAtom Source

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

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

agenericIndex :: RefAtom Source

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

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

agenericReplicate :: RefAtom Source

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

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

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))))))) Source

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)))))))) Source

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))))))))) Source

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)))))) Source

azipWith4 :: RefAtom Source

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) Source

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))))))) Source

azipWith5 :: RefAtom Source

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) Source

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)))))))) Source

azipWith6 :: RefAtom Source

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) Source

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))))))))) Source

azipWith7 :: RefAtom Source

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) Source

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

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

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))) Source

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))) Source

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

aunfoldr :: RefAtom Source

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

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

amap :: RefAtom Source

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

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

(+++) :: RefAtom Source

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

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

aconcat :: RefAtom Source

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

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

afilter :: RefAtom Source

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

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

ahead :: RefAtom Source

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

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

alast :: RefAtom Source

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

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

atail :: RefAtom Source

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

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

ainit :: RefAtom Source

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

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

anull :: RefAtom Source

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

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

alength :: RefAtom Source

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

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

(+!!) :: RefAtom Source

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

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

afoldl :: RefAtom Source

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

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

afoldl1 :: RefAtom Source

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

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

ascanl :: RefAtom Source

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

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

ascanl1 :: RefAtom Source

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

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

afoldr :: RefAtom Source

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

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

afoldr1 :: RefAtom Source

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

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

ascanr :: RefAtom Source

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

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

ascanr1 :: RefAtom Source

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

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

aiterate :: RefAtom Source

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

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

arepeat :: RefAtom Source

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

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

areplicate :: RefAtom Source

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

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

acycle :: RefAtom Source

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

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

atake :: RefAtom Source

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

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

adrop :: RefAtom Source

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

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

asplitAt :: RefAtom Source

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

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

atakeWhile :: RefAtom Source

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

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

adropWhile :: RefAtom Source

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

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

aspan :: RefAtom Source

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

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

abreak :: RefAtom Source

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

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

alines :: RefAtom Source

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

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

awords :: RefAtom Source

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

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

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

aunwords :: RefAtom Source

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

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

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

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

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

aany :: RefAtom Source

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

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

aall :: RefAtom Source

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

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

aelem :: RefAtom Source

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

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

anotElem :: RefAtom Source

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

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

alookup :: RefAtom Source

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

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

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

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

amaximum :: RefAtom Source

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

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

aminimum :: RefAtom Source

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

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

aconcatMap :: RefAtom Source

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

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

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

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

azipWith :: RefAtom Source

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

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

azipWith3 :: RefAtom Source

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

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

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