Language.Symantic.Lib.Foldable

Symantic for Foldable.

Class Sym_Foldable

class Sym_Foldable term where

Methods

foldMap :: Foldable f => Monoid m => term (a -> m) -> term (f a) -> term m

foldr :: Foldable f => term (a -> b -> b) -> term b -> term (f a) -> term b

foldr' :: Foldable f => term (a -> b -> b) -> term b -> term (f a) -> term b

foldl :: Foldable f => term (b -> a -> b) -> term b -> term (f a) -> term b

foldl' :: Foldable f => term (b -> a -> b) -> term b -> term (f a) -> term b

length :: Foldable f => term (f a) -> term Int

null :: Foldable f => term (f a) -> term Bool

minimum :: Foldable f => Ord a => term (f a) -> term a

maximum :: Foldable f => Ord a => term (f a) -> term a

elem :: Foldable f => Eq a => term a -> term (f a) -> term Bool infix 4

sum :: Foldable f => Num a => term (f a) -> term a

product :: Foldable f => Num a => term (f a) -> term a

toList :: Foldable f => term (f a) -> term [a]

all :: Foldable f => term (a -> Bool) -> term (f a) -> term Bool

and :: Foldable f => term (f Bool) -> term Bool

any :: Foldable f => term (a -> Bool) -> term (f a) -> term Bool

concat :: Foldable f => term (f [a]) -> term [a]

concatMap :: Foldable f => term (a -> [b]) -> term (f a) -> term [b]

find :: Foldable f => term (a -> Bool) -> term (f a) -> term (Maybe a)

foldlM :: Foldable f => Monad m => term (b -> a -> m b) -> term b -> term (f a) -> term (m b)

foldrM :: Foldable f => Monad m => term (a -> b -> m b) -> term b -> term (f a) -> term (m b)

forM_ :: Foldable f => Monad m => term (f a) -> term (a -> m b) -> term (m ())

for_ :: Foldable f => Applicative p => term (f a) -> term (a -> p b) -> term (p ())

mapM_ :: Foldable f => Monad m => term (a -> m b) -> term (f a) -> term (m ())

maximumBy :: Foldable f => term (a -> a -> Ordering) -> term (f a) -> term a

minimumBy :: Foldable f => term (a -> a -> Ordering) -> term (f a) -> term a

notElem :: Foldable f => Eq a => term a -> term (f a) -> term Bool

or :: Foldable f => term (f Bool) -> term Bool

sequenceA_ :: Foldable f => Applicative p => term (f (p a)) -> term (p ())

sequence_ :: Foldable f => Monad m => term (f (m a)) -> term (m ())

traverse_ :: Foldable f => Applicative p => term (a -> p b) -> term (f a) -> term (p ())

asum :: Foldable f => Alternative p => term (f (p a)) -> term (p a)

msum :: Foldable f => MonadPlus p => term (f (p a)) -> term (p a)

foldMap :: Sym_Foldable (UnT term) => Trans term => Foldable f => Monoid m => term (a -> m) -> term (f a) -> term m

foldr :: Sym_Foldable (UnT term) => Trans term => Foldable f => term (a -> b -> b) -> term b -> term (f a) -> term b

foldr' :: Sym_Foldable (UnT term) => Trans term => Foldable f => term (a -> b -> b) -> term b -> term (f a) -> term b

foldl :: Sym_Foldable (UnT term) => Trans term => Foldable f => term (b -> a -> b) -> term b -> term (f a) -> term b

foldl' :: Sym_Foldable (UnT term) => Trans term => Foldable f => term (b -> a -> b) -> term b -> term (f a) -> term b

length :: Sym_Foldable (UnT term) => Trans term => Foldable f => term (f a) -> term Int

null :: Sym_Foldable (UnT term) => Trans term => Foldable f => term (f a) -> term Bool

minimum :: Sym_Foldable (UnT term) => Trans term => Foldable f => Ord a => term (f a) -> term a

maximum :: Sym_Foldable (UnT term) => Trans term => Foldable f => Ord a => term (f a) -> term a

elem :: Sym_Foldable (UnT term) => Trans term => Foldable f => Eq a => term a -> term (f a) -> term Bool infix 4

sum :: Sym_Foldable (UnT term) => Trans term => Foldable f => Num a => term (f a) -> term a

product :: Sym_Foldable (UnT term) => Trans term => Foldable f => Num a => term (f a) -> term a

toList :: Sym_Foldable (UnT term) => Trans term => Foldable f => term (f a) -> term [a]

all :: Sym_Foldable (UnT term) => Trans term => Foldable f => term (a -> Bool) -> term (f a) -> term Bool

and :: Sym_Foldable (UnT term) => Trans term => Foldable f => term (f Bool) -> term Bool

any :: Sym_Foldable (UnT term) => Trans term => Foldable f => term (a -> Bool) -> term (f a) -> term Bool

concat :: Sym_Foldable (UnT term) => Trans term => Foldable f => term (f [a]) -> term [a]

concatMap :: Sym_Foldable (UnT term) => Trans term => Foldable f => term (a -> [b]) -> term (f a) -> term [b]

find :: Sym_Foldable (UnT term) => Trans term => Foldable f => term (a -> Bool) -> term (f a) -> term (Maybe a)

foldlM :: Sym_Foldable (UnT term) => Trans term => Foldable f => Monad m => term (b -> a -> m b) -> term b -> term (f a) -> term (m b)

foldrM :: Sym_Foldable (UnT term) => Trans term => Foldable f => Monad m => term (a -> b -> m b) -> term b -> term (f a) -> term (m b)

forM_ :: Sym_Foldable (UnT term) => Trans term => Foldable f => Monad m => term (f a) -> term (a -> m b) -> term (m ())

for_ :: Sym_Foldable (UnT term) => Trans term => Foldable f => Applicative p => term (f a) -> term (a -> p b) -> term (p ())

mapM_ :: Sym_Foldable (UnT term) => Trans term => Foldable f => Monad m => term (a -> m b) -> term (f a) -> term (m ())

maximumBy :: Sym_Foldable (UnT term) => Trans term => Foldable f => term (a -> a -> Ordering) -> term (f a) -> term a

minimumBy :: Sym_Foldable (UnT term) => Trans term => Foldable f => term (a -> a -> Ordering) -> term (f a) -> term a

notElem :: Sym_Foldable (UnT term) => Trans term => Foldable f => Eq a => term a -> term (f a) -> term Bool

or :: Sym_Foldable (UnT term) => Trans term => Foldable f => term (f Bool) -> term Bool

sequenceA_ :: Sym_Foldable (UnT term) => Trans term => Foldable f => Applicative p => term (f (p a)) -> term (p ())

sequence_ :: Sym_Foldable (UnT term) => Trans term => Foldable f => Monad m => term (f (m a)) -> term (m ())

traverse_ :: Sym_Foldable (UnT term) => Trans term => Foldable f => Applicative p => term (a -> p b) -> term (f a) -> term (p ())

asum :: Sym_Foldable (UnT term) => Trans term => Foldable f => Alternative m => term (f (m a)) -> term (m a)

msum :: Sym_Foldable (UnT term) => Trans term => Foldable f => MonadPlus m => term (f (m a)) -> term (m a)

Instances

Sym_Foldable View

Defined in Language.Symantic.Lib.Foldable

Methods

foldMap :: (Foldable f, Monoid m) => View (a -> m) -> View (f a) -> View m

foldr :: Foldable f => View (a -> b -> b) -> View b -> View (f a) -> View b

foldr' :: Foldable f => View (a -> b -> b) -> View b -> View (f a) -> View b

foldl :: Foldable f => View (b -> a -> b) -> View b -> View (f a) -> View b

foldl' :: Foldable f => View (b -> a -> b) -> View b -> View (f a) -> View b

length :: Foldable f => View (f a) -> View Int

null :: Foldable f => View (f a) -> View Bool

minimum :: (Foldable f, Ord a) => View (f a) -> View a

maximum :: (Foldable f, Ord a) => View (f a) -> View a

elem :: (Foldable f, Eq a) => View a -> View (f a) -> View Bool

sum :: (Foldable f, Num a) => View (f a) -> View a

product :: (Foldable f, Num a) => View (f a) -> View a

toList :: Foldable f => View (f a) -> View [a]

all :: Foldable f => View (a -> Bool) -> View (f a) -> View Bool

and :: Foldable f => View (f Bool) -> View Bool

any :: Foldable f => View (a -> Bool) -> View (f a) -> View Bool

concat :: Foldable f => View (f [a]) -> View [a]

concatMap :: Foldable f => View (a -> [b]) -> View (f a) -> View [b]

find :: Foldable f => View (a -> Bool) -> View (f a) -> View (Maybe a)

foldlM :: (Foldable f, Monad m) => View (b -> a -> m b) -> View b -> View (f a) -> View (m b)

foldrM :: (Foldable f, Monad m) => View (a -> b -> m b) -> View b -> View (f a) -> View (m b)

forM_ :: (Foldable f, Monad m) => View (f a) -> View (a -> m b) -> View (m ())

for_ :: (Foldable f, Applicative p) => View (f a) -> View (a -> p b) -> View (p ())

mapM_ :: (Foldable f, Monad m) => View (a -> m b) -> View (f a) -> View (m ())

maximumBy :: Foldable f => View (a -> a -> Ordering) -> View (f a) -> View a

minimumBy :: Foldable f => View (a -> a -> Ordering) -> View (f a) -> View a

notElem :: (Foldable f, Eq a) => View a -> View (f a) -> View Bool

or :: Foldable f => View (f Bool) -> View Bool

sequenceA_ :: (Foldable f, Applicative p) => View (f (p a)) -> View (p ())

sequence_ :: (Foldable f, Monad m) => View (f (m a)) -> View (m ())

traverse_ :: (Foldable f, Applicative p) => View (a -> p b) -> View (f a) -> View (p ())

asum :: (Foldable f, Alternative p) => View (f (p a)) -> View (p a)

msum :: (Foldable f, MonadPlus p) => View (f (p a)) -> View (p a)

Sym_Foldable Eval

Defined in Language.Symantic.Lib.Foldable

Methods

foldMap :: (Foldable f, Monoid m) => Eval (a -> m) -> Eval (f a) -> Eval m

foldr :: Foldable f => Eval (a -> b -> b) -> Eval b -> Eval (f a) -> Eval b

foldr' :: Foldable f => Eval (a -> b -> b) -> Eval b -> Eval (f a) -> Eval b

foldl :: Foldable f => Eval (b -> a -> b) -> Eval b -> Eval (f a) -> Eval b

foldl' :: Foldable f => Eval (b -> a -> b) -> Eval b -> Eval (f a) -> Eval b

length :: Foldable f => Eval (f a) -> Eval Int

null :: Foldable f => Eval (f a) -> Eval Bool

minimum :: (Foldable f, Ord a) => Eval (f a) -> Eval a

maximum :: (Foldable f, Ord a) => Eval (f a) -> Eval a

elem :: (Foldable f, Eq a) => Eval a -> Eval (f a) -> Eval Bool

sum :: (Foldable f, Num a) => Eval (f a) -> Eval a

product :: (Foldable f, Num a) => Eval (f a) -> Eval a

toList :: Foldable f => Eval (f a) -> Eval [a]

all :: Foldable f => Eval (a -> Bool) -> Eval (f a) -> Eval Bool

and :: Foldable f => Eval (f Bool) -> Eval Bool

any :: Foldable f => Eval (a -> Bool) -> Eval (f a) -> Eval Bool

concat :: Foldable f => Eval (f [a]) -> Eval [a]

concatMap :: Foldable f => Eval (a -> [b]) -> Eval (f a) -> Eval [b]

find :: Foldable f => Eval (a -> Bool) -> Eval (f a) -> Eval (Maybe a)

foldlM :: (Foldable f, Monad m) => Eval (b -> a -> m b) -> Eval b -> Eval (f a) -> Eval (m b)

foldrM :: (Foldable f, Monad m) => Eval (a -> b -> m b) -> Eval b -> Eval (f a) -> Eval (m b)

forM_ :: (Foldable f, Monad m) => Eval (f a) -> Eval (a -> m b) -> Eval (m ())

for_ :: (Foldable f, Applicative p) => Eval (f a) -> Eval (a -> p b) -> Eval (p ())

mapM_ :: (Foldable f, Monad m) => Eval (a -> m b) -> Eval (f a) -> Eval (m ())

maximumBy :: Foldable f => Eval (a -> a -> Ordering) -> Eval (f a) -> Eval a

minimumBy :: Foldable f => Eval (a -> a -> Ordering) -> Eval (f a) -> Eval a

notElem :: (Foldable f, Eq a) => Eval a -> Eval (f a) -> Eval Bool

or :: Foldable f => Eval (f Bool) -> Eval Bool

sequenceA_ :: (Foldable f, Applicative p) => Eval (f (p a)) -> Eval (p ())

sequence_ :: (Foldable f, Monad m) => Eval (f (m a)) -> Eval (m ())

traverse_ :: (Foldable f, Applicative p) => Eval (a -> p b) -> Eval (f a) -> Eval (p ())

asum :: (Foldable f, Alternative p) => Eval (f (p a)) -> Eval (p a)

msum :: (Foldable f, MonadPlus p) => Eval (f (p a)) -> Eval (p a)

(Sym_Foldable term, Sym_Lambda term) => Sym_Foldable (BetaT term)

Defined in Language.Symantic.Lib.Foldable

Methods

foldMap :: (Foldable f, Monoid m) => BetaT term (a -> m) -> BetaT term (f a) -> BetaT term m

foldr :: Foldable f => BetaT term (a -> b -> b) -> BetaT term b -> BetaT term (f a) -> BetaT term b

foldr' :: Foldable f => BetaT term (a -> b -> b) -> BetaT term b -> BetaT term (f a) -> BetaT term b

foldl :: Foldable f => BetaT term (b -> a -> b) -> BetaT term b -> BetaT term (f a) -> BetaT term b

foldl' :: Foldable f => BetaT term (b -> a -> b) -> BetaT term b -> BetaT term (f a) -> BetaT term b

length :: Foldable f => BetaT term (f a) -> BetaT term Int

null :: Foldable f => BetaT term (f a) -> BetaT term Bool

minimum :: (Foldable f, Ord a) => BetaT term (f a) -> BetaT term a

maximum :: (Foldable f, Ord a) => BetaT term (f a) -> BetaT term a

elem :: (Foldable f, Eq a) => BetaT term a -> BetaT term (f a) -> BetaT term Bool

sum :: (Foldable f, Num a) => BetaT term (f a) -> BetaT term a

product :: (Foldable f, Num a) => BetaT term (f a) -> BetaT term a

toList :: Foldable f => BetaT term (f a) -> BetaT term [a]

all :: Foldable f => BetaT term (a -> Bool) -> BetaT term (f a) -> BetaT term Bool

and :: Foldable f => BetaT term (f Bool) -> BetaT term Bool

any :: Foldable f => BetaT term (a -> Bool) -> BetaT term (f a) -> BetaT term Bool

concat :: Foldable f => BetaT term (f [a]) -> BetaT term [a]

concatMap :: Foldable f => BetaT term (a -> [b]) -> BetaT term (f a) -> BetaT term [b]

find :: Foldable f => BetaT term (a -> Bool) -> BetaT term (f a) -> BetaT term (Maybe a)

foldlM :: (Foldable f, Monad m) => BetaT term (b -> a -> m b) -> BetaT term b -> BetaT term (f a) -> BetaT term (m b)

foldrM :: (Foldable f, Monad m) => BetaT term (a -> b -> m b) -> BetaT term b -> BetaT term (f a) -> BetaT term (m b)

forM_ :: (Foldable f, Monad m) => BetaT term (f a) -> BetaT term (a -> m b) -> BetaT term (m ())

for_ :: (Foldable f, Applicative p) => BetaT term (f a) -> BetaT term (a -> p b) -> BetaT term (p ())

mapM_ :: (Foldable f, Monad m) => BetaT term (a -> m b) -> BetaT term (f a) -> BetaT term (m ())

maximumBy :: Foldable f => BetaT term (a -> a -> Ordering) -> BetaT term (f a) -> BetaT term a

minimumBy :: Foldable f => BetaT term (a -> a -> Ordering) -> BetaT term (f a) -> BetaT term a

notElem :: (Foldable f, Eq a) => BetaT term a -> BetaT term (f a) -> BetaT term Bool

or :: Foldable f => BetaT term (f Bool) -> BetaT term Bool

sequenceA_ :: (Foldable f, Applicative p) => BetaT term (f (p a)) -> BetaT term (p ())

sequence_ :: (Foldable f, Monad m) => BetaT term (f (m a)) -> BetaT term (m ())

traverse_ :: (Foldable f, Applicative p) => BetaT term (a -> p b) -> BetaT term (f a) -> BetaT term (p ())

asum :: (Foldable f, Alternative p) => BetaT term (f (p a)) -> BetaT term (p a)

msum :: (Foldable f, MonadPlus p) => BetaT term (f (p a)) -> BetaT term (p a)

(Sym_Foldable r1, Sym_Foldable r2) => Sym_Foldable (Dup r1 r2)

Defined in Language.Symantic.Lib.Foldable

Methods

foldMap :: (Foldable f, Monoid m) => Dup r1 r2 (a -> m) -> Dup r1 r2 (f a) -> Dup r1 r2 m

foldr :: Foldable f => Dup r1 r2 (a -> b -> b) -> Dup r1 r2 b -> Dup r1 r2 (f a) -> Dup r1 r2 b

foldr' :: Foldable f => Dup r1 r2 (a -> b -> b) -> Dup r1 r2 b -> Dup r1 r2 (f a) -> Dup r1 r2 b

foldl :: Foldable f => Dup r1 r2 (b -> a -> b) -> Dup r1 r2 b -> Dup r1 r2 (f a) -> Dup r1 r2 b

foldl' :: Foldable f => Dup r1 r2 (b -> a -> b) -> Dup r1 r2 b -> Dup r1 r2 (f a) -> Dup r1 r2 b

length :: Foldable f => Dup r1 r2 (f a) -> Dup r1 r2 Int

null :: Foldable f => Dup r1 r2 (f a) -> Dup r1 r2 Bool

minimum :: (Foldable f, Ord a) => Dup r1 r2 (f a) -> Dup r1 r2 a

maximum :: (Foldable f, Ord a) => Dup r1 r2 (f a) -> Dup r1 r2 a

elem :: (Foldable f, Eq a) => Dup r1 r2 a -> Dup r1 r2 (f a) -> Dup r1 r2 Bool

sum :: (Foldable f, Num a) => Dup r1 r2 (f a) -> Dup r1 r2 a

product :: (Foldable f, Num a) => Dup r1 r2 (f a) -> Dup r1 r2 a

toList :: Foldable f => Dup r1 r2 (f a) -> Dup r1 r2 [a]

all :: Foldable f => Dup r1 r2 (a -> Bool) -> Dup r1 r2 (f a) -> Dup r1 r2 Bool

and :: Foldable f => Dup r1 r2 (f Bool) -> Dup r1 r2 Bool

any :: Foldable f => Dup r1 r2 (a -> Bool) -> Dup r1 r2 (f a) -> Dup r1 r2 Bool

concat :: Foldable f => Dup r1 r2 (f [a]) -> Dup r1 r2 [a]

concatMap :: Foldable f => Dup r1 r2 (a -> [b]) -> Dup r1 r2 (f a) -> Dup r1 r2 [b]

find :: Foldable f => Dup r1 r2 (a -> Bool) -> Dup r1 r2 (f a) -> Dup r1 r2 (Maybe a)

foldlM :: (Foldable f, Monad m) => Dup r1 r2 (b -> a -> m b) -> Dup r1 r2 b -> Dup r1 r2 (f a) -> Dup r1 r2 (m b)

foldrM :: (Foldable f, Monad m) => Dup r1 r2 (a -> b -> m b) -> Dup r1 r2 b -> Dup r1 r2 (f a) -> Dup r1 r2 (m b)

forM_ :: (Foldable f, Monad m) => Dup r1 r2 (f a) -> Dup r1 r2 (a -> m b) -> Dup r1 r2 (m ())

for_ :: (Foldable f, Applicative p) => Dup r1 r2 (f a) -> Dup r1 r2 (a -> p b) -> Dup r1 r2 (p ())

mapM_ :: (Foldable f, Monad m) => Dup r1 r2 (a -> m b) -> Dup r1 r2 (f a) -> Dup r1 r2 (m ())

maximumBy :: Foldable f => Dup r1 r2 (a -> a -> Ordering) -> Dup r1 r2 (f a) -> Dup r1 r2 a

minimumBy :: Foldable f => Dup r1 r2 (a -> a -> Ordering) -> Dup r1 r2 (f a) -> Dup r1 r2 a

notElem :: (Foldable f, Eq a) => Dup r1 r2 a -> Dup r1 r2 (f a) -> Dup r1 r2 Bool

or :: Foldable f => Dup r1 r2 (f Bool) -> Dup r1 r2 Bool

sequenceA_ :: (Foldable f, Applicative p) => Dup r1 r2 (f (p a)) -> Dup r1 r2 (p ())

sequence_ :: (Foldable f, Monad m) => Dup r1 r2 (f (m a)) -> Dup r1 r2 (m ())

traverse_ :: (Foldable f, Applicative p) => Dup r1 r2 (a -> p b) -> Dup r1 r2 (f a) -> Dup r1 r2 (p ())

asum :: (Foldable f, Alternative p) => Dup r1 r2 (f (p a)) -> Dup r1 r2 (p a)

msum :: (Foldable f, MonadPlus p) => Dup r1 r2 (f (p a)) -> Dup r1 r2 (p a)

Types

tyFoldable :: Source src => Type src vs a -> Type src vs (Foldable a)

t0 :: Source src => LenInj vs => KindInj (K t) => Type src (Proxy t ': vs) t

t1 :: Source src => LenInj vs => KindInj (K t) => Type src (a ': (Proxy t ': vs)) t

t2 :: Source src => LenInj vs => KindInj (K t) => Type src (a ': (b ': (Proxy t ': vs))) t

Terms

teFoldable_foldMap :: TermDef Foldable '[Proxy a, Proxy t, Proxy m] ((Foldable t # Monoid m) #> ((a -> m) -> t a -> m))

teFoldable_elem :: TermDef Foldable '[Proxy a, Proxy t] ((Foldable t # Eq a) #> (a -> t a -> Bool))

teFoldable_toList :: TermDef Foldable '[Proxy a, Proxy t] (Foldable t #> (t a -> [a]))

teFoldable_concat :: TermDef Foldable '[Proxy a, Proxy t] (Foldable t #> (t [a] -> [a]))

teFoldable_foldr :: TermDef Foldable '[Proxy a, Proxy b, Proxy t] (Foldable t #> ((a -> b -> b) -> b -> t a -> b))

teFoldable_foldr' :: TermDef Foldable '[Proxy a, Proxy b, Proxy t] (Foldable t #> ((a -> b -> b) -> b -> t a -> b))

teFoldable_foldl :: TermDef Foldable '[Proxy a, Proxy b, Proxy t] (Foldable t #> ((b -> a -> b) -> b -> t a -> b))

teFoldable_length :: TermDef Foldable '[Proxy a, Proxy t] (Foldable t #> (t a -> Int))

teFoldable_null :: TermDef Foldable '[Proxy a, Proxy t] (Foldable t #> (t a -> Bool))

teFoldable_minimum :: TermDef Foldable '[Proxy a, Proxy t] ((Foldable t # Ord a) #> (t a -> a))

teFoldable_maximum :: TermDef Foldable '[Proxy a, Proxy t] ((Foldable t # Ord a) #> (t a -> a))

teFoldable_sum :: TermDef Foldable '[Proxy a, Proxy t] ((Foldable t # Num a) #> (t a -> a))

teFoldable_product :: TermDef Foldable '[Proxy a, Proxy t] ((Foldable t # Num a) #> (t a -> a))

teFoldable_all :: TermDef Foldable '[Proxy a, Proxy t] (Foldable t #> ((a -> Bool) -> t a -> Bool))

teFoldable_any :: TermDef Foldable '[Proxy a, Proxy t] (Foldable t #> ((a -> Bool) -> t a -> Bool))

teFoldable_and :: TermDef Foldable '[Proxy t] (Foldable t #> (t Bool -> Bool))

teFoldable_or :: TermDef Foldable '[Proxy t] (Foldable t #> (t Bool -> Bool))

teFoldable_asum :: TermDef Foldable '[Proxy a, Proxy t, Proxy f] ((Foldable t # Alternative f) #> (t (f a) -> f a))

Orphan instances

ClassInstancesFor Foldable

Methods

proveConstraintFor :: Source src => proxy Foldable -> Type src vs q -> Maybe (Qual q)

TypeInstancesFor Foldable

Methods

expandFamFor :: Source src => proxy Foldable -> Len vs -> Const src fam -> Types src vs ts -> Maybe (Type src vs (Fam fam ts))

NameTyOf Foldable

Methods

nameTyOf :: proxy Foldable -> Mod NameTy

isNameTyOp :: proxy Foldable -> Bool

FixityOf Foldable

Methods

fixityOf :: proxy Foldable -> Maybe Fixity

(Source src, SymInj ss Foldable) => ModuleFor src ss Foldable

Methods

moduleFor :: (PathMod, Module src ss)

Gram_Term_AtomsFor src ss g Foldable

Methods

g_term_atomsFor :: [CF g (AST_Term src ss)]