Just

Just :: a -> Maybe a

base Prelude Data.Maybe GHC.Maybe, hedgehog Hedgehog.Internal.Prelude, ghc GHC.Data.Strict GHC.Prelude.Basic, base-compat Prelude.Compat, strict Data.Strict.Maybe, protolude Protolude, haskell-gi-base Data.GI.Base.ShortPrelude, relude Relude.Monad.Reexport, rio RIO.Prelude.Types, base-prelude BasePrelude BasePrelude.DataTypes, classy-prelude ClassyPrelude, numeric-prelude NumericPrelude NumericPrelude.Base, Cabal-syntax Distribution.Compat.Prelude, basic-prelude CorePrelude, universum Universum.Monad.Reexport, ihaskell IHaskellPrelude, basement Basement.Compat.Base Basement.Imports, numhask NumHask.Prelude, clash-prelude Clash.HaskellPrelude, github GitHub.Internal.Prelude, foundation Foundation, ghc-lib-parser GHC.Data.Strict GHC.Prelude.Basic, prelude-compat Prelude2010, dimensional Numeric.Units.Dimensional.Prelude, ghc-internal GHC.Internal.Data.Maybe GHC.Internal.Maybe, haxl Haxl.Prelude, rebase Rebase.Prelude, quaalude Essentials, hledger Hledger.Cli.Script, mixed-types-num Numeric.MixedTypes.PreludeHiding, xmonad-contrib XMonad.Config.Prime, yaya Yaya.Pattern, constrained-categories Control.Category.Constrained.Prelude Control.Category.Hask, copilot-language Copilot.Language.Prelude, incipit-base Incipit.Base, LambdaHack Game.LambdaHack.Core.Prelude, cabal-install-solver Distribution.Solver.Compat.Prelude, faktory Faktory.Prelude, protobuf-simple Data.ProtoBufInt, strict-base-types Data.Maybe.Strict, vcr Imports, verset Verset, yesod-paginator Yesod.Paginator.Prelude, distribution-opensuse OpenSuse.Prelude, hledger-web Hledger.Web.Import, termonad Termonad.Prelude

just :: (MonadGen m, GenBase m ~ Identity) => m (Maybe a) -> m a

hedgehog Hedgehog.Gen Hedgehog.Internal.Gen, registry-hedgehog Test.Tasty.Hedgehogx

Runs a Maybe generator until it produces a Just. This is implemented using filter and has the same caveats.

just :: (Monad m) => a -> MaybeT m a

errors Control.Error.Util

Analogous to Just and equivalent to return

just :: NullableFieldProjection typ typ' => SqlExpr (Value typ) -> SqlExpr (Value (Maybe typ'))

esqueleto Database.Esqueleto Database.Esqueleto.Experimental Database.Esqueleto.Internal.Internal Database.Esqueleto.Legacy

Analogous to Just, promotes a value of type typ into one of type Maybe typ. It should hold that val . Just === just . val. This function will try not to produce a nested Maybe. This is in accord with how SQL represents NULL. That means that just . just = just. This behavior was changed in v3.6.0.0. If you want to produce nested Maybe, see just'.

just :: Prism (Maybe a) (Maybe b) a b

lens-family Lens.Family2.Stock

A prism on the Just element of a Maybe.

just :: (Applicative f, Traversable g) => AdapterLike f g (Maybe a) (Maybe b) a b

lens-family-core Lens.Family.Stock

just :: Prism (Maybe a) (Maybe b) a b

A prism on the Just element of a Maybe.

just :: ProjectableMaybe p => p a -> p (Maybe a)

relational-query Database.Relational.Arrow Database.Relational.Projectable, relational-schemas Database.Custom.IBMDB2 Database.Custom.MySQL Database.Custom.Oracle Database.Custom.PostgreSQL Database.Custom.SQLServer Database.Custom.SQLite3

Cast record phantom type into Maybe.

just :: Record c r -> Record c (Maybe r)

relational-query Database.Relational.Record

Cast into Maybe on record phantom type.

just :: Maybe a -> Assertion

chell Test.Chell

Assert that some value is Just.

just :: forall (m :: Type -> Type) a . Monad m => Predicate m a -> Predicate m (Maybe a)

skeletest Skeletest.Internal.Predicate Skeletest.Predicate

A predicate checking if the input is Just, wrapping a value matching the given predicate.

>>> Just 1 `shouldSatisfy` P.just (P.gt 0)

just :: Expr -> Expr

express Data.Express.Fixtures, code-conjure Conjure.Engine Conjure.Expr

The Just constructor lifted over the Expr type. This works for the Bool, Int, Char argument types and their lists.

> just zero
Just 0 :: Maybe Int
> just false
Just False :: Maybe Bool

just :: Predicate a -> Predicate (Maybe a)

explainable-predicates Test.Predicates

A Predicate that accepts Maybe values of Just x, where x matches the given child Predicate.

>>> accept (just (eq "value")) Nothing
False

>>> accept (just (eq "value")) (Just "value")
True

>>> accept (just (eq "value")) (Just "wrong value")
False

just :: Iso a (Maybe a)

partial-isomorphisms Control.Isomorphism.Partial.Constructors

just :: Eq a => a -> Event a

probability Numeric.Probability.Distribution

just :: MaybeLike a v => v -> a

monad-memo Data.MaybeLike

just :: ProjectableMaybe p => forall a . () => p a -> p Maybe a

relational-record Database.Relational.Documentation

Cast record phantom type into Maybe.

just :: a -> TMap c a

trie-simple Data.Trie.Map

TMap which contains only one entry from the empty string to a.