data ListT f a

newtype ZipListT f a

nil :: forall f a. (Applicative f) => ListT f a

cons' :: forall f a. (Applicative f) => Lazy a -> Lazy (ListT f a) -> ListT f a

prepend' :: forall f a. (Applicative f) => a -> Lazy (ListT f a) -> ListT f a

prepend :: forall f a. (Applicative f) => a -> ListT f a -> ListT f a

singleton :: forall f a. (Applicative f) => a -> ListT f a

fromEffect :: forall f a. (Applicative f) => f a -> ListT f a

wrapEffect :: forall f a. (Monad f) => f (ListT f a) -> ListT f a

wrapLazy :: forall f a. (Monad f) => Lazy (ListT f a) -> ListT f a

unfold :: forall f a z. (Monad f) => (z -> f (Maybe (Tuple z a))) -> z -> ListT f a

iterate :: forall f a. (Monad f) => (a -> a) -> a -> ListT f a

repeat :: forall f a. (Monad f) => a -> ListT f a

fromArray :: forall f a. (Monad f) => [a] -> ListT f a

toArray :: forall f a. (Monad f) => ListT f a -> f [a]

take :: forall f a. (Applicative f) => Number -> ListT f a -> ListT f a

takeWhile :: forall f a. (Applicative f) => (a -> Boolean) -> ListT f a -> ListT f a

drop :: forall f a. (Applicative f) => Number -> ListT f a -> ListT f a

dropWhile :: forall f a. (Applicative f) => (a -> Boolean) -> ListT f a -> ListT f a

filter :: forall f a. (Functor f) => (a -> Boolean) -> ListT f a -> ListT f a

mapMaybe :: forall f a b. (Functor f) => (a -> Maybe b) -> ListT f a -> ListT f b

catMaybes :: forall f a. (Functor f) => ListT f (Maybe a) -> ListT f a

uncons :: forall f a. (Monad f) => ListT f a -> f (Maybe (Tuple a (ListT f a)))

head :: forall f a. (Monad f) => ListT f a -> f (Maybe a)

tail :: forall f a. (Monad f) => ListT f a -> f (Maybe (ListT f a))

foldl' :: forall f a b. (Monad f) => (b -> a -> f b) -> b -> ListT f a -> f b

foldl :: forall f a b. (Monad f) => (b -> a -> b) -> b -> ListT f a -> f b

scanl :: forall f a b. (Monad f) => (b -> a -> b) -> b -> ListT f a -> ListT f b

zipWith' :: forall f a b c. (Monad f) => (a -> b -> f c) -> ListT f a -> ListT f b -> ListT f c

zipWith :: forall f a b c. (Monad f) => (a -> b -> c) -> ListT f a -> ListT f b -> ListT f c

zipList :: forall f a. ListT f a -> ZipListT f a

instance semigroupListT :: (Applicative f) => Semigroup (ListT f a)

instance semigroupZipListT :: (Applicative f) => Semigroup (ZipListT f a)

instance monoidListT :: (Applicative f) => Monoid (ListT f a)

instance monoidZipListT :: (Applicative f) => Monoid (ZipListT f a)

instance functorListT :: (Functor f) => Functor (ListT f)

instance functorZipListT :: (Functor f) => Functor (ZipListT f)

instance unfoldableListT :: (Monad f) => Unfoldable (ListT f)

instance applyListT :: (Monad f) => Apply (ListT f)

instance applyZipListT :: (Monad f) => Apply (ZipListT f)

instance applicativeListT :: (Monad f) => Applicative (ListT f)

instance applicativeZipListT :: (Monad f) => Applicative (ZipListT f)

instance bindListT :: (Monad f) => Bind (ListT f)

instance monadListT :: (Monad f) => Monad (ListT f)

instance monadTransListT :: MonadTrans ListT

instance altListT :: (Applicative f) => Alt (ListT f)

instance altZipListT :: (Applicative f) => Alt (ZipListT f)

instance plusListT :: (Monad f) => Plus (ListT f)

instance plusZipListT :: (Monad f) => Plus (ZipListT f)

instance alternativeListT :: (Monad f) => Alternative (ListT f)

instance alternativeZipListT :: (Monad f) => Alternative (ZipListT f)

instance monadPlusListT :: (Monad f) => MonadPlus (ListT f)

data List a
  = Nil 
  | Cons a (List a)

instance showList :: (Show a) => Show (List a)

instance eqList :: (Eq a) => Eq (List a)

instance ordList :: (Ord a) => Ord (List a)

instance semigroupList :: Semigroup (List a)

instance monoidList :: Monoid (List a)

instance functorList :: Functor List

instance foldableList :: Foldable List

instance unfoldableList :: Unfoldable List

instance traversableList :: Traversable List

instance applyList :: Apply List

instance applicativeList :: Applicative List

instance bindList :: Bind List

instance monadList :: Monad List

instance altList :: Alt List

instance plusList :: Plus List

instance alternativeList :: Alternative List

instance monadPlusList :: MonadPlus List

fromArray :: forall a. [a] -> List a

toArray :: forall a. List a -> [a]

(!) :: forall a. List a -> Number -> Maybe a

drop :: forall a. Number -> List a -> List a

take :: forall a. Number -> List a -> List a

length :: forall a. List a -> Number

filter :: forall a. (a -> Boolean) -> List a -> List a

mapMaybe :: forall a b. (a -> Maybe b) -> List a -> List b

catMaybes :: forall a. List (Maybe a) -> List a

head :: forall a. List a -> Maybe a

tail :: forall a. List a -> Maybe (List a)

uncons :: forall a. List a -> Maybe (Tuple a (List a))

last :: forall a. List a -> Maybe a

init :: forall a. List a -> Maybe (List a)

zipWith :: forall a b c. (a -> b -> c) -> List a -> List b -> List c

null :: forall a. List a -> Boolean

span :: forall a. (a -> Boolean) -> List a -> Tuple (List a) (List a)

group :: forall a. (Eq a) => List a -> List (List a)

groupBy :: forall a. (a -> a -> Boolean) -> List a -> List (List a)

(\\) :: forall a. (Eq a) => List a -> List a -> List a

insert :: forall a. (Ord a) => a -> List a -> List a

insertBy :: forall a. (a -> a -> Ordering) -> a -> List a -> List a

insertAt :: forall a. Number -> a -> List a -> Maybe (List a)

delete :: forall a. (Eq a) => a -> List a -> List a

deleteBy :: forall a. (a -> a -> Boolean) -> a -> List a -> List a

deleteAt :: forall a. Number -> List a -> Maybe (List a)

alterAt :: forall a. Number -> (a -> Maybe a) -> List a -> Maybe (List a)

reverse :: forall a. List a -> List a

nub :: forall a. (Eq a) => List a -> List a

nubBy :: forall a. (a -> a -> Boolean) -> List a -> List a

intersect :: forall a. (Eq a) => List a -> List a -> List a

intersectBy :: forall a. (a -> a -> Boolean) -> List a -> List a -> List a

union :: forall a. (Eq a) => List a -> List a -> List a

unionBy :: forall a. (a -> a -> Boolean) -> List a -> List a -> List a

type List = L.ListT Lazy

newtype LazyList a
  = LazyList (List a)

unLazyList :: forall a. LazyList a -> List a

instance foldableLazyList :: Foldable LazyList

head :: forall a. List a -> a

tail :: forall a. List a -> List a

last :: forall a. List a -> a

init :: forall a. List a -> List a

instance arbitraryListT :: (Monad f, Arbitrary a) => Arbitrary (ListT f a)

instance arbitraryList :: (Arbitrary a) => Arbitrary (List a)