| Safe Haskell | Safe-Inferred |
|---|---|
| Language | Haskell2010 |
PlutusPrelude
Synopsis
- (&) :: a -> (a -> b) -> b
- (&&&) :: Arrow a => a b c -> a b c' -> a b (c, c')
- (>>>) :: forall {k} cat (a :: k) (b :: k) (c :: k). Category cat => cat a b -> cat b c -> cat a c
- (<&>) :: Functor f => f a -> (a -> b) -> f b
- toList :: Foldable t => t a -> [a]
- first :: Bifunctor p => (a -> b) -> p a c -> p b c
- second :: Bifunctor p => (b -> c) -> p a b -> p a c
- on :: (b -> b -> c) -> (a -> b) -> a -> a -> c
- isNothing :: Maybe a -> Bool
- isJust :: Maybe a -> Bool
- fromMaybe :: a -> Maybe a -> a
- guard :: Alternative f => Bool -> f ()
- foldl' :: Foldable t => (b -> a -> b) -> b -> t a -> b
- for_ :: (Foldable t, Applicative f) => t a -> (a -> f b) -> f ()
- traverse_ :: (Foldable t, Applicative f) => (a -> f b) -> t a -> f ()
- fold :: (Foldable t, Monoid m) => t m -> m
- for :: (Traversable t, Applicative f) => t a -> (a -> f b) -> f (t b)
- throw :: forall (r :: RuntimeRep) (a :: TYPE r) e. Exception e => e -> a
- join :: Monad m => m (m a) -> m a
- (<=<) :: Monad m => (b -> m c) -> (a -> m b) -> a -> m c
- (>=>) :: Monad m => (a -> m b) -> (b -> m c) -> a -> m c
- ($>) :: Functor f => f a -> b -> f b
- fromRight :: b -> Either a b -> b
- isRight :: Either a b -> Bool
- isLeft :: Either a b -> Bool
- void :: Functor f => f a -> f ()
- through :: Functor f => (a -> f b) -> a -> f a
- coerce :: forall {k :: RuntimeRep} (a :: TYPE k) (b :: TYPE k). Coercible a b => a -> b
- coerceVia :: Coercible a b => (a -> b) -> a -> b
- coerceArg :: Coercible a b => (a -> s) -> b -> s
- coerceRes :: Coercible s t => (a -> s) -> a -> t
- class Generic a
- class NFData a
- data Natural
- data NonEmpty a = a :| [a]
- data Word8
- class Applicative f => Alternative (f :: Type -> Type) where
- class (Typeable e, Show e) => Exception e
- newtype PairT b f a = PairT {
- unPairT :: f (b, a)
- class a ~R# b => Coercible (a :: k) (b :: k)
- class Typeable (a :: k)
- type Lens' s a = Lens s s a a
- lens :: (s -> a) -> (s -> b -> t) -> Lens s t a b
- (^.) :: s -> Getting a s a -> a
- view :: MonadReader s m => Getting a s a -> m a
- (.~) :: ASetter s t a b -> b -> s -> t
- set :: ASetter s t a b -> b -> s -> t
- (%~) :: ASetter s t a b -> (a -> b) -> s -> t
- over :: ASetter s t a b -> (a -> b) -> s -> t
- (<^>) :: Fold s a -> Fold s a -> Fold s a
- traceShowId :: Show a => a -> a
- trace :: String -> a -> a
- (.*) :: (c -> d) -> (a -> b -> c) -> a -> b -> d
- (<<$>>) :: (Functor f1, Functor f2) => (a -> b) -> f1 (f2 a) -> f1 (f2 b)
- (<<*>>) :: (Applicative f1, Applicative f2) => f1 (f2 (a -> b)) -> f1 (f2 a) -> f1 (f2 b)
- mtraverse :: (Monad m, Traversable m, Applicative f) => (a -> f (m b)) -> m a -> f (m b)
- foldMapM :: (Foldable f, Monad m, Monoid b) => (a -> m b) -> f a -> m b
- reoption :: (Foldable f, Alternative g) => f a -> g a
- enumerate :: (Enum a, Bounded a) => [a]
- tabulateArray :: (Bounded i, Enum i, Ix i) => (i -> a) -> Array i a
- (?) :: Alternative f => Bool -> a -> f a
- ensure :: Alternative f => (a -> Bool) -> a -> f a
- asksM :: MonadReader r m => (r -> m a) -> m a
- timesA :: Natural -> (a -> a) -> a -> a
- data Doc ann
- newtype ShowPretty a = ShowPretty {
- unShowPretty :: a
- class Pretty a where
- pretty :: a -> Doc ann
- prettyList :: [a] -> Doc ann
- class PrettyBy config a where
- prettyBy :: config -> a -> Doc ann
- prettyListBy :: config -> [a] -> Doc ann
- type family HasPrettyDefaults config :: Bool
- type PrettyDefaultBy config = DispatchPrettyDefaultBy (NonStuckHasPrettyDefaults config) config
- newtype PrettyAny a = PrettyAny {
- unPrettyAny :: a
- class Render str where
- display :: forall str a. (Pretty a, Render str) => a -> str
- printPretty :: Pretty a => a -> IO ()
- showText :: Show a => a -> Text
- class Default a where
- def :: a
- zipExact :: [a] -> [b] -> Maybe [(a, b)]
- allSame :: Eq a => [a] -> Bool
- distinct :: Eq a => [a] -> Bool
- unsafeFromRight :: Show e => Either e a -> a
- tryError :: MonadError e m => m a -> m (Either e a)
- modifyError :: MonadError e' m => (e -> e') -> ExceptT e m a -> m a
- lowerInitialChar :: String -> String
Reexports from base
(&&&) :: Arrow a => a b c -> a b c' -> a b (c, c') infixr 3 Source #
Fanout: send the input to both argument arrows and combine their output.
The default definition may be overridden with a more efficient version if desired.
(>>>) :: forall {k} cat (a :: k) (b :: k) (c :: k). Category cat => cat a b -> cat b c -> cat a c infixr 1 Source #
Left-to-right composition
toList :: Foldable t => t a -> [a] Source #
List of elements of a structure, from left to right. If the entire list is intended to be reduced via a fold, just fold the structure directly bypassing the list.
Examples
Basic usage:
>>>toList Nothing[]
>>>toList (Just 42)[42]
>>>toList (Left "foo")[]
>>>toList (Node (Leaf 5) 17 (Node Empty 12 (Leaf 8)))[5,17,12,8]
For lists, toList is the identity:
>>>toList [1, 2, 3][1,2,3]
Since: base-4.8.0.0
on :: (b -> b -> c) -> (a -> b) -> a -> a -> c infixl 0 Source #
fromMaybe :: a -> Maybe a -> a Source #
The fromMaybe function takes a default value and a Maybe
value. If the Maybe is Nothing, it returns the default value;
otherwise, it returns the value contained in the Maybe.
Examples
Basic usage:
>>>fromMaybe "" (Just "Hello, World!")"Hello, World!"
>>>fromMaybe "" Nothing""
Read an integer from a string using readMaybe. If we fail to
parse an integer, we want to return 0 by default:
>>>import Text.Read ( readMaybe )>>>fromMaybe 0 (readMaybe "5")5>>>fromMaybe 0 (readMaybe "")0
guard :: Alternative f => Bool -> f () Source #
Conditional failure of Alternative computations. Defined by
guard True =pure() guard False =empty
Examples
Common uses of guard include conditionally signaling an error in
an error monad and conditionally rejecting the current choice in an
Alternative-based parser.
As an example of signaling an error in the error monad Maybe,
consider a safe division function safeDiv x y that returns
Nothing when the denominator y is zero and Just (x `div`
y)
>>>safeDiv 4 0Nothing
>>>safeDiv 4 2Just 2
A definition of safeDiv using guards, but not guard:
safeDiv :: Int -> Int -> Maybe Int
safeDiv x y | y /= 0 = Just (x `div` y)
| otherwise = Nothing
A definition of safeDiv using guard and Monad do-notation:
safeDiv :: Int -> Int -> Maybe Int safeDiv x y = do guard (y /= 0) return (x `div` y)
foldl' :: Foldable t => (b -> a -> b) -> b -> t a -> b Source #
Left-associative fold of a structure but with strict application of the operator.
This ensures that each step of the fold is forced to Weak Head Normal
Form before being applied, avoiding the collection of thunks that would
otherwise occur. This is often what you want to strictly reduce a
finite structure to a single strict result (e.g. sum).
For a general Foldable structure this should be semantically identical
to,
foldl' f z =foldl'f z .toList
Since: base-4.6.0.0
for_ :: (Foldable t, Applicative f) => t a -> (a -> f b) -> f () Source #
for_ is traverse_ with its arguments flipped. For a version
that doesn't ignore the results see for. This
is forM_ generalised to Applicative actions.
for_ is just like forM_, but generalised to Applicative actions.
Examples
Basic usage:
>>>for_ [1..4] print1 2 3 4
traverse_ :: (Foldable t, Applicative f) => (a -> f b) -> t a -> f () Source #
Map each element of a structure to an Applicative action, evaluate these
actions from left to right, and ignore the results. For a version that
doesn't ignore the results see traverse.
traverse_ is just like mapM_, but generalised to Applicative actions.
Examples
Basic usage:
>>>traverse_ print ["Hello", "world", "!"]"Hello" "world" "!"
fold :: (Foldable t, Monoid m) => t m -> m Source #
Given a structure with elements whose type is a Monoid, combine them
via the monoid's ( operator. This fold is right-associative and
lazy in the accumulator. When you need a strict left-associative fold,
use <>)foldMap' instead, with id as the map.
Examples
Basic usage:
>>>fold [[1, 2, 3], [4, 5], [6], []][1,2,3,4,5,6]
>>>fold $ Node (Leaf (Sum 1)) (Sum 3) (Leaf (Sum 5))Sum {getSum = 9}
Folds of unbounded structures do not terminate when the monoid's
( operator is strict:<>)
>>>fold (repeat Nothing)* Hangs forever *
Lazy corecursive folds of unbounded structures are fine:
>>>take 12 $ fold $ map (\i -> [i..i+2]) [0..][0,1,2,1,2,3,2,3,4,3,4,5]>>>sum $ take 4000000 $ fold $ map (\i -> [i..i+2]) [0..]2666668666666
for :: (Traversable t, Applicative f) => t a -> (a -> f b) -> f (t b) Source #
throw :: forall (r :: RuntimeRep) (a :: TYPE r) e. Exception e => e -> a Source #
Throw an exception. Exceptions may be thrown from purely
functional code, but may only be caught within the IO monad.
WARNING: You may want to use throwIO instead so that your pure code
stays exception-free.
join :: Monad m => m (m a) -> m a Source #
The join function is the conventional monad join operator. It
is used to remove one level of monadic structure, projecting its
bound argument into the outer level.
'join bssdo expression
do bs <- bss bs
Examples
A common use of join is to run an IO computation returned from
an STM transaction, since STM transactions
can't perform IO directly. Recall that
atomically :: STM a -> IO a
is used to run STM transactions atomically. So, by
specializing the types of atomically and join to
atomically:: STM (IO b) -> IO (IO b)join:: IO (IO b) -> IO b
we can compose them as
join.atomically:: STM (IO b) -> IO b
(>=>) :: Monad m => (a -> m b) -> (b -> m c) -> a -> m c infixr 1 Source #
Left-to-right composition of Kleisli arrows.
'(bs ' can be understood as the >=> cs) ado expression
do b <- bs a cs b
($>) :: Functor f => f a -> b -> f b infixl 4 Source #
Flipped version of <$.
Examples
Replace the contents of a Maybe IntString:
>>>Nothing $> "foo"Nothing>>>Just 90210 $> "foo"Just "foo"
Replace the contents of an Either Int IntString, resulting in an Either
Int String
>>>Left 8675309 $> "foo"Left 8675309>>>Right 8675309 $> "foo"Right "foo"
Replace each element of a list with a constant String:
>>>[1,2,3] $> "foo"["foo","foo","foo"]
Replace the second element of a pair with a constant String:
>>>(1,2) $> "foo"(1,"foo")
Since: base-4.7.0.0
fromRight :: b -> Either a b -> b Source #
Return the contents of a Right-value or a default value otherwise.
Examples
Basic usage:
>>>fromRight 1 (Right 3)3>>>fromRight 1 (Left "foo")1
Since: base-4.10.0.0
isRight :: Either a b -> Bool Source #
Return True if the given value is a Right-value, False otherwise.
Examples
Basic usage:
>>>isRight (Left "foo")False>>>isRight (Right 3)True
Assuming a Left value signifies some sort of error, we can use
isRight to write a very simple reporting function that only
outputs "SUCCESS" when a computation has succeeded.
This example shows how isRight might be used to avoid pattern
matching when one does not care about the value contained in the
constructor:
>>>import Control.Monad ( when )>>>let report e = when (isRight e) $ putStrLn "SUCCESS">>>report (Left "parse error")>>>report (Right 1)SUCCESS
Since: base-4.7.0.0
isLeft :: Either a b -> Bool Source #
Return True if the given value is a Left-value, False otherwise.
Examples
Basic usage:
>>>isLeft (Left "foo")True>>>isLeft (Right 3)False
Assuming a Left value signifies some sort of error, we can use
isLeft to write a very simple error-reporting function that does
absolutely nothing in the case of success, and outputs "ERROR" if
any error occurred.
This example shows how isLeft might be used to avoid pattern
matching when one does not care about the value contained in the
constructor:
>>>import Control.Monad ( when )>>>let report e = when (isLeft e) $ putStrLn "ERROR">>>report (Right 1)>>>report (Left "parse error")ERROR
Since: base-4.7.0.0
void :: Functor f => f a -> f () Source #
void valueIO action.
Examples
Replace the contents of a Maybe Int
>>>void NothingNothing>>>void (Just 3)Just ()
Replace the contents of an Either Int IntEither Int ()
>>>void (Left 8675309)Left 8675309>>>void (Right 8675309)Right ()
Replace every element of a list with unit:
>>>void [1,2,3][(),(),()]
Replace the second element of a pair with unit:
>>>void (1,2)(1,())
Discard the result of an IO action:
>>>mapM print [1,2]1 2 [(),()]>>>void $ mapM print [1,2]1 2
through :: Functor f => (a -> f b) -> a -> f a Source #
Makes an effectful function ignore its result value and return its input value.
coerce :: forall {k :: RuntimeRep} (a :: TYPE k) (b :: TYPE k). Coercible a b => a -> b Source #
The function coerce allows you to safely convert between values of
types that have the same representation with no run-time overhead. In the
simplest case you can use it instead of a newtype constructor, to go from
the newtype's concrete type to the abstract type. But it also works in
more complicated settings, e.g. converting a list of newtypes to a list of
concrete types.
When used in conversions involving a newtype wrapper, make sure the newtype constructor is in scope.
This function is representation-polymorphic, but the
RuntimeRep type argument is marked as Inferred, meaning
that it is not available for visible type application. This means
the typechecker will accept coerce @Int @Age 42
Examples
>>>newtype TTL = TTL Int deriving (Eq, Ord, Show)>>>newtype Age = Age Int deriving (Eq, Ord, Show)>>>coerce (Age 42) :: TTLTTL 42>>>coerce (+ (1 :: Int)) (Age 42) :: TTLTTL 43>>>coerce (map (+ (1 :: Int))) [Age 42, Age 24] :: [TTL][TTL 43,TTL 25]
coerceVia :: Coercible a b => (a -> b) -> a -> b Source #
Coerce the second argument to the result type of the first one. The motivation for this
function is that it's often more annoying to explicitly specify a target type for coerce than
to construct an explicit coercion function, so this combinator can be used in cases like that.
Plus the code reads better, as it becomes clear what and where gets wrapped/unwrapped.
coerceArg :: Coercible a b => (a -> s) -> b -> s Source #
Same as f -> f . coerce, but does not create any closures and so is completely free.
coerceRes :: Coercible s t => (a -> s) -> a -> t Source #
Same as f -> coerce . f, but does not create any closures and so is completely free.
Representable types of kind *.
This class is derivable in GHC with the DeriveGeneric flag on.
A Generic instance must satisfy the following laws:
from.to≡idto.from≡id
Instances
A class of types that can be fully evaluated.
Since: deepseq-1.1.0.0
Instances
Natural number
Invariant: numbers <= 0xffffffffffffffff use the NS constructor
Instances
| FromJSON Natural | |
Defined in Data.Aeson.Types.FromJSON | |
| FromJSONKey Natural | |
Defined in Data.Aeson.Types.FromJSON | |
| ToJSON Natural | |
Defined in Data.Aeson.Types.ToJSON Methods toEncoding :: Natural -> Encoding toJSONList :: [Natural] -> Value toEncodingList :: [Natural] -> Encoding | |
| ToJSONKey Natural | |
Defined in Data.Aeson.Types.ToJSON | |
| Data Natural | Since: base-4.8.0.0 |
Defined in Data.Data Methods gfoldl :: (forall d b. Data d => c (d -> b) -> d -> c b) -> (forall g. g -> c g) -> Natural -> c Natural Source # gunfold :: (forall b r. Data b => c (b -> r) -> c r) -> (forall r. r -> c r) -> Constr -> c Natural Source # toConstr :: Natural -> Constr Source # dataTypeOf :: Natural -> DataType Source # dataCast1 :: Typeable t => (forall d. Data d => c (t d)) -> Maybe (c Natural) Source # dataCast2 :: Typeable t => (forall d e. (Data d, Data e) => c (t d e)) -> Maybe (c Natural) Source # gmapT :: (forall b. Data b => b -> b) -> Natural -> Natural Source # gmapQl :: (r -> r' -> r) -> r -> (forall d. Data d => d -> r') -> Natural -> r Source # gmapQr :: forall r r'. (r' -> r -> r) -> r -> (forall d. Data d => d -> r') -> Natural -> r Source # gmapQ :: (forall d. Data d => d -> u) -> Natural -> [u] Source # gmapQi :: Int -> (forall d. Data d => d -> u) -> Natural -> u Source # gmapM :: Monad m => (forall d. Data d => d -> m d) -> Natural -> m Natural Source # gmapMp :: MonadPlus m => (forall d. Data d => d -> m d) -> Natural -> m Natural Source # gmapMo :: MonadPlus m => (forall d. Data d => d -> m d) -> Natural -> m Natural Source # | |
| Bits Natural | Since: base-4.8.0 |
Defined in GHC.Bits Methods (.&.) :: Natural -> Natural -> Natural Source # (.|.) :: Natural -> Natural -> Natural Source # xor :: Natural -> Natural -> Natural Source # complement :: Natural -> Natural Source # shift :: Natural -> Int -> Natural Source # rotate :: Natural -> Int -> Natural Source # bit :: Int -> Natural Source # setBit :: Natural -> Int -> Natural Source # clearBit :: Natural -> Int -> Natural Source # complementBit :: Natural -> Int -> Natural Source # testBit :: Natural -> Int -> Bool Source # bitSizeMaybe :: Natural -> Maybe Int Source # bitSize :: Natural -> Int Source # isSigned :: Natural -> Bool Source # shiftL :: Natural -> Int -> Natural Source # unsafeShiftL :: Natural -> Int -> Natural Source # shiftR :: Natural -> Int -> Natural Source # unsafeShiftR :: Natural -> Int -> Natural Source # rotateL :: Natural -> Int -> Natural Source # | |
| Enum Natural | Since: base-4.8.0.0 |
Defined in GHC.Enum Methods succ :: Natural -> Natural Source # pred :: Natural -> Natural Source # toEnum :: Int -> Natural Source # fromEnum :: Natural -> Int Source # enumFrom :: Natural -> [Natural] Source # enumFromThen :: Natural -> Natural -> [Natural] Source # enumFromTo :: Natural -> Natural -> [Natural] Source # enumFromThenTo :: Natural -> Natural -> Natural -> [Natural] Source # | |
| Ix Natural | Since: base-4.8.0.0 |
| Num Natural | Note that Since: base-4.8.0.0 |
Defined in GHC.Num | |
| Read Natural | Since: base-4.8.0.0 |
| Integral Natural | Since: base-4.8.0.0 |
Defined in GHC.Real Methods quot :: Natural -> Natural -> Natural Source # rem :: Natural -> Natural -> Natural Source # div :: Natural -> Natural -> Natural Source # mod :: Natural -> Natural -> Natural Source # quotRem :: Natural -> Natural -> (Natural, Natural) Source # | |
| Real Natural | Since: base-4.8.0.0 |
| Show Natural | Since: base-4.8.0.0 |
| PrintfArg Natural | Since: base-4.8.0.0 |
Defined in Text.Printf Methods formatArg :: Natural -> FieldFormatter Source # parseFormat :: Natural -> ModifierParser Source # | |
| Subtractive Natural | |
| FromField Natural | |
Defined in Data.Csv.Conversion Methods parseField :: Field -> Parser Natural | |
| ToField Natural | |
Defined in Data.Csv.Conversion | |
| NFData Natural | Since: deepseq-1.4.0.0 |
Defined in Control.DeepSeq | |
| Eq Natural | |
| Ord Natural | |
| Hashable Natural | |
Defined in Data.Hashable.Class | |
| NoThunks Natural | |
| ExMemoryUsage Natural Source # | |
Defined in PlutusCore.Evaluation.Machine.ExMemoryUsage Methods memoryUsage :: Natural -> CostRose Source # | |
| Pretty Natural | |
Defined in Prettyprinter.Internal | |
| UniformRange Natural | |
Defined in System.Random.Internal | |
| Corecursive Natural | |
Defined in Data.Functor.Foldable Methods embed :: Base Natural Natural -> Natural ana :: (a -> Base Natural a) -> a -> Natural apo :: (a -> Base Natural (Either Natural a)) -> a -> Natural postpro :: Recursive Natural => (forall b. Base Natural b -> Base Natural b) -> (a -> Base Natural a) -> a -> Natural gpostpro :: (Recursive Natural, Monad m) => (forall b. m (Base Natural b) -> Base Natural (m b)) -> (forall c. Base Natural c -> Base Natural c) -> (a -> Base Natural (m a)) -> a -> Natural | |
| Recursive Natural | |
Defined in Data.Functor.Foldable Methods project :: Natural -> Base Natural Natural cata :: (Base Natural a -> a) -> Natural -> a para :: (Base Natural (Natural, a) -> a) -> Natural -> a gpara :: (Corecursive Natural, Comonad w) => (forall b. Base Natural (w b) -> w (Base Natural b)) -> (Base Natural (EnvT Natural w a) -> a) -> Natural -> a prepro :: Corecursive Natural => (forall b. Base Natural b -> Base Natural b) -> (Base Natural a -> a) -> Natural -> a gprepro :: (Corecursive Natural, Comonad w) => (forall b. Base Natural (w b) -> w (Base Natural b)) -> (forall c. Base Natural c -> Base Natural c) -> (Base Natural (w a) -> a) -> Natural -> a | |
| Serialise Natural | |
Defined in Codec.Serialise.Class | |
| Pretty Natural | |
Defined in Text.PrettyPrint.Annotated.WL | |
| KnownNat n => HasResolution (n :: Nat) | For example, |
Defined in Data.Fixed Methods resolution :: p n -> Integer Source # | |
| TestCoercion SNat | Since: base-4.18.0.0 |
Defined in GHC.TypeNats | |
| TestEquality SNat | Since: base-4.18.0.0 |
Defined in GHC.TypeNats | |
| DefaultPrettyBy config Natural | |
Defined in Text.PrettyBy.Internal Methods defaultPrettyBy :: config -> Natural -> Doc ann defaultPrettyListBy :: config -> [Natural] -> Doc ann | |
| PrettyDefaultBy config Natural => PrettyBy config Natural | |
Defined in Text.PrettyBy.Internal | |
| GCompare SNat | |
Defined in Data.GADT.Internal | |
| GEq SNat | |
| GShow SNat | |
Defined in Data.GADT.Internal Methods gshowsPrec :: forall (a :: k). Int -> SNat a -> ShowS # | |
| Lift Natural | |
| KnownBuiltinTypeIn DefaultUni term Integer => MakeKnownIn DefaultUni term Natural Source # | |
Defined in PlutusCore.Default.Universe Methods makeKnown :: Natural -> BuiltinResult term Source # | |
| KnownBuiltinTypeIn DefaultUni term Integer => ReadKnownIn DefaultUni term Natural Source # | |
Defined in PlutusCore.Default.Universe Methods readKnown :: term -> ReadKnownM Natural Source # | |
| KnownNat n => Reifies (n :: Nat) Integer | |
Defined in Data.Reflection | |
| KnownTypeAst tyname DefaultUni Natural Source # | |
Defined in PlutusCore.Default.Universe Associated Types type IsBuiltin DefaultUni Natural :: Bool Source # type ToHoles DefaultUni Natural :: [Hole] Source # type ToBinds DefaultUni acc Natural :: [Some TyNameRep] Source # Methods typeAst :: Type tyname DefaultUni () Source # | |
| GTraversable (n :: Nat) (f :: k1 -> Type) (g :: k1 -> Type) (Rec (P n f a') (f a) :: k2 -> Type) (Rec (P n g a') (g a) :: k2 -> Type) | |
Defined in Barbies.Generics.Traversable Methods gtraverse :: forall t (x :: k20). Applicative t => Proxy n -> (forall (a0 :: k10). f a0 -> t (g a0)) -> Rec (P n f a') (f a) x -> t (Rec (P n g a') (g a) x) | |
| Traversable h => GTraversable (n :: Nat) (f :: k1 -> Type) (g :: k1 -> Type) (Rec (h (P n f a)) (h (f a)) :: k2 -> Type) (Rec (h (P n g a)) (h (g a)) :: k2 -> Type) | |
Defined in Barbies.Generics.Traversable Methods gtraverse :: forall t (x :: k20). Applicative t => Proxy n -> (forall (a0 :: k10). f a0 -> t (g a0)) -> Rec (h (P n f a)) (h (f a)) x -> t (Rec (h (P n g a)) (h (g a)) x) | |
| type Difference Natural | |
Defined in Basement.Numerical.Subtractive | |
| type Base Natural | |
Defined in Data.Functor.Foldable | |
| type Compare (a :: Natural) (b :: Natural) | |
Defined in Data.Type.Ord | |
| type IsBuiltin DefaultUni Natural Source # | |
Defined in PlutusCore.Default.Universe | |
| type ToHoles DefaultUni Natural Source # | |
Defined in PlutusCore.Default.Universe | |
| type ToBinds DefaultUni acc Natural Source # | |
Defined in PlutusCore.Default.Universe | |
Non-empty (and non-strict) list type.
Since: base-4.9.0.0
Constructors
| a :| [a] infixr 5 |
Instances
| FromJSON1 NonEmpty | |
Defined in Data.Aeson.Types.FromJSON Methods liftParseJSON :: Maybe a -> (Value -> Parser a) -> (Value -> Parser [a]) -> Value -> Parser (NonEmpty a) liftParseJSONList :: Maybe a -> (Value -> Parser a) -> (Value -> Parser [a]) -> Value -> Parser [NonEmpty a] liftOmittedField :: Maybe a -> Maybe (NonEmpty a) | |
| ToJSON1 NonEmpty | |
Defined in Data.Aeson.Types.ToJSON Methods liftToJSON :: (a -> Bool) -> (a -> Value) -> ([a] -> Value) -> NonEmpty a -> Value liftToJSONList :: (a -> Bool) -> (a -> Value) -> ([a] -> Value) -> [NonEmpty a] -> Value liftToEncoding :: (a -> Bool) -> (a -> Encoding) -> ([a] -> Encoding) -> NonEmpty a -> Encoding liftToEncodingList :: (a -> Bool) -> (a -> Encoding) -> ([a] -> Encoding) -> [NonEmpty a] -> Encoding liftOmitField :: (a -> Bool) -> NonEmpty a -> Bool | |
| MonadFix NonEmpty | Since: base-4.9.0.0 |
| Foldable NonEmpty | Since: base-4.9.0.0 |
Defined in Data.Foldable Methods fold :: Monoid m => NonEmpty m -> m Source # foldMap :: Monoid m => (a -> m) -> NonEmpty a -> m Source # foldMap' :: Monoid m => (a -> m) -> NonEmpty a -> m Source # foldr :: (a -> b -> b) -> b -> NonEmpty a -> b Source # foldr' :: (a -> b -> b) -> b -> NonEmpty a -> b Source # foldl :: (b -> a -> b) -> b -> NonEmpty a -> b Source # foldl' :: (b -> a -> b) -> b -> NonEmpty a -> b Source # foldr1 :: (a -> a -> a) -> NonEmpty a -> a Source # foldl1 :: (a -> a -> a) -> NonEmpty a -> a Source # toList :: NonEmpty a -> [a] Source # null :: NonEmpty a -> Bool Source # length :: NonEmpty a -> Int Source # elem :: Eq a => a -> NonEmpty a -> Bool Source # maximum :: Ord a => NonEmpty a -> a Source # minimum :: Ord a => NonEmpty a -> a Source # | |
| Eq1 NonEmpty | Since: base-4.10.0.0 |
| Ord1 NonEmpty | Since: base-4.10.0.0 |
Defined in Data.Functor.Classes | |
| Read1 NonEmpty | Since: base-4.10.0.0 |
Defined in Data.Functor.Classes Methods liftReadsPrec :: (Int -> ReadS a) -> ReadS [a] -> Int -> ReadS (NonEmpty a) Source # liftReadList :: (Int -> ReadS a) -> ReadS [a] -> ReadS [NonEmpty a] Source # liftReadPrec :: ReadPrec a -> ReadPrec [a] -> ReadPrec (NonEmpty a) Source # liftReadListPrec :: ReadPrec a -> ReadPrec [a] -> ReadPrec [NonEmpty a] Source # | |
| Show1 NonEmpty | Since: base-4.10.0.0 |
| Traversable NonEmpty | Since: base-4.9.0.0 |
Defined in Data.Traversable | |
| Applicative NonEmpty | Since: base-4.9.0.0 |
Defined in GHC.Base | |
| Functor NonEmpty | Since: base-4.9.0.0 |
| Monad NonEmpty | Since: base-4.9.0.0 |
| NFData1 NonEmpty | Since: deepseq-1.4.3.0 |
Defined in Control.DeepSeq | |
| Hashable1 NonEmpty | |
Defined in Data.Hashable.Class | |
| Traversable1 NonEmpty | |
| Generic1 NonEmpty | |
| Foldable1WithIndex Int NonEmpty | |
Defined in WithIndex Methods ifoldMap1 :: Semigroup m => (Int -> a -> m) -> NonEmpty a -> m ifoldMap1' :: Semigroup m => (Int -> a -> m) -> NonEmpty a -> m ifoldrMap1 :: (Int -> a -> b) -> (Int -> a -> b -> b) -> NonEmpty a -> b ifoldlMap1' :: (Int -> a -> b) -> (Int -> b -> a -> b) -> NonEmpty a -> b ifoldlMap1 :: (Int -> a -> b) -> (Int -> b -> a -> b) -> NonEmpty a -> b ifoldrMap1' :: (Int -> a -> b) -> (Int -> a -> b -> b) -> NonEmpty a -> b | |
| FoldableWithIndex Int NonEmpty | |
Defined in WithIndex | |
| FunctorWithIndex Int NonEmpty | |
| TraversableWithIndex Int NonEmpty | |
| PrettyBy config a => DefaultPrettyBy config (NonEmpty a) | |
Defined in Text.PrettyBy.Internal Methods defaultPrettyBy :: config -> NonEmpty a -> Doc ann defaultPrettyListBy :: config -> [NonEmpty a] -> Doc ann | |
| PrettyDefaultBy config (NonEmpty a) => PrettyBy config (NonEmpty a) | |
Defined in Text.PrettyBy.Internal | |
| Lift a => Lift (NonEmpty a :: Type) | Since: template-haskell-2.15.0.0 |
| FromJSON a => FromJSON (NonEmpty a) | |
Defined in Data.Aeson.Types.FromJSON Methods parseJSON :: Value -> Parser (NonEmpty a) parseJSONList :: Value -> Parser [NonEmpty a] omittedField :: Maybe (NonEmpty a) | |
| ToJSON a => ToJSON (NonEmpty a) | |
Defined in Data.Aeson.Types.ToJSON Methods toEncoding :: NonEmpty a -> Encoding toJSONList :: [NonEmpty a] -> Value toEncodingList :: [NonEmpty a] -> Encoding | |
| Data a => Data (NonEmpty a) | Since: base-4.9.0.0 |
Defined in Data.Data Methods gfoldl :: (forall d b. Data d => c (d -> b) -> d -> c b) -> (forall g. g -> c g) -> NonEmpty a -> c (NonEmpty a) Source # gunfold :: (forall b r. Data b => c (b -> r) -> c r) -> (forall r. r -> c r) -> Constr -> c (NonEmpty a) Source # toConstr :: NonEmpty a -> Constr Source # dataTypeOf :: NonEmpty a -> DataType Source # dataCast1 :: Typeable t => (forall d. Data d => c (t d)) -> Maybe (c (NonEmpty a)) Source # dataCast2 :: Typeable t => (forall d e. (Data d, Data e) => c (t d e)) -> Maybe (c (NonEmpty a)) Source # gmapT :: (forall b. Data b => b -> b) -> NonEmpty a -> NonEmpty a Source # gmapQl :: (r -> r' -> r) -> r -> (forall d. Data d => d -> r') -> NonEmpty a -> r Source # gmapQr :: forall r r'. (r' -> r -> r) -> r -> (forall d. Data d => d -> r') -> NonEmpty a -> r Source # gmapQ :: (forall d. Data d => d -> u) -> NonEmpty a -> [u] Source # gmapQi :: Int -> (forall d. Data d => d -> u) -> NonEmpty a -> u Source # gmapM :: Monad m => (forall d. Data d => d -> m d) -> NonEmpty a -> m (NonEmpty a) Source # gmapMp :: MonadPlus m => (forall d. Data d => d -> m d) -> NonEmpty a -> m (NonEmpty a) Source # gmapMo :: MonadPlus m => (forall d. Data d => d -> m d) -> NonEmpty a -> m (NonEmpty a) Source # | |
| Semigroup (NonEmpty a) | Since: base-4.9.0.0 |
| Generic (NonEmpty a) | |
| IsList (NonEmpty a) | Since: base-4.9.0.0 |
| Read a => Read (NonEmpty a) | Since: base-4.11.0.0 |
| Show a => Show (NonEmpty a) | Since: base-4.11.0.0 |
| NFData a => NFData (NonEmpty a) | Since: deepseq-1.4.2.0 |
Defined in Control.DeepSeq | |
| Eq a => Eq (NonEmpty a) | Since: base-4.9.0.0 |
| Ord a => Ord (NonEmpty a) | Since: base-4.9.0.0 |
Defined in GHC.Base Methods compare :: NonEmpty a -> NonEmpty a -> Ordering Source # (<) :: NonEmpty a -> NonEmpty a -> Bool Source # (<=) :: NonEmpty a -> NonEmpty a -> Bool Source # (>) :: NonEmpty a -> NonEmpty a -> Bool Source # (>=) :: NonEmpty a -> NonEmpty a -> Bool Source # | |
| Hashable a => Hashable (NonEmpty a) | |
Defined in Data.Hashable.Class | |
| Ixed (NonEmpty a) | |
Defined in Control.Lens.At | |
| Reversing (NonEmpty a) | |
Defined in Control.Lens.Internal.Iso | |
| Wrapped (NonEmpty a) | |
Defined in Control.Lens.Wrapped Associated Types type Unwrapped (NonEmpty a) | |
| Ixed (NonEmpty a) | |
Defined in Lens.Micro.Internal | |
| GrowingAppend (NonEmpty a) | |
Defined in Data.MonoTraversable | |
| MonoFoldable (NonEmpty a) | |
Defined in Data.MonoTraversable Methods ofoldMap :: Monoid m => (Element (NonEmpty a) -> m) -> NonEmpty a -> m ofoldr :: (Element (NonEmpty a) -> b -> b) -> b -> NonEmpty a -> b ofoldl' :: (a0 -> Element (NonEmpty a) -> a0) -> a0 -> NonEmpty a -> a0 otoList :: NonEmpty a -> [Element (NonEmpty a)] oall :: (Element (NonEmpty a) -> Bool) -> NonEmpty a -> Bool oany :: (Element (NonEmpty a) -> Bool) -> NonEmpty a -> Bool olength64 :: NonEmpty a -> Int64 ocompareLength :: Integral i => NonEmpty a -> i -> Ordering otraverse_ :: Applicative f => (Element (NonEmpty a) -> f b) -> NonEmpty a -> f () ofor_ :: Applicative f => NonEmpty a -> (Element (NonEmpty a) -> f b) -> f () omapM_ :: Applicative m => (Element (NonEmpty a) -> m ()) -> NonEmpty a -> m () oforM_ :: Applicative m => NonEmpty a -> (Element (NonEmpty a) -> m ()) -> m () ofoldlM :: Monad m => (a0 -> Element (NonEmpty a) -> m a0) -> a0 -> NonEmpty a -> m a0 ofoldMap1Ex :: Semigroup m => (Element (NonEmpty a) -> m) -> NonEmpty a -> m ofoldr1Ex :: (Element (NonEmpty a) -> Element (NonEmpty a) -> Element (NonEmpty a)) -> NonEmpty a -> Element (NonEmpty a) ofoldl1Ex' :: (Element (NonEmpty a) -> Element (NonEmpty a) -> Element (NonEmpty a)) -> NonEmpty a -> Element (NonEmpty a) headEx :: NonEmpty a -> Element (NonEmpty a) lastEx :: NonEmpty a -> Element (NonEmpty a) unsafeHead :: NonEmpty a -> Element (NonEmpty a) unsafeLast :: NonEmpty a -> Element (NonEmpty a) maximumByEx :: (Element (NonEmpty a) -> Element (NonEmpty a) -> Ordering) -> NonEmpty a -> Element (NonEmpty a) minimumByEx :: (Element (NonEmpty a) -> Element (NonEmpty a) -> Ordering) -> NonEmpty a -> Element (NonEmpty a) | |
| MonoFunctor (NonEmpty a) | |
| MonoPointed (NonEmpty a) | |
Defined in Data.MonoTraversable | |
| MonoTraversable (NonEmpty a) | |
Defined in Data.MonoTraversable | |
| SemiSequence (NonEmpty a) | |
Defined in Data.Sequences Associated Types type Index (NonEmpty a) Methods intersperse :: Element (NonEmpty a) -> NonEmpty a -> NonEmpty a reverse :: NonEmpty a -> NonEmpty a find :: (Element (NonEmpty a) -> Bool) -> NonEmpty a -> Maybe (Element (NonEmpty a)) sortBy :: (Element (NonEmpty a) -> Element (NonEmpty a) -> Ordering) -> NonEmpty a -> NonEmpty a | |
| NoThunks a => NoThunks (NonEmpty a) | |
| Pretty a => Pretty (NonEmpty a) | |
Defined in Prettyprinter.Internal | |
| Corecursive (NonEmpty a) | |
Defined in Data.Functor.Foldable Methods embed :: Base (NonEmpty a) (NonEmpty a) -> NonEmpty a ana :: (a0 -> Base (NonEmpty a) a0) -> a0 -> NonEmpty a apo :: (a0 -> Base (NonEmpty a) (Either (NonEmpty a) a0)) -> a0 -> NonEmpty a postpro :: Recursive (NonEmpty a) => (forall b. Base (NonEmpty a) b -> Base (NonEmpty a) b) -> (a0 -> Base (NonEmpty a) a0) -> a0 -> NonEmpty a gpostpro :: (Recursive (NonEmpty a), Monad m) => (forall b. m (Base (NonEmpty a) b) -> Base (NonEmpty a) (m b)) -> (forall c. Base (NonEmpty a) c -> Base (NonEmpty a) c) -> (a0 -> Base (NonEmpty a) (m a0)) -> a0 -> NonEmpty a | |
| Recursive (NonEmpty a) | |
Defined in Data.Functor.Foldable Methods project :: NonEmpty a -> Base (NonEmpty a) (NonEmpty a) cata :: (Base (NonEmpty a) a0 -> a0) -> NonEmpty a -> a0 para :: (Base (NonEmpty a) (NonEmpty a, a0) -> a0) -> NonEmpty a -> a0 gpara :: (Corecursive (NonEmpty a), Comonad w) => (forall b. Base (NonEmpty a) (w b) -> w (Base (NonEmpty a) b)) -> (Base (NonEmpty a) (EnvT (NonEmpty a) w a0) -> a0) -> NonEmpty a -> a0 prepro :: Corecursive (NonEmpty a) => (forall b. Base (NonEmpty a) b -> Base (NonEmpty a) b) -> (Base (NonEmpty a) a0 -> a0) -> NonEmpty a -> a0 gprepro :: (Corecursive (NonEmpty a), Comonad w) => (forall b. Base (NonEmpty a) (w b) -> w (Base (NonEmpty a) b)) -> (forall c. Base (NonEmpty a) c -> Base (NonEmpty a) c) -> (Base (NonEmpty a) (w a0) -> a0) -> NonEmpty a -> a0 | |
| Serialise a => Serialise (NonEmpty a) | |
Defined in Codec.Serialise.Class Methods encode :: NonEmpty a -> Encoding decode :: Decoder s (NonEmpty a) encodeList :: [NonEmpty a] -> Encoding decodeList :: Decoder s [NonEmpty a] | |
| Pretty a => Pretty (NonEmpty a) | |
Defined in Text.PrettyPrint.Annotated.WL | |
| t ~ NonEmpty b => Rewrapped (NonEmpty a) t | |
Defined in Control.Lens.Wrapped | |
| Reference n t => Reference (NonEmpty n) t Source # | |
Defined in PlutusCore.Check.Scoping Methods referenceVia :: (forall name. ToScopedName name => name -> NameAnn) -> NonEmpty n -> t NameAnn -> t NameAnn Source # | |
| Each (NonEmpty a) (NonEmpty b) a b | |
Defined in Control.Lens.Each | |
| Each (NonEmpty a) (NonEmpty b) a b | |
Defined in Lens.Micro.Internal | |
| type Rep1 NonEmpty | Since: base-4.6.0.0 |
Defined in GHC.Generics type Rep1 NonEmpty = D1 ('MetaData "NonEmpty" "GHC.Base" "base" 'False) (C1 ('MetaCons ":|" ('InfixI 'RightAssociative 5) 'False) (S1 ('MetaSel ('Nothing :: Maybe Symbol) 'NoSourceUnpackedness 'NoSourceStrictness 'DecidedLazy) Par1 :*: S1 ('MetaSel ('Nothing :: Maybe Symbol) 'NoSourceUnpackedness 'NoSourceStrictness 'DecidedLazy) (Rec1 List))) | |
| type Rep (NonEmpty a) | Since: base-4.6.0.0 |
Defined in GHC.Generics type Rep (NonEmpty a) = D1 ('MetaData "NonEmpty" "GHC.Base" "base" 'False) (C1 ('MetaCons ":|" ('InfixI 'RightAssociative 5) 'False) (S1 ('MetaSel ('Nothing :: Maybe Symbol) 'NoSourceUnpackedness 'NoSourceStrictness 'DecidedLazy) (Rec0 a) :*: S1 ('MetaSel ('Nothing :: Maybe Symbol) 'NoSourceUnpackedness 'NoSourceStrictness 'DecidedLazy) (Rec0 [a]))) | |
| type Item (NonEmpty a) | |
Defined in GHC.IsList | |
| type Index (NonEmpty a) | |
Defined in Control.Lens.At | |
| type IxValue (NonEmpty a) | |
Defined in Control.Lens.At type IxValue (NonEmpty a) = a | |
| type Unwrapped (NonEmpty a) | |
Defined in Control.Lens.Wrapped type Unwrapped (NonEmpty a) = (a, [a]) | |
| type Index (NonEmpty a) | |
Defined in Lens.Micro.Internal | |
| type IxValue (NonEmpty a) | |
Defined in Lens.Micro.Internal type IxValue (NonEmpty a) = a | |
| type Element (NonEmpty a) | |
Defined in Data.MonoTraversable type Element (NonEmpty a) = a | |
| type Index (NonEmpty a) | |
Defined in Data.Sequences | |
| type Base (NonEmpty a) | |
Defined in Data.Functor.Foldable type Base (NonEmpty a) = NonEmptyF a | |
8-bit unsigned integer type
Instances
class Applicative f => Alternative (f :: Type -> Type) where Source #
A monoid on applicative functors.
If defined, some and many should be the least solutions
of the equations:
Methods
The identity of <|>
(<|>) :: f a -> f a -> f a infixl 3 Source #
An associative binary operation
One or more.
Zero or more.
Instances
class (Typeable e, Show e) => Exception e Source #
Any type that you wish to throw or catch as an exception must be an
instance of the Exception class. The simplest case is a new exception
type directly below the root:
data MyException = ThisException | ThatException
deriving Show
instance Exception MyExceptionThe default method definitions in the Exception class do what we need
in this case. You can now throw and catch ThisException and
ThatException as exceptions:
*Main> throw ThisException `catch` \e -> putStrLn ("Caught " ++ show (e :: MyException))
Caught ThisException
In more complicated examples, you may wish to define a whole hierarchy of exceptions:
---------------------------------------------------------------------
-- Make the root exception type for all the exceptions in a compiler
data SomeCompilerException = forall e . Exception e => SomeCompilerException e
instance Show SomeCompilerException where
show (SomeCompilerException e) = show e
instance Exception SomeCompilerException
compilerExceptionToException :: Exception e => e -> SomeException
compilerExceptionToException = toException . SomeCompilerException
compilerExceptionFromException :: Exception e => SomeException -> Maybe e
compilerExceptionFromException x = do
SomeCompilerException a <- fromException x
cast a
---------------------------------------------------------------------
-- Make a subhierarchy for exceptions in the frontend of the compiler
data SomeFrontendException = forall e . Exception e => SomeFrontendException e
instance Show SomeFrontendException where
show (SomeFrontendException e) = show e
instance Exception SomeFrontendException where
toException = compilerExceptionToException
fromException = compilerExceptionFromException
frontendExceptionToException :: Exception e => e -> SomeException
frontendExceptionToException = toException . SomeFrontendException
frontendExceptionFromException :: Exception e => SomeException -> Maybe e
frontendExceptionFromException x = do
SomeFrontendException a <- fromException x
cast a
---------------------------------------------------------------------
-- Make an exception type for a particular frontend compiler exception
data MismatchedParentheses = MismatchedParentheses
deriving Show
instance Exception MismatchedParentheses where
toException = frontendExceptionToException
fromException = frontendExceptionFromExceptionWe can now catch a MismatchedParentheses exception as
MismatchedParentheses, SomeFrontendException or
SomeCompilerException, but not other types, e.g. IOException:
*Main> throw MismatchedParentheses `catch` \e -> putStrLn ("Caught " ++ show (e :: MismatchedParentheses))
Caught MismatchedParentheses
*Main> throw MismatchedParentheses `catch` \e -> putStrLn ("Caught " ++ show (e :: SomeFrontendException))
Caught MismatchedParentheses
*Main> throw MismatchedParentheses `catch` \e -> putStrLn ("Caught " ++ show (e :: SomeCompilerException))
Caught MismatchedParentheses
*Main> throw MismatchedParentheses `catch` \e -> putStrLn ("Caught " ++ show (e :: IOException))
*** Exception: MismatchedParentheses
Instances
class a ~R# b => Coercible (a :: k) (b :: k) Source #
Coercible is a two-parameter class that has instances for types a and b if
the compiler can infer that they have the same representation. This class
does not have regular instances; instead they are created on-the-fly during
type-checking. Trying to manually declare an instance of Coercible
is an error.
Nevertheless one can pretend that the following three kinds of instances exist. First, as a trivial base-case:
instance Coercible a a
Furthermore, for every type constructor there is
an instance that allows to coerce under the type constructor. For
example, let D be a prototypical type constructor (data or
newtype) with three type arguments, which have roles nominal,
representational resp. phantom. Then there is an instance of
the form
instance Coercible b b' => Coercible (D a b c) (D a b' c')
Note that the nominal type arguments are equal, the
representational type arguments can differ, but need to have a
Coercible instance themself, and the phantom type arguments can be
changed arbitrarily.
The third kind of instance exists for every newtype NT = MkNT T and
comes in two variants, namely
instance Coercible a T => Coercible a NT
instance Coercible T b => Coercible NT b
This instance is only usable if the constructor MkNT is in scope.
If, as a library author of a type constructor like Set a, you
want to prevent a user of your module to write
coerce :: Set T -> Set NT,
you need to set the role of Set's type parameter to nominal,
by writing
type role Set nominal
For more details about this feature, please refer to Safe Coercions by Joachim Breitner, Richard A. Eisenberg, Simon Peyton Jones and Stephanie Weirich.
Since: ghc-prim-0.4.0
class Typeable (a :: k) Source #
The class Typeable allows a concrete representation of a type to
be calculated.
Minimal complete definition
typeRep#
Lens
view :: MonadReader s m => Getting a s a -> m a #
(<^>) :: Fold s a -> Fold s a -> Fold s a infixr 6 Source #
Compose two folds to make them run in parallel. The results are concatenated.
Debugging
traceShowId :: Show a => a -> a Source #
Like traceShow but returns the shown value instead of a third value.
>>>traceShowId (1+2+3, "hello" ++ "world")(6,"helloworld") (6,"helloworld")
Since: base-4.7.0.0
trace :: String -> a -> a Source #
The trace function outputs the trace message given as its first argument,
before returning the second argument as its result.
For example, this returns the value of f x and outputs the message to stderr.
Depending on your terminal (settings), they may or may not be mixed.
>>>let x = 123; f = show>>>trace ("calling f with x = " ++ show x) (f x)calling f with x = 123 "123"
The trace function should only be used for debugging, or for monitoring
execution. The function is not referentially transparent: its type indicates
that it is a pure function but it has the side effect of outputting the
trace message.
Reexports from Control.Composition
Custom functions
(<<*>>) :: (Applicative f1, Applicative f2) => f1 (f2 (a -> b)) -> f1 (f2 a) -> f1 (f2 b) infixl 4 Source #
mtraverse :: (Monad m, Traversable m, Applicative f) => (a -> f (m b)) -> m a -> f (m b) Source #
reoption :: (Foldable f, Alternative g) => f a -> g a Source #
This function generalizes eitherToMaybe, eitherToList,
listToMaybe and other such functions.
tabulateArray :: (Bounded i, Enum i, Ix i) => (i -> a) -> Array i a Source #
Basically a Data.Functor.Representable instance for Array.
We can't provide an actual instance because of the Distributive superclass: Array i is not
Distributive unless we assume that indices in an array range over the entirety of i.
(?) :: Alternative f => Bool -> a -> f a infixr 2 Source #
b ? x is equal to pure x whenever b holds and is empty otherwise.
ensure :: Alternative f => (a -> Bool) -> a -> f a Source #
ensure p x is equal to pure x whenever p x holds and is empty otherwise.
asksM :: MonadReader r m => (r -> m a) -> m a Source #
A monadic version of asks.
Pretty-printing
Instances
newtype ShowPretty a Source #
A newtype wrapper around a whose point is to provide a Show instance
for anything that has a Pretty instance.
Constructors
| ShowPretty | |
Fields
| |
Instances
| Pretty a => Show (ShowPretty a) Source # | |
Defined in PlutusPrelude | |
| Eq a => Eq (ShowPretty a) Source # | |
Defined in PlutusPrelude Methods (==) :: ShowPretty a -> ShowPretty a -> Bool Source # (/=) :: ShowPretty a -> ShowPretty a -> Bool Source # | |
Minimal complete definition
Instances
class PrettyBy config a where #
Minimal complete definition
Nothing
Instances
type family HasPrettyDefaults config :: Bool #
Instances
| type HasPrettyDefaults PrettyConfigName Source # | |
Defined in PlutusCore.Pretty.ConfigName | |
| type HasPrettyDefaults PrettyConfigPlc Source # | |
Defined in PlutusCore.Pretty.Plc | |
| type HasPrettyDefaults ConstConfig Source # | |
Defined in PlutusCore.Pretty.PrettyConst | |
| type HasPrettyDefaults () | |
Defined in Text.PrettyBy.Internal | |
| type HasPrettyDefaults (PrettyConfigClassic _1) Source # | |
Defined in PlutusCore.Pretty.Classic | |
| type HasPrettyDefaults (PrettyConfigReadable _1) Source # | |
Defined in PlutusCore.Pretty.Readable | |
| type HasPrettyDefaults (Sole config) Source # | |
Defined in PlutusCore.Pretty.Extra | |
type PrettyDefaultBy config = DispatchPrettyDefaultBy (NonStuckHasPrettyDefaults config) config #
Constructors
| PrettyAny | |
Fields
| |
Instances
GHCi
printPretty :: Pretty a => a -> IO () Source #
A command suitable for use in GHCi as an interactive printer.
Text
Minimal complete definition
Nothing
Instances
Lists
zipExact :: [a] -> [b] -> Maybe [(a, b)] Source #
Zips two lists of the same length together, returning Nothing if they are not
the same length.
unsafeFromRight :: Show e => Either e a -> a Source #
tryError :: MonadError e m => m a -> m (Either e a) Source #
A MonadError version of try.
TODO: remove when we switch to mtl>=2.3
modifyError :: MonadError e' m => (e -> e') -> ExceptT e m a -> m a Source #
lowerInitialChar :: String -> String Source #
Orphan instances
| (PrettyBy config a, PrettyBy config b) => DefaultPrettyBy config (Either a b) Source # | Default pretty-printing for the spine of |
Methods defaultPrettyBy :: config -> Either a b -> Doc ann defaultPrettyListBy :: config -> [Either a b] -> Doc ann | |
| PrettyDefaultBy config (Either a b) => PrettyBy config (Either a b) Source # | An instance extending the set of types supporting default pretty-printing with |
| (Pretty a, Pretty b) => Pretty (Either a b) Source # | |