Language.Symantic.Lib.NonNull

Symantic for NonNull.

Class Sym_NonNull

class Sym_NonNull term where

Minimal complete definition

Nothing

Methods

fromNullable :: MonoFoldable o => term o -> term (Maybe (NonNull o))

toNullable :: MonoFoldable o => term (NonNull o) -> term o

ncons :: SemiSequence s => term (Element s) -> term s -> term (NonNull s)

nuncons :: IsSequence s => term (NonNull s) -> term (Element s, Maybe (NonNull s))

head :: MonoFoldable o => term (NonNull o) -> term (Element o)

last :: MonoFoldable o => term (NonNull o) -> term (Element o)

tail :: IsSequence s => term (NonNull s) -> term s

init :: IsSequence s => term (NonNull s) -> term s

nfilter :: IsSequence s => term (Element s -> Bool) -> term (NonNull s) -> term s

fromNullable :: Sym_NonNull (UnT term) => Trans term => MonoFoldable o => term o -> term (Maybe (NonNull o))

toNullable :: Sym_NonNull (UnT term) => Trans term => MonoFoldable o => term (NonNull o) -> term o

ncons :: Sym_NonNull (UnT term) => Trans term => SemiSequence s => term (Element s) -> term s -> term (NonNull s)

nuncons :: Sym_NonNull (UnT term) => Trans term => IsSequence s => term (NonNull s) -> term (Element s, Maybe (NonNull s))

head :: Sym_NonNull (UnT term) => Trans term => MonoFoldable o => term (NonNull o) -> term (Element o)

last :: Sym_NonNull (UnT term) => Trans term => MonoFoldable o => term (NonNull o) -> term (Element o)

tail :: Sym_NonNull (UnT term) => Trans term => IsSequence s => term (NonNull s) -> term s

init :: Sym_NonNull (UnT term) => Trans term => IsSequence s => term (NonNull s) -> term s

nfilter :: Sym_NonNull (UnT term) => Trans term => IsSequence s => term (Element s -> Bool) -> term (NonNull s) -> term s

Instances

Sym_NonNull View

Defined in Language.Symantic.Lib.NonNull

Methods

fromNullable :: MonoFoldable o => View o -> View (Maybe (NonNull o))

toNullable :: MonoFoldable o => View (NonNull o) -> View o

ncons :: SemiSequence s => View (Element s) -> View s -> View (NonNull s)

nuncons :: IsSequence s => View (NonNull s) -> View (Element s, Maybe (NonNull s))

head :: MonoFoldable o => View (NonNull o) -> View (Element o)

last :: MonoFoldable o => View (NonNull o) -> View (Element o)

tail :: IsSequence s => View (NonNull s) -> View s

init :: IsSequence s => View (NonNull s) -> View s

nfilter :: IsSequence s => View (Element s -> Bool) -> View (NonNull s) -> View s

Sym_NonNull Eval

Defined in Language.Symantic.Lib.NonNull

Methods

fromNullable :: MonoFoldable o => Eval o -> Eval (Maybe (NonNull o))

toNullable :: MonoFoldable o => Eval (NonNull o) -> Eval o

ncons :: SemiSequence s => Eval (Element s) -> Eval s -> Eval (NonNull s)

nuncons :: IsSequence s => Eval (NonNull s) -> Eval (Element s, Maybe (NonNull s))

head :: MonoFoldable o => Eval (NonNull o) -> Eval (Element o)

last :: MonoFoldable o => Eval (NonNull o) -> Eval (Element o)

tail :: IsSequence s => Eval (NonNull s) -> Eval s

init :: IsSequence s => Eval (NonNull s) -> Eval s

nfilter :: IsSequence s => Eval (Element s -> Bool) -> Eval (NonNull s) -> Eval s

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

Defined in Language.Symantic.Lib.NonNull

Methods

fromNullable :: MonoFoldable o => BetaT term o -> BetaT term (Maybe (NonNull o))

toNullable :: MonoFoldable o => BetaT term (NonNull o) -> BetaT term o

ncons :: SemiSequence s => BetaT term (Element s) -> BetaT term s -> BetaT term (NonNull s)

nuncons :: IsSequence s => BetaT term (NonNull s) -> BetaT term (Element s, Maybe (NonNull s))

head :: MonoFoldable o => BetaT term (NonNull o) -> BetaT term (Element o)

last :: MonoFoldable o => BetaT term (NonNull o) -> BetaT term (Element o)

tail :: IsSequence s => BetaT term (NonNull s) -> BetaT term s

init :: IsSequence s => BetaT term (NonNull s) -> BetaT term s

nfilter :: IsSequence s => BetaT term (Element s -> Bool) -> BetaT term (NonNull s) -> BetaT term s

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

Defined in Language.Symantic.Lib.NonNull

Methods

fromNullable :: MonoFoldable o => Dup r1 r2 o -> Dup r1 r2 (Maybe (NonNull o))

toNullable :: MonoFoldable o => Dup r1 r2 (NonNull o) -> Dup r1 r2 o

ncons :: SemiSequence s => Dup r1 r2 (Element s) -> Dup r1 r2 s -> Dup r1 r2 (NonNull s)

nuncons :: IsSequence s => Dup r1 r2 (NonNull s) -> Dup r1 r2 (Element s, Maybe (NonNull s))

head :: MonoFoldable o => Dup r1 r2 (NonNull o) -> Dup r1 r2 (Element o)

last :: MonoFoldable o => Dup r1 r2 (NonNull o) -> Dup r1 r2 (Element o)

tail :: IsSequence s => Dup r1 r2 (NonNull s) -> Dup r1 r2 s

init :: IsSequence s => Dup r1 r2 (NonNull s) -> Dup r1 r2 s

nfilter :: IsSequence s => Dup r1 r2 (Element s -> Bool) -> Dup r1 r2 (NonNull s) -> Dup r1 r2 s

Types

tyNonNull :: Source src => Type src vs a -> Type src vs (NonNull a)

Terms

teNonNull_fromNullable :: TermDef NonNull '[Proxy o] (MonoFoldable o #> (o -> Maybe (NonNull o)))

teNonNull_toNullable :: TermDef NonNull '[Proxy o] (MonoFoldable o #> (NonNull o -> o))

teNonNull_ncons :: TermDef NonNull '[Proxy s, Proxy e] ((SemiSequence s # (e #~ Element s)) #> (e -> s -> NonNull s))

teNonNull_nuncons :: TermDef NonNull '[Proxy s, Proxy e] ((IsSequence s # (e #~ Element s)) #> (NonNull s -> (e, Maybe (NonNull s))))

teNonNull_nfilter :: TermDef NonNull '[Proxy s, Proxy e] ((IsSequence s # (e #~ Element s)) #> ((e -> Bool) -> NonNull s -> s))

teNonNull_head :: TermDef NonNull '[Proxy o, Proxy e] ((MonoFoldable o # (e #~ Element o)) #> (NonNull o -> e))

teNonNull_last :: TermDef NonNull '[Proxy o, Proxy e] ((MonoFoldable o # (e #~ Element o)) #> (NonNull o -> e))

teNonNull_tail :: TermDef NonNull '[Proxy s] (IsSequence s #> (NonNull s -> s))

teNonNull_init :: TermDef NonNull '[Proxy s] (IsSequence s #> (NonNull s -> s))

Orphan instances

ClassInstancesFor NonNull

Methods

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

TypeInstancesFor NonNull

Methods

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

NameTyOf NonNull

Methods

nameTyOf :: proxy NonNull -> Mod NameTy

isNameTyOp :: proxy NonNull -> Bool

FixityOf NonNull

Methods

fixityOf :: proxy NonNull -> Maybe Fixity

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

Methods

moduleFor :: (PathMod, Module src ss)

Gram_Term_AtomsFor src ss g NonNull

Methods

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