plutus-core-1.60.0.0: Language library for Plutus Core
Safe HaskellSafe-Inferred
LanguageHaskell2010

PlutusPrelude

Contents

Reexports from base

(&) :: a -> (a -> b) -> b infixl 1 #

& is a reverse application operator. This provides notational convenience. Its precedence is one higher than that of the forward application operator $, which allows & to be nested in $.

>>> 5 & (+1) & show
"6"

Since: base-4.8.0.0

(&&&) :: Arrow a => a b c -> a b c' -> a b (c, c') infixr 3 #

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 #

Left-to-right composition

(<&>) :: Functor f => f a -> (a -> b) -> f b infixl 1 #

Flipped version of <$>.

(<&>) = flip fmap

Examples

Expand

Apply (+1) to a list, a Just and a Right:

>>> Just 2 <&> (+1)
Just 3

>>> [1,2,3] <&> (+1)
[2,3,4]

>>> Right 3 <&> (+1)
Right 4

Since: base-4.11.0.0

toList :: Foldable t => t a -> [a] #

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

Expand

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

first :: Bifunctor p => (a -> b) -> p a c -> p b c #

Map covariantly over the first argument.

first f ≡ bimap f id

Examples

Expand
>>> first toUpper ('j', 3)
('J',3)

>>> first toUpper (Left 'j')
Left 'J'

second :: Bifunctor p => (b -> c) -> p a b -> p a c #

Map covariantly over the second argument.

second ≡ bimap id

Examples

Expand
>>> second (+1) ('j', 3)
('j',4)

>>> second (+1) (Right 3)
Right 4

on :: (b -> b -> c) -> (a -> b) -> a -> a -> c infixl 0 #

on b u x y runs the binary function b on the results of applying unary function u to two arguments x and y. From the opposite perspective, it transforms two inputs and combines the outputs.

((+) `on` f) x y = f x + f y

Typical usage: sortBy (compare `on` fst).

Algebraic properties:

  • (*) `on` id = (*) -- (if (*) ∉ {⊥, const ⊥})
  • ((*) `on` f) `on` g = (*) `on` (f . g)
  • flip on f . flip on g = flip on (g . f)

isNothing :: Maybe a -> Bool #

The isNothing function returns True iff its argument is Nothing.

Examples

Expand

Basic usage:

>>> isNothing (Just 3)
False

>>> isNothing (Just ())
False

>>> isNothing Nothing
True

Only the outer constructor is taken into consideration:

>>> isNothing (Just Nothing)
False

isJust :: Maybe a -> Bool #

The isJust function returns True iff its argument is of the form Just _.

Examples

Expand

Basic usage:

>>> isJust (Just 3)
True

>>> isJust (Just ())
True

>>> isJust Nothing
False

Only the outer constructor is taken into consideration:

>>> isJust (Just Nothing)
True

fromMaybe :: a -> Maybe a -> a #

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

Expand

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 () #

Conditional failure of Alternative computations. Defined by

guard True  = pure ()
guard False = empty

Examples

Expand

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) otherwise. For example:

>>> safeDiv 4 0
Nothing

>>> safeDiv 4 2
Just 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 #

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 () #

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

Expand

Basic usage:

>>> for_ [1..4] print
1
2
3
4

traverse_ :: (Foldable t, Applicative f) => (a -> f b) -> t a -> f () #

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

Expand

Basic usage:

>>> traverse_ print ["Hello", "world", "!"]
"Hello"
"world"
"!"

fold :: (Foldable t, Monoid m) => t m -> m #

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

Expand

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) #

for is traverse with its arguments flipped. For a version that ignores the results see for_.

throw :: forall (r :: RuntimeRep) (a :: TYPE r) e. Exception e => e -> a #

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 #

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 bss' can be understood as the do expression

do bs <- bss
   bs

Examples

Expand

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

to run an STM transaction and the IO action it returns.

(<=<) :: Monad m => (b -> m c) -> (a -> m b) -> a -> m c infixr 1 #

Right-to-left composition of Kleisli arrows. (>=>), with the arguments flipped.

Note how this operator resembles function composition (.):

(.)   ::            (b ->   c) -> (a ->   b) -> a ->   c
(<=<) :: Monad m => (b -> m c) -> (a -> m b) -> a -> m c

(>=>) :: Monad m => (a -> m b) -> (b -> m c) -> a -> m c infixr 1 #

Left-to-right composition of Kleisli arrows.

'(bs >=> cs) a' can be understood as the do expression

do b <- bs a
   cs b

($>) :: Functor f => f a -> b -> f b infixl 4 #

Flipped version of <$.

Examples

Expand

Replace the contents of a Maybe Int with a constant String:

>>> Nothing $> "foo"
Nothing
>>> Just 90210 $> "foo"
Just "foo"

Replace the contents of an Either Int Int with a constant String, 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 #

Return the contents of a Right-value or a default value otherwise.

Examples

Expand

Basic usage:

>>> fromRight 1 (Right 3)
3
>>> fromRight 1 (Left "foo")
1

Since: base-4.10.0.0

isRight :: Either a b -> Bool #

Return True if the given value is a Right-value, False otherwise.

Examples

Expand

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 #

Return True if the given value is a Left-value, False otherwise.

Examples

Expand

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 () #

void value discards or ignores the result of evaluation, such as the return value of an IO action.

Examples

Expand

Replace the contents of a Maybe Int with unit:

>>> void Nothing
Nothing
>>> void (Just 3)
Just ()

Replace the contents of an Either Int Int with unit, resulting in an Either 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 #

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 #

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

Expand
>>> newtype TTL = TTL Int deriving (Eq, Ord, Show)
>>> newtype Age = Age Int deriving (Eq, Ord, Show)
>>> coerce (Age 42) :: TTL
TTL 42
>>> coerce (+ (1 :: Int)) (Age 42) :: TTL
TTL 43
>>> coerce (map (+ (1 :: Int))) [Age 42, Age 24] :: [TTL]
[TTL 43,TTL 25]

coerceVia :: Coercible a b => (a -> b) -> a -> b #

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 #

Same as f -> f . coerce, but does not create any closures and so is completely free.

coerceRes :: Coercible s t => (a -> s) -> a -> t #

Same as f -> coerce . f, but does not create any closures and so is completely free.

(#.) :: Coercible b c => (b -> c) -> (a -> b) -> a -> c #

Same as (.), but ignores the first argument and uses a no-op coerction instead.

class Generic a #

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 ≡ id
to . from ≡ id

Minimal complete definition

Hash h a -> () #

(NFData k, NFData a) => NFData (MVector s a -> () #

(NFData a, NFData b) => NFData (a, b) 
Instance details

Defined in Control.DeepSeq

Methods

rnf :: (a, b) -> () #

NFData (a -> b)

This instance is for convenience and consistency with seq. This assumes that WHNF is equivalent to NF for functions.

Since: deepseq-1.3.0.0

Instance details

Defined in ToJSON Natural 

Instance details

Defined in Data.Aeson.Types.ToJSON

Methods

toJSON :: Natural -> Value

toEncoding :: Natural -> Encoding

toJSONList :: [Natural] -> Value

toEncodingList :: [Natural] -> Encoding

omitField :: Natural -> Bool

ToJSONKey Natural 
Instance details

Defined in Data.Aeson.Types.ToJSON

Methods

toJSONKey :: ToJSONKeyFunction Natural

toJSONKeyList :: ToJSONKeyFunction [Natural]

Data Natural

Since: base-4.8.0.0

Instance details

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 #

gunfold :: (forall b r. Data b => c (b -> r) -> c r) -> (forall r. r -> c r) -> Constr -> c Natural #

toConstr :: Natural -> Constr #

dataTypeOf :: Natural -> DataType #

dataCast1 :: Typeable t => (forall d. Data d => c (t d)) -> Maybe (c Natural) #

dataCast2 :: Typeable t => (forall d e. (Data d, Data e) => c (t d e)) -> Maybe (c Natural) #

gmapT :: (forall b. Data b => b -> b) -> Natural -> Natural #

gmapQl :: (r -> r' -> r) -> r -> (forall d. Data d => d -> r') -> Natural -> r #

gmapQr :: forall r r'. (r' -> r -> r) -> r -> (forall d. Data d => d -> r') -> Natural -> r #

gmapQ :: (forall d. Data d => d -> u) -> Natural -> [u] #

gmapQi :: Int -> (forall d. Data d => d -> u) -> Natural -> u #

gmapM :: Monad m => (forall d. Data d => d -> m d) -> Natural -> m Natural #

gmapMp :: MonadPlus m => (forall d. Data d => d -> m d) -> Natural -> m Natural #

gmapMo :: MonadPlus m => (forall d. Data d => d -> m d) -> Natural -> m Natural #

Bits Natural

Since: base-4.8.0

Instance details

Defined in GHC.Bits

Methods

(.&.) :: Natural -> Natural -> Natural #

(.|.) :: Natural -> Natural -> Natural #

xor :: Natural -> Natural -> Natural #

complement :: Natural -> Natural #

shift :: Natural -> Int -> Natural #

rotate :: Natural -> Int -> Natural #

zeroBits :: Natural #

bit :: Int -> Natural #

setBit :: Natural -> Int -> Natural #

clearBit :: Natural -> Int -> Natural #

complementBit :: Natural -> Int -> Natural #

testBit :: Natural -> Int -> Bool #

bitSizeMaybe :: Natural -> Maybe Int #

bitSize :: Natural -> Int #

isSigned :: Natural -> Bool #

shiftL :: Natural -> Int -> Natural #

unsafeShiftL :: Natural -> Int -> Natural #

shiftR :: Natural -> Int -> Natural #

unsafeShiftR :: Natural -> Int -> Natural #

rotateL :: Natural -> Int -> Natural #

rotateR :: Natural -> Int -> Natural #

popCount :: Natural -> Int #

Enum Natural

Since: base-4.8.0.0

Instance details

Defined in GHC.Enum

Methods

succ :: Natural -> Natural #

pred :: Natural -> Natural #

toEnum :: Int -> Natural #

fromEnum :: Natural -> Int #

enumFrom :: Natural -> [Natural] #

enumFromThen :: Natural -> Natural -> [Natural] #

enumFromTo :: Natural -> Natural -> [Natural] #

enumFromThenTo :: Natural -> Natural -> Natural -> [Natural] #

Ix Natural

Since: base-4.8.0.0

Instance details

Defined in GHC.Ix

Methods

range :: (Natural, Natural) -> [Natural] #

index :: (Natural, Natural) -> Natural -> Int #

unsafeIndex :: (Natural, Natural) -> Natural -> Int #

inRange :: (Natural, Natural) -> Natural -> Bool #

rangeSize :: (Natural, Natural) -> Int #

unsafeRangeSize :: (Natural, Natural) -> Int #

Num Natural

Note that Natural's Num instance isn't a ring: no element but 0 has an additive inverse. It is a semiring though.

Since: base-4.8.0.0

Instance details

Defined in Text.PrettyBy.Internal

Methods

defaultPrettyBy :: config -> Natural -> Doc ann #

defaultPrettyListBy :: config -> [Natural] -> Doc ann #

PrettyDefaultBy config Natural => PrettyBy config Natural
>>> prettyBy () (123 :: Natural)
123
Instance details

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)

prettyBy for NonEmpty a is defined in terms of prettyListBy by default.

>>> prettyBy () (True :| [False])
[True, False]
>>> prettyBy () ('a' :| "bc")
abc
>>> prettyBy () (Just False :| [Nothing, Just True])
[False, True]
Instance details

Defined in PlutusCore.Flat.Data.ByteString.Convert

Methods

toByteString :: [Word8] -> MVector s Word64)

type IsBuiltin DefaultUni Word64 # 
Instance details

Defined in PlutusCore.Default.Universe

type IsBuiltin DefaultUni Word64
type ToBinds DefaultUni acc Word64 # 
Instance details

Defined in PlutusCore.Default.Universe

type ToBinds DefaultUni acc Word64
type ToHoles DefaultUni hole Word64 # 
Instance details

Defined in PlutusCore.Default.Universe

type ToHoles DefaultUni hole Word64

class Applicative f => Alternative (f :: Type -> Type) where #

A monoid on applicative functors.

If defined, some and many should be the least solutions of the equations:

Alternative IO

Takes the first non-throwing IO action's result. empty throws an exception.

Since: base-4.9.0.0

Instance details

Defined in Star f a [a0] #

(Alternative f, Applicative g) => Alternative (Compose f g)

Since: base-4.9.0.0

Instance details

Defined in Data.Functor.Compose

Methods

empty :: Compose f g a #

(<|>) :: Compose f g a -> Compose f g a -> Compose f g a #

some :: Compose f g a -> Compose f g [a] #

many :: Compose f g a -> Compose f g [a] #

(Alternative f, Applicative g) => Alternative (f :.: g)

Since: base-4.9.0.0

Instance details

Defined in GHC.Generics

Methods

empty :: (f :.: g) a #

(<|>) :: (f :.: g) a -> (f :.: g) a -> (f :.: g) a #

some :: (f :.: g) a -> (f :.: g) [a] #

many :: (f :.: g) a -> (f :.: g) [a] #

Alternative f => Alternative (M1 i c f)

Since: base-4.9.0.0

Instance details

Defined in GHC.Generics

Methods

empty :: M1 i c f a #

(<|>) :: M1 i c f a -> M1 i c f a -> M1 i c f a #

some :: M1 i c f a -> M1 i c f [a] #

many :: M1 i c f a -> M1 i c f [a] #

Alternative m => Alternative (NormalizeTypeT m tyname uni ann) # 
Instance details

Defined in PlutusCore.Normalize.Internal

Methods

empty :: NormalizeTypeT m tyname uni ann a #

(<|>) :: NormalizeTypeT m tyname uni ann a -> NormalizeTypeT m tyname uni ann a -> NormalizeTypeT m tyname uni ann a #

some :: NormalizeTypeT m tyname uni ann a -> NormalizeTypeT m tyname uni ann [a] #

many :: NormalizeTypeT m tyname uni ann a -> NormalizeTypeT m tyname uni ann [a] #

(Functor m, MonadPlus m) => Alternative (RWST r w s m) 
Instance details

Defined in Control.Monad.Trans.RWS.CPS

Methods

empty :: RWST r w s m a #

(<|>) :: RWST r w s m a -> RWST r w s m a -> RWST r w s m a #

some :: RWST r w s m a -> RWST r w s m [a] #

many :: RWST r w s m a -> RWST r w s m [a] #

(Monoid w, Functor m, MonadPlus m) => Alternative (RWST r w s m) 
Instance details

Defined in Control.Monad.Trans.RWS.Lazy

Methods

empty :: RWST r w s m a #

(<|>) :: RWST r w s m a -> RWST r w s m a -> RWST r w s m a #

some :: RWST r w s m a -> RWST r w s m [a] #

many :: RWST r w s m a -> RWST r w s m [a] #

(Monoid w, Functor m, MonadPlus m) => Alternative (RWST r w s m) 
Instance details

Defined in Control.Monad.Trans.RWS.Strict

Methods

empty :: RWST r w s m a #

(<|>) :: RWST r w s m a -> RWST r w s m a -> RWST r w s m a #

some :: RWST r w s m a -> RWST r w s m [a] #

many :: RWST r w s m a -> RWST r w s m [a] #

class (Typeable e, Show e) => Exception e #

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 MyException

The 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 = frontendExceptionFromException

We 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

Instances details
Exception AesonException 
Instance details

Defined in Data.Aeson.Types.Internal

Methods

toException :: AesonException -> DecodeException -> ParseErrorBundle s e -> String #

(PrettyPlc cause, PrettyPlc err, Typeable cause, Typeable err) => Exception (ErrorWithCause err cause) # 
Instance details

Defined in PlutusCore.Evaluation.ErrorWithCause

Methods

toException :: ErrorWithCause err cause -> SomeException #

fromException :: SomeException -> Maybe (ErrorWithCause err cause) #

displayException :: ErrorWithCause err cause -> String #

(Reifies s (SomeException -> Maybe a), Typeable a, Typeable s, Typeable m) => Exception (Handling a s m) 
Instance details

Defined in Control.Lens.Internal.Exception

Methods

toException :: Handling a s m -> SomeException #

fromException :: SomeException -> Maybe (Handling a s m) #

displayException :: Handling a s m -> String #

newtype PairT b f a #

Constructors

PairT 

Fields

Instances

Instances details
Functor f => Functor (PairT b f) # 
Instance details

Defined in PlutusPrelude

Methods

fmap :: (a -> b0) -> PairT b f a -> PairT b f b0 #

(<$) :: a -> PairT b f b0 -> PairT b f a #

class a ~R# b => Coercible (a :: k) (b :: k) #

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) #

The class Typeable allows a concrete representation of a type to be calculated.

Minimal complete definition

typeRep#

Lens

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 #

purely :: ((a -> Identity b) -> c -> Identity d) -> (a -> b) -> c -> d #

(<^>) :: Fold s a -> Fold s a -> Fold s a infixr 6 #

Compose two folds to make them run in parallel. The results are concatenated.

Debugging

traceShowId :: Show a => a -> a #

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 #

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

(.*) :: (c -> d) -> (a -> b -> c) -> a -> b -> d infixr 8 #

Custom functions

(<<$>>) :: (Functor f1, Functor f2) => (a -> b) -> f1 (f2 a) -> f1 (f2 b) infixl 4 #

(<<*>>) :: (Applicative f1, Applicative f2) => f1 (f2 (a -> b)) -> f1 (f2 a) -> f1 (f2 b) infixl 4 #

forJoin :: (Monad m, Traversable m, Applicative f) => m a -> (a -> f (m b)) -> f (m b) #

foldMapM :: (Foldable f, Monad m, Monoid b) => (a -> m b) -> f a -> m b #

Fold a monadic function over a Foldable. The monadic version of foldMap.

reoption :: (Foldable f, Alternative g) => f a -> g a #

This function generalizes eitherToMaybe, eitherToList, listToMaybe and other such functions.

enumerate :: (Enum a, Bounded a) => [a] #

Enumerate all the values of an Enum, from minBound to maxBound.

enumerate == [False, True]

tabulateArray :: (Bounded i, Enum i, Ix i) => (i -> a) -> Array i a #

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 #

b ? x is equal to pure x whenever b holds and is empty otherwise.

ensure :: Alternative f => (a -> Bool) -> a -> f a #

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 #

A monadic version of asks.

timesA :: Natural -> (a -> a) -> a -> a #

function recursively applied N times

Pretty-printing

data Doc ann #

The abstract data type Doc ann represents pretty documents that have been annotated with data of type ann.

More specifically, a value of type Doc represents a non-empty set of possible layouts of a document. The layout functions select one of these possibilities, taking into account things like the width of the output document.

The annotation is an arbitrary piece of data associated with (part of) a document. Annotations may be used by the rendering backends in order to display output differently, such as

  • color information (e.g. when rendering to the terminal)
  • mouseover text (e.g. when rendering to rich HTML)
  • whether to show something or not (to allow simple or detailed versions)

The simplest way to display a Doc is via the Show class.

>>> putStrLn (show (vsep ["hello", "world"]))
hello
world

Instances

Instances details
Functor Doc

Alter the document’s annotations.

This instance makes Doc more flexible (because it can be used in Functor-polymorphic values), but fmap is much less readable compared to using reAnnotate in code that only works for Doc anyway. Consider using the latter when the type does not matter.

Instance details

Defined in Prettyprinter.Internal

Methods

fmap :: (a -> b) -> Doc a -> Doc b #

(<$) :: a -> Doc b -> Doc a #

IsString (Doc ann)
>>> pretty ("hello\nworld")
hello
world

This instance uses the Pretty Doc instance, and uses the same newline to emptyDoc hcat 

>>> mappend "hello" "world" :: Doc ann
helloworld
Instance details

Defined in hcat [x, y] 

>>> "hello" <> "world" :: Doc ann
helloworld
Instance details

Defined in defaultLayoutOptions, ignoring all annotations.

Instance details

Defined in Text)) PageWidth -> Doc ann)))) :+: (C1 ('MetaCons "Nesting" 'PrefixI 'False) (S1 ('MetaSel ('Nothing :: Maybe Symbol) 'NoSourceUnpackedness 'NoSourceStrictness 'DecidedLazy) (Rec0 (Int -> Doc ann))) :+: C1 ('MetaCons "Annotated" 'PrefixI 'False) (S1 ('MetaSel ('Nothing :: Maybe Symbol) 'NoSourceUnpackedness 'NoSourceStrictness 'DecidedLazy) (Rec0 ann) :*: S1 ('MetaSel ('Nothing :: Maybe Symbol) 'NoSourceUnpackedness 'NoSourceStrictness 'DecidedLazy) (Rec0 (Doc ann)))))))

newtype ShowPretty a #

A newtype wrapper around a whose point is to provide a Show instance for anything that has a Pretty instance.

Constructors

ShowPretty 

Fields

Instances

Instances details
Pretty a => Show (ShowPretty a) # 
Instance details

Defined in PlutusPrelude

Methods

showsPrec :: Int -> ShowPretty a -> ShowS #

show :: ShowPretty a -> String #

showList :: [ShowPretty a] -> ShowS #

Eq a => Eq (ShowPretty a) # 
Instance details

Defined in PlutusPrelude

Methods

(==) :: ShowPretty a -> ShowPretty a -> Bool #

(/=) :: ShowPretty a -> ShowPretty a -> Bool #

class Pretty a where #

Overloaded conversion to Doc.

Laws:

  1. output should be pretty. :-)

Minimal complete definition

pretty

Methods

pretty :: a -> Doc ann #

>>> pretty 1 <+> pretty "hello" <+> pretty 1.234
1 hello 1.234

prettyList :: [a] -> Doc ann #

prettyList is only used to define the instance Pretty a => Pretty [a]. In normal circumstances only the pretty function is used.

>>> prettyList [1, 23, 456]
[1, 23, 456]

Instances

Instances details
Pretty Void

Finding a good example for printing something that does not exist is hard, so here is an example of printing a list full of nothing.

>>> pretty ([] :: [Void])
[]
Instance details

Defined in Text

Automatically converts all newlines to line.

>>> pretty ("hello\nworld" :: Text)
hello
world

Note that group:

>>> group (pretty ("hello\nworld" :: Text))
hello world

Manually use Text] -> Doc ann #

Pretty Prettyprinter.Internal

Methods

pretty :: Text -> Doc ann #

prettyList :: [Text] -> Doc ann #

Pretty Integer
>>> pretty (2^123 :: Integer)
10633823966279326983230456482242756608
Instance details

Defined in Prettyprinter.Internal

Methods

pretty :: Natural -> Doc ann #

prettyList :: [Natural] -> Doc ann #

Pretty ()
>>> pretty ()
()

The argument is not used:

>>> pretty (error "Strict?" :: ())
()
Instance details

Defined in Prettyprinter.Internal

Methods

pretty :: () -> Doc ann #

prettyList :: [()] -> Doc ann #

Pretty Bool
>>> pretty True
True
Instance details

Defined in line as a more readable alternative.

>>> pretty 'f' <> pretty 'o' <> pretty 'o'
foo
>>> pretty ("string" :: String)
string
Instance details

Defined in Prettyprinter.Internal

Methods

pretty :: Char -> Doc ann #

prettyList :: [Char] -> Doc ann #

Pretty Double
>>> pretty (exp 1 :: Double)
2.71828182845904...
Instance details

Defined in Prettyprinter.Internal

Methods

pretty :: Double -> Doc ann #

prettyList :: [Double] -> Doc ann #

Pretty Float
>>> pretty (pi :: Float)
3.1415927
Instance details

Defined in Prettyprinter.Internal

Methods

pretty :: Float -> Doc ann #

prettyList :: [Float] -> Doc ann #

Pretty Int
>>> pretty (123 :: Int)
123
Instance details

Defined in Prettyprinter.Internal

Methods

pretty :: Word -> Doc ann #

prettyList :: [Word] -> Doc ann #

Pretty a => Pretty (Identity a)
>>> pretty (Identity 1)
1
Instance details

Defined in Prettyprinter.Internal

Methods

pretty :: NonEmpty a -> Doc ann #

prettyList :: [NonEmpty a] -> Doc ann #

Pretty a => Pretty (Spine a) #
>>> import Text.Pretty
>>> pretty (SpineCons 'a' $ SpineLast 'b')
[a, b]
Instance details

Defined in PlutusCore.Builtin.KnownType

Methods

pretty :: Spine a -> Doc ann #

prettyList :: [Spine a] -> Doc ann #

Pretty (BuiltinSemanticsVariant DefaultFun) # 
Instance details

Defined in PlutusCore.Default.Builtins

Methods

pretty :: BuiltinSemanticsVariant DefaultFun -> Doc ann #

prettyList :: [BuiltinSemanticsVariant DefaultFun] -> Doc ann #

Pretty ann => Pretty (Kind ann) # 
Instance details

Defined in PlutusCore.Core.Instance.Pretty.Default

Methods

pretty :: Kind ann -> Doc ann0 #

prettyList :: [Kind ann] -> Doc ann0 #

Pretty a => Pretty (Normalized a) # 
Instance details

Defined in PlutusCore.Core.Type

Methods

pretty :: Normalized a -> Doc ann #

prettyList :: [Normalized a] -> Doc ann #

Pretty (DefaultUni a) #

This always pretty-prints parens around type applications (e.g. (list bool)) and doesn't pretty-print them otherwise (e.g. integer).

Instance details

Defined in PlutusCore.Default.Universe

Methods

pretty :: DefaultUni a -> Doc ann #

prettyList :: [DefaultUni a] -> Doc ann #

Pretty ann => Pretty (UniqueError ann) # 
Instance details

Defined in PlutusCore.Error

Methods

pretty :: UniqueError ann -> Doc ann0 #

prettyList :: [UniqueError ann] -> Doc ann0 #

PrettyClassic a => Pretty (EvaluationResult a) # 
Instance details

Defined in PlutusCore.Evaluation.Result

Methods

pretty :: EvaluationResult a -> Doc ann #

prettyList :: [EvaluationResult a] -> Doc ann #

PrettyReadable a => Pretty (AsReadable a) # 
Instance details

Defined in PlutusCore.Pretty.Readable

Methods

pretty :: AsReadable a -> Doc ann #

prettyList :: [AsReadable a] -> Doc ann #

Pretty (SomeTypeIn DefaultUni) # 
Instance details

Defined in PlutusCore.Default.Universe

Methods

pretty :: SomeTypeIn DefaultUni -> Doc ann #

prettyList :: [SomeTypeIn DefaultUni] -> Doc ann #

Pretty (SomeTypeIn uni) => Pretty (SomeTypeIn (Kinded uni)) # 
Instance details

Defined in PlutusCore.Pretty.PrettyConst

Methods

pretty :: SomeTypeIn (Kinded uni) -> Doc ann #

prettyList :: [SomeTypeIn (Kinded uni)] -> Doc ann #

(Show fun, Ord fun) => Pretty (CekExTally fun) # 
Instance details

Defined in UntypedPlutusCore.Evaluation.Machine.Cek.ExBudgetMode

Methods

pretty :: CekExTally fun -> Doc ann #

prettyList :: [CekExTally fun] -> Doc ann #

(Show fun, Ord fun) => Pretty (TallyingSt fun) # 
Instance details

Defined in UntypedPlutusCore.Evaluation.Machine.Cek.ExBudgetMode

Methods

pretty :: TallyingSt fun -> Doc ann #

prettyList :: [TallyingSt fun] -> Doc ann #

Show fun => Pretty (ExBudgetCategory fun) # 
Instance details

Defined in UntypedPlutusCore.Evaluation.Machine.Cek.Internal

Methods

pretty :: ExBudgetCategory fun -> Doc ann #

prettyList :: [ExBudgetCategory fun] -> Doc ann #

Pretty a => Pretty (Maybe a)

Ignore Nothings, print Just contents.

>>> pretty (Just True)
True
>>> braces (pretty (Nothing :: Maybe Bool))
{}

>>> pretty [Just 1, Nothing, Just 3, Nothing]
[1, 3]
Instance details

Defined in Prettyprinter.Internal

Methods

pretty :: Maybe a -> Doc ann #

prettyList :: [Maybe a] -> Doc ann #

Pretty a => Pretty [a]
>>> pretty [1,2,3]
[1, 2, 3]
Instance details

Defined in AttachDefaultPrettyConfig config a] -> Doc ann #

PrettyBy config a => Pretty (AttachPrettyConfig config a)
>>> data Cfg = Cfg
>>> data D = D
>>> instance PrettyBy Cfg D where prettyBy Cfg D = "D"
>>> pretty $ AttachPrettyConfig Cfg D
D
Instance details

Defined in Text.PrettyBy.Internal

Methods

pretty :: AttachPrettyConfig config a -> Doc ann #

prettyList :: [AttachPrettyConfig config a] -> Doc ann #

(Closed uni, Everywhere uni PrettyConst) => Pretty (Some (ValueOf uni)) # 
Instance details

Defined in PlutusCore.Pretty.PrettyConst

Methods

pretty :: Some (ValueOf uni) -> Doc ann #

prettyList :: [Some (ValueOf uni)] -> Doc ann #

(Pretty a1, Pretty a2) => Pretty (a1, a2)
>>> pretty (123, "hello")
(123, hello)
Instance details

Defined in Prettyprinter.Internal

Methods

pretty :: Const a b -> Doc ann #

prettyList :: [Const a b] -> Doc ann #

(Pretty err, Pretty a, Pretty b) => Pretty (HeadSpine err a b) #
>>> import Text.Pretty
>>> pretty (HeadOnly 'z')
z
>>> pretty (HeadSpine 'f' (SpineCons 'x' $ SpineLast 'y'))
f `applyN` [x, y]
Instance details

Defined in PlutusCore.Builtin.KnownType

Methods

pretty :: HeadSpine err a b -> Doc ann #

prettyList :: [HeadSpine err a b] -> Doc ann #

(PrettyClassic tyname, PrettyParens (SomeTypeIn uni), Pretty ann) => Pretty (Type tyname uni ann) # 
Instance details

Defined in PlutusCore.Core.Instance.Pretty.Default

Methods

pretty :: Type tyname uni ann -> Doc ann0 #

prettyList :: [Type tyname uni ann] -> Doc ann0 #

Pretty (CekState uni fun ann) # 
Instance details

Defined in UntypedPlutusCore.Evaluation.Machine.SteppableCek.Internal

Methods

pretty :: CekState uni fun ann -> Doc ann0 #

prettyList :: [CekState uni fun ann] -> Doc ann0 #

(Pretty a1, Pretty a2, Pretty a3) => Pretty (a1, a2, a3)
>>> pretty (123, "hello", False)
(123, hello, False)
Instance details

Defined in Prettyprinter.Internal

Methods

pretty :: (a1, a2, a3) -> Doc ann #

prettyList :: [(a1, a2, a3)] -> Doc ann #

(PrettyClassic name, PrettyUni uni, Pretty fun, Pretty ann) => Pretty (Program name uni fun ann) # 
Instance details

Defined in UntypedPlutusCore.Core.Instance.Pretty.Default

Methods

pretty :: Program name uni fun ann -> Doc ann0 #

prettyList :: [Program name uni fun ann] -> Doc ann0 #

(PrettyClassic name, PrettyUni uni, Pretty fun, Pretty ann) => Pretty (Term name uni fun ann) # 
Instance details

Defined in UntypedPlutusCore.Core.Instance.Pretty.Default

Methods

pretty :: Term name uni fun ann -> Doc ann0 #

prettyList :: [Term name uni fun ann] -> Doc ann0 #

(PrettyClassic tyname, PrettyClassic name, PrettyUni uni, Pretty fun, Pretty ann) => Pretty (Program tyname name uni fun ann) # 
Instance details

Defined in PlutusCore.Core.Instance.Pretty.Default

Methods

pretty :: Program tyname name uni fun ann -> Doc ann0 #

prettyList :: [Program tyname name uni fun ann] -> Doc ann0 #

(PrettyClassic tyname, PrettyClassic name, PrettyUni uni, Pretty fun, Pretty ann) => Pretty (Term tyname name uni fun ann) # 
Instance details

Defined in PlutusCore.Core.Instance.Pretty.Default

Methods

pretty :: Term tyname name uni fun ann -> Doc ann0 #

prettyList :: [Term tyname name uni fun ann] -> Doc ann0 #

class PrettyBy config a where #

A class for pretty-printing values in a configurable manner.

A basic example:

>>> data Case = UpperCase | LowerCase
>>> data D = D
>>> instance PrettyBy Case D where prettyBy UpperCase D = "D"; prettyBy LowerCase D = "d"
>>> prettyBy UpperCase D
D
>>> prettyBy LowerCase D
d

The library provides instances for common types like Integer or Bool, so you can't define your own PrettyBy SomeConfig Integer instance. And for the same reason you should not define instances like PrettyBy SomeAnotherConfig a for universally quantified a, because such an instance would overlap with the existing ones. Take for example

>>> data ViaShow = ViaShow
>>> instance Show a => PrettyBy ViaShow a where prettyBy ViaShow = pretty . show

with such an instance prettyBy ViaShow (1 :: Int) throws an error about overlapping instances:

• Overlapping instances for PrettyBy ViaShow Int
    arising from a use of ‘prettyBy’
  Matching instances:
    instance PrettyDefaultBy config Int => PrettyBy config Int
    instance [safe] Show a => PrettyBy ViaShow a

There's a newtype provided specifically for the purpose of defining a PrettyBy instance for any a: PrettyAny. Read its docs for details on when you might want to use it.

The PrettyBy instance for common types is defined in a way that allows to override default pretty-printing behaviour, read the docs of HasPrettyDefaults for details.

Minimal complete definition

Nothing

Methods

prettyBy :: config -> a -> Doc ann #

Pretty-print a value of type a the way a config specifies it. The default implementation of prettyBy is in terms of pretty, defaultPrettyFunctorBy or defaultPrettyBifunctorBy depending on the kind of the data type that you're providing an instance for. For example, the default implementation of prettyBy for a monomorphic type is going to be "ignore the config and call pretty over the value":

>>> newtype N = N Int deriving newtype (Pretty)
>>> instance PrettyBy () N
>>> prettyBy () (N 42)
42

The default implementation of prettyBy for a Functor is going to be in terms of defaultPrettyFunctorBy:

>>> newtype N a = N a deriving stock (Functor) deriving newtype (Pretty)
>>> instance PrettyBy () a => PrettyBy () (N a)
>>> prettyBy () (N (42 :: Int))
42

It's fine for the data type to have a phantom parameter as long as the data type is still a defaultPrettyFunctorBy is used again:

>>> newtype N a = N Int deriving stock (Functor) deriving newtype (Pretty)
>>> instance PrettyBy () (N b)
>>> prettyBy () (N 42)
42

If the data type has a single parameter of any other kind, then it's not a functor and so like in the monomorphic case pretty is used:

>>> newtype N (b :: Bool) = N Int deriving newtype (Pretty)
>>> instance PrettyBy () (N b)
>>> prettyBy () (N 42)
42

Same applies to a data type with two parameters: if both the parameters are of kind Type, then the data type is assumed to be a defaultPrettyBifunctorBy is used. If the right parameter is of kind Type and the left parameter is of any other kind, then we fallback to assuming the data type is a Functor and defining prettyBy as defaultPrettyFunctorBy. If both the parameters are not of kind Type, we fallback to implementing prettyBy in terms of pretty like in the monomorphic case.

Note that in all those cases a Pretty instance for the data type has to already exist, so that we can derive a PrettyBy one in terms of it. If it doesn't exist or if your data type is not supported (for example, if it has three or more parameters of kind Type), then you'll need to provide the implementation manually.

prettyListBy :: config -> [a] -> Doc ann #

prettyListBy is used to define the default PrettyBy instance for [a] and NonEmpty a. In normal circumstances only the prettyBy function is used. The default implementation of prettyListBy is in terms of defaultPrettyFunctorBy.

Instances

Instances details
PrettyBy PrettyConfigPlc DefaultFun # 
Instance details

Defined in PlutusCore.Default.Builtins

Methods

prettyBy :: PrettyConfigPlc -> DefaultFun -> Doc ann #

prettyListBy :: PrettyConfigPlc -> [DefaultFun] -> Doc ann #

PrettyBy ConstConfig ByteString # 
Instance details

Defined in PlutusCore.Pretty.PrettyConst

Methods

prettyBy :: ConstConfig -> ByteString -> Doc ann #

prettyListBy :: ConstConfig -> [ByteString] -> Doc ann #

PrettyBy ConstConfig Element # 
Instance details

Defined in PlutusCore.Crypto.BLS12_381.G1

Methods

prettyBy :: ConstConfig -> Element -> Doc ann #

prettyListBy :: ConstConfig -> [Element] -> Doc ann #

PrettyBy ConstConfig Element # 
Instance details

Defined in PlutusCore.Crypto.BLS12_381.G2

Methods

prettyBy :: ConstConfig -> Element -> Doc ann #

prettyListBy :: ConstConfig -> [Element] -> Doc ann #

PrettyBy ConstConfig MlResult # 
Instance details

Defined in PlutusCore.Crypto.BLS12_381.Pairing

Methods

prettyBy :: ConstConfig -> MlResult -> Doc ann #

prettyListBy :: ConstConfig -> [MlResult] -> Doc ann #

PrettyBy ConstConfig Data # 
Instance details

Defined in PlutusCore.Pretty.PrettyConst

Methods

prettyBy :: ConstConfig -> Data -> Doc ann #

prettyListBy :: ConstConfig -> [Data] -> Doc ann #

PrettyBy ConstConfig K # 
Instance details

Defined in PlutusCore.Pretty.PrettyConst

Methods

prettyBy :: ConstConfig -> K -> Doc ann #

prettyListBy :: ConstConfig -> [K] -> Doc ann #

PrettyBy ConstConfig Quantity # 
Instance details

Defined in PlutusCore.Pretty.PrettyConst

Methods

prettyBy :: ConstConfig -> Quantity -> Doc ann #

prettyListBy :: ConstConfig -> [Quantity] -> Doc ann #

PrettyBy ConstConfig Value # 
Instance details

Defined in PlutusCore.Pretty.PrettyConst

Methods

prettyBy :: ConstConfig -> Value -> Doc ann #

prettyListBy :: ConstConfig -> [Value] -> Doc ann #

PrettyDefaultBy config Void => PrettyBy config Void
>>> prettyBy () ([] :: [Void])
[]
Instance details

Defined in Text

Automatically converts all newlines to line.

>>> prettyBy () ("hello\nworld" :: Strict.Text)
hello
world
Instance details

Defined in Text] -> Doc ann #

PrettyDefaultBy config Text.PrettyBy.Internal

Methods

prettyBy :: config -> Text -> Doc ann #

prettyListBy :: config -> [Text] -> Doc ann #

PrettyDefaultBy config Integer => PrettyBy config Integer
>>> prettyBy () (2^(123 :: Int) :: Integer)
10633823966279326983230456482242756608
Instance details

Defined in Text.PrettyBy.Internal

Methods

prettyBy :: config -> Integer -> Doc ann #

prettyListBy :: config -> [Integer] -> Doc ann #

PrettyDefaultBy config Natural => PrettyBy config Natural
>>> prettyBy () (123 :: Natural)
123
Instance details

Defined in Text.PrettyBy.Internal

Methods

prettyBy :: config -> Natural -> Doc ann #

prettyListBy :: config -> [Natural] -> Doc ann #

PrettyDefaultBy config () => PrettyBy config ()
>>> prettyBy () ()
()

The argument is not used:

>>> prettyBy () (error "Strict?" :: ())
()
Instance details

Defined in Text.PrettyBy.Internal

Methods

prettyBy :: config -> () -> Doc ann #

prettyListBy :: config -> [()] -> Doc ann #

PrettyDefaultBy config Bool => PrettyBy config Bool
>>> prettyBy () True
True
Instance details

Defined in Text.PrettyBy.Internal

Methods

prettyBy :: config -> Bool -> Doc ann #

prettyListBy :: config -> [Bool] -> Doc ann #

PrettyDefaultBy config Char => PrettyBy config Char

By default a String (i.e. [Char]) is converted to a Text first and then pretty-printed. So make sure that if you have any non-default pretty-printing for Char or Text, they're in sync.

>>> prettyBy () 'a'
a
>>> prettyBy () "abc"
abc
Instance details

Defined in Text.PrettyBy.Internal

Methods

prettyBy :: config -> Char -> Doc ann #

prettyListBy :: config -> [Char] -> Doc ann #

PrettyDefaultBy config Double => PrettyBy config Double
>>> prettyBy () (pi :: Double)
3.141592653589793
Instance details

Defined in Text.PrettyBy.Internal

Methods

prettyBy :: config -> Double -> Doc ann #

prettyListBy :: config -> [Double] -> Doc ann #

PrettyDefaultBy config Float => PrettyBy config Float
>>> prettyBy () (pi :: Float)
3.1415927
Instance details

Defined in Text.PrettyBy.Internal

Methods

prettyBy :: config -> Float -> Doc ann #

prettyListBy :: config -> [Float] -> Doc ann #

PrettyDefaultBy config Int => PrettyBy config Int
>>> prettyBy () (123 :: Int)
123
Instance details

Defined in RenderContext -> [SomeTypeIn DefaultUni] -> Doc ann #

PrettyDefaultBy config (Identity a) => PrettyBy config (Identity a)
>>> prettyBy () (Identity True)
True
Instance details

Defined in Text.PrettyBy.Internal

Methods

prettyBy :: config -> Identity a -> Doc ann #

prettyListBy :: config -> [Identity a] -> Doc ann #

PrettyDefaultBy config (NonEmpty a) => PrettyBy config (NonEmpty a)

prettyBy for NonEmpty a is defined in terms of prettyListBy by default.

>>> prettyBy () (True :| [False])
[True, False]
>>> prettyBy () ('a' :| "bc")
abc
>>> prettyBy () (Just False :| [Nothing, Just True])
[False, True]
Instance details

Defined in Text.PrettyBy.Internal

Methods

prettyBy :: config -> NonEmpty a -> Doc ann #

prettyListBy :: config -> [NonEmpty a] -> Doc ann #

PrettyDefaultBy config (Set a) => PrettyBy config (Set a) # 
Instance details

Defined in PlutusCore.Pretty.Extra

Methods

prettyBy :: config -> Set a -> Doc ann #

prettyListBy :: config -> [Set a] -> Doc ann #

PrettyDefaultBy config (Spine a) => PrettyBy config (Spine a) # 
Instance details

Defined in PlutusCore.Builtin.KnownType

Methods

prettyBy :: config -> Spine a -> Doc ann #

prettyListBy :: config -> [Spine a] -> Doc ann #

PrettyBy config (t NameAnn) => PrettyBy config (ScopeCheckError t) # 
Instance details

Defined in PlutusCore.Check.Scoping

Methods

prettyBy :: config -> ScopeCheckError t -> Doc ann #

prettyListBy :: config -> [ScopeCheckError t] -> Doc ann #

PrettyBy config a => PrettyBy config (Normalized a) # 
Instance details

Defined in PlutusCore.Core.Type

Methods

prettyBy :: config -> Normalized a -> Doc ann #

prettyListBy :: config -> [Normalized a] -> Doc ann #

(HasPrettyDefaults config ~ 'True, Pretty fun) => PrettyBy config (MachineError fun) # 
Instance details

Defined in PlutusCore.Evaluation.Machine.Exception

Methods

prettyBy :: config -> MachineError fun -> Doc ann #

prettyListBy :: config -> [MachineError fun] -> Doc ann #

PrettyBy config a => PrettyBy config (EvaluationResult a) # 
Instance details

Defined in PlutusCore.Evaluation.Result

Methods

prettyBy :: config -> EvaluationResult a -> Doc ann #

prettyListBy :: config -> [EvaluationResult a] -> Doc ann #

PrettyDefaultBy config (AsReadable a) => PrettyBy config (AsReadable a) # 
Instance details

Defined in PlutusCore.Pretty.Readable

Methods

prettyBy :: config -> AsReadable a -> Doc ann #

prettyListBy :: config -> [AsReadable a] -> Doc ann #

(Show fun, Ord fun) => PrettyBy config (CekExTally fun) # 
Instance details

Defined in UntypedPlutusCore.Evaluation.Machine.Cek.ExBudgetMode

Methods

prettyBy :: config -> CekExTally fun -> Doc ann #

prettyListBy :: config -> [CekExTally fun] -> Doc ann #

(Show fun, Ord fun) => PrettyBy config (TallyingSt fun) # 
Instance details

Defined in UntypedPlutusCore.Evaluation.Machine.Cek.ExBudgetMode

Methods

prettyBy :: config -> TallyingSt fun -> Doc ann #

prettyListBy :: config -> [TallyingSt fun] -> Doc ann #

Pretty a => PrettyBy config (IgnorePrettyConfig a)
>>> data Cfg = Cfg
>>> data D = D
>>> instance Pretty D where pretty D = "D"
>>> prettyBy Cfg $ IgnorePrettyConfig D
D
Instance details

Defined in Vector a] -> Doc ann #

PrettyDefaultBy config (Maybe a) => PrettyBy config (Maybe a)

By default a [Maybe a] is converted to [a] first and only then pretty-printed.

>>> braces $ prettyBy () (Just True)
{True}
>>> braces $ prettyBy () (Nothing :: Maybe Bool)
{}
>>> prettyBy () [Just False, Nothing, Just True]
[False, True]
>>> prettyBy () [Nothing, Just 'a', Just 'b', Nothing, Just 'c']
abc
Instance details

Defined in Text.PrettyBy.Internal

Methods

prettyBy :: config -> Maybe a -> Doc ann #

prettyListBy :: config -> [Maybe a] -> Doc ann #

PrettyDefaultBy config [a] => PrettyBy config [a]

prettyBy for [a] is defined in terms of prettyListBy by default.

>>> prettyBy () [True, False]
[True, False]
>>> prettyBy () "abc"
abc
>>> prettyBy () [Just False, Nothing, Just True]
[False, True]
Instance details

Defined in Text.PrettyBy.Internal

Methods

prettyBy :: config -> [a] -> Doc ann #

prettyListBy :: config -> [[a]] -> Doc ann #

(PrettyUni uni, Pretty fun) => PrettyBy PrettyConfigPlc (CkValue uni fun) # 
Instance details

Defined in PlutusCore.Evaluation.Machine.Ck

Methods

prettyBy :: PrettyConfigPlc -> CkValue uni fun -> Doc ann #

prettyListBy :: PrettyConfigPlc -> [CkValue uni fun] -> Doc ann #

(PrettyUni uni, Pretty fun) => PrettyBy PrettyConfigPlc (DischargeResult uni fun) # 
Instance details

Defined in UntypedPlutusCore.Evaluation.Machine.Cek.Internal

Methods

prettyBy :: PrettyConfigPlc -> DischargeResult uni fun -> Doc ann #

prettyListBy :: PrettyConfigPlc -> [DischargeResult uni fun] -> Doc ann #

(Closed uni, Everywhere uni PrettyConst) => PrettyBy ConstConfig (ValueOf uni a) # 
Instance details

Defined in PlutusCore.Pretty.PrettyConst

Methods

prettyBy :: ConstConfig -> ValueOf uni a -> Doc ann #

prettyListBy :: ConstConfig -> [ValueOf uni a] -> Doc ann #

(Closed uni, Everywhere uni PrettyConst) => PrettyBy ConstConfig (Some (ValueOf uni)) # 
Instance details

Defined in PlutusCore.Pretty.PrettyConst

Methods

prettyBy :: ConstConfig -> Some (ValueOf uni) -> Doc ann #

prettyListBy :: ConstConfig -> [Some (ValueOf uni)] -> Doc ann #

PrettyDefaultBy config (Either a b) => PrettyBy config (Either a b) #

An instance extending the set of types supporting default pretty-printing with Either.

Instance details

Defined in PlutusPrelude

Methods

prettyBy :: config -> Either a b -> Doc ann #

prettyListBy :: config -> [Either a b] -> Doc ann #

PrettyDefaultBy config (Map k v) => PrettyBy config (Map k v) # 
Instance details

Defined in PlutusCore.Pretty.Extra

Methods

prettyBy :: config -> Map k v -> Doc ann #

prettyListBy :: config -> [Map k v] -> Doc ann #

(HasPrettyDefaults config ~ 'True, PrettyBy config structural, Pretty operational) => PrettyBy config (EvaluationError structural operational) # 
Instance details

Defined in PlutusCore.Evaluation.Error

Methods

prettyBy :: config -> EvaluationError structural operational -> Doc ann #

prettyListBy :: config -> [EvaluationError structural operational] -> Doc ann #

(PrettyBy config cause, PrettyBy config err) => PrettyBy config (ErrorWithCause err cause) # 
Instance details

Defined in PlutusCore.Evaluation.ErrorWithCause

Methods

prettyBy :: config -> ErrorWithCause err cause -> Doc ann #

prettyListBy :: config -> [ErrorWithCause err cause] -> Doc ann #

PrettyDefaultBy config (a, b) => PrettyBy config (a, b)
>>> prettyBy () (False, "abc")
(False, abc)
Instance details

Defined in Text.PrettyBy.Internal

Methods

prettyBy :: config -> (a, b) -> Doc ann #

prettyListBy :: config -> [(a, b)] -> Doc ann #

DefaultPrettyPlcStrategy (Type tyname uni ann) => PrettyBy PrettyConfigPlc (Type tyname uni ann) # 
Instance details

Defined in PlutusCore.Core.Instance.Pretty.Plc

Methods

prettyBy :: PrettyConfigPlc -> Type tyname uni ann -> Doc ann0 #

prettyListBy :: PrettyConfigPlc -> [Type tyname uni ann] -> Doc ann0 #

(PrettyUni uni, Pretty fun, Pretty ann) => PrettyBy PrettyConfigPlc (Error uni fun ann) # 
Instance details

Defined in PlutusCore.Error

Methods

prettyBy :: PrettyConfigPlc -> Error uni fun ann -> Doc ann0 #

prettyListBy :: PrettyConfigPlc -> [Error uni fun ann] -> Doc ann0 #

(PrettyUni uni, Pretty fun) => PrettyBy PrettyConfigPlc (CekValue uni fun ann) # 
Instance details

Defined in UntypedPlutusCore.Evaluation.Machine.Cek.Internal

Methods

prettyBy :: PrettyConfigPlc -> CekValue uni fun ann -> Doc ann0 #

prettyListBy :: PrettyConfigPlc -> [CekValue uni fun ann] -> Doc ann0 #

PrettyDefaultBy config (Const a b) => PrettyBy config (Const a b)

Non-polykinded, because Pretty (Const a b) is not polykinded either.

>>> prettyBy () (Const 1 :: Const Integer Bool)
1
Instance details

Defined in Text.PrettyBy.Internal

Methods

prettyBy :: config -> Const a b -> Doc ann #

prettyListBy :: config -> [Const a b] -> Doc ann #

PrettyDefaultBy config (HeadSpine err a b) => PrettyBy config (HeadSpine err a b) # 
Instance details

Defined in PlutusCore.Builtin.KnownType

Methods

prettyBy :: config -> HeadSpine err a b -> Doc ann #

prettyListBy :: config -> [HeadSpine err a b] -> Doc ann #

PrettyDefaultBy config (a, b, c) => PrettyBy config (a, b, c)
>>> prettyBy () ('a', "bcd", True)
(a, bcd, True)
Instance details

Defined in Text.PrettyBy.Internal

Methods

prettyBy :: config -> (a, b, c) -> Doc ann #

prettyListBy :: config -> [(a, b, c)] -> Doc ann #

(Pretty term, PrettyUni uni, Pretty fun, Pretty ann) => PrettyBy PrettyConfigPlc (TypeError term uni fun ann) # 
Instance details

Defined in PlutusCore.Error

Methods

prettyBy :: PrettyConfigPlc -> TypeError term uni fun ann -> Doc ann0 #

prettyListBy :: PrettyConfigPlc -> [TypeError term uni fun ann] -> Doc ann0 #

DefaultPrettyPlcStrategy (UnrestrictedProgram name uni fun ann) => PrettyBy PrettyConfigPlc (UnrestrictedProgram name uni fun ann) # 
Instance details

Defined in UntypedPlutusCore.Core.Instance.Flat

Methods

prettyBy :: PrettyConfigPlc -> UnrestrictedProgram name uni fun ann -> Doc ann0 #

prettyListBy :: PrettyConfigPlc -> [UnrestrictedProgram name uni fun ann] -> Doc ann0 #

DefaultPrettyPlcStrategy (Program name uni fun ann) => PrettyBy PrettyConfigPlc (Program name uni fun ann) # 
Instance details

Defined in UntypedPlutusCore.Core.Instance.Pretty.Plc

Methods

prettyBy :: PrettyConfigPlc -> Program name uni fun ann -> Doc ann0 #

prettyListBy :: PrettyConfigPlc -> [Program name uni fun ann] -> Doc ann0 #

DefaultPrettyPlcStrategy (Term name uni fun ann) => PrettyBy PrettyConfigPlc (Term name uni fun ann) # 
Instance details

Defined in UntypedPlutusCore.Core.Instance.Pretty.Plc

Methods

prettyBy :: PrettyConfigPlc -> Term name uni fun ann -> Doc ann0 #

prettyListBy :: PrettyConfigPlc -> [Term name uni fun ann] -> Doc ann0 #

PrettyBy config (Term name uni fun a) => PrettyBy config (EvalOrder name uni fun a) # 
Instance details

Defined in UntypedPlutusCore.Purity

Methods

prettyBy :: config -> EvalOrder name uni fun a -> Doc ann #

prettyListBy :: config -> [EvalOrder name uni fun a] -> Doc ann #

PrettyBy config (Term name uni fun a) => PrettyBy config (EvalTerm name uni fun a) # 
Instance details

Defined in UntypedPlutusCore.Purity

Methods

prettyBy :: config -> EvalTerm name uni fun a -> Doc ann #

prettyListBy :: config -> [EvalTerm name uni fun a] -> Doc ann #

DefaultPrettyPlcStrategy (Program tyname name uni fun ann) => PrettyBy PrettyConfigPlc (Program tyname name uni fun ann) # 
Instance details

Defined in PlutusCore.Core.Instance.Pretty.Plc

Methods

prettyBy :: PrettyConfigPlc -> Program tyname name uni fun ann -> Doc ann0 #

prettyListBy :: PrettyConfigPlc -> [Program tyname name uni fun ann] -> Doc ann0 #

DefaultPrettyPlcStrategy (Term tyname name uni fun ann) => PrettyBy PrettyConfigPlc (Term tyname name uni fun ann) # 
Instance details

Defined in PlutusCore.Core.Instance.Pretty.Plc

Methods

prettyBy :: PrettyConfigPlc -> Term tyname name uni fun ann -> Doc ann0 #

prettyListBy :: PrettyConfigPlc -> [Term tyname name uni fun ann] -> Doc ann0 #

(Pretty ann, PrettyBy config (Type tyname uni ann), PrettyBy config (Term tyname name uni fun ann)) => PrettyBy config (NormCheckError tyname name uni fun ann) # 
Instance details

Defined in PlutusCore.Error

Methods

prettyBy :: config -> NormCheckError tyname name uni fun ann -> Doc ann0 #

prettyListBy :: config -> [NormCheckError tyname name uni fun ann] -> Doc ann0 #

Pretty ann => PrettyBy (PrettyConfigClassic configName) (Kind ann) # 
Instance details

Defined in PlutusCore.Core.Instance.Pretty.Classic

Methods

prettyBy :: PrettyConfigClassic configName -> Kind ann -> Doc ann0 #

prettyListBy :: PrettyConfigClassic configName -> [Kind ann] -> Doc ann0 #

PrettyBy (PrettyConfigReadable configName) (Kind a) # 
Instance details

Defined in PlutusCore.Core.Instance.Pretty.Readable

Methods

prettyBy :: PrettyConfigReadable configName -> Kind a -> Doc ann #

prettyListBy :: PrettyConfigReadable configName -> [Kind a] -> Doc ann #

PrettyReadableBy configName a => PrettyBy (PrettyConfigReadable configName) (Parened a) # 
Instance details

Defined in PlutusCore.Pretty.Readable

Methods

prettyBy :: PrettyConfigReadable configName -> Parened a -> Doc ann #

prettyListBy :: PrettyConfigReadable configName -> [Parened a] -> Doc ann #

PrettyReadableBy configName tyname => PrettyBy (PrettyConfigReadable configName) (TyVarDecl tyname ann) # 
Instance details

Defined in PlutusCore.Core.Instance.Pretty.Readable

Methods

prettyBy :: PrettyConfigReadable configName -> TyVarDecl tyname ann -> Doc ann0 #

prettyListBy :: PrettyConfigReadable configName -> [TyVarDecl tyname ann] -> Doc ann0 #

(PrettyClassicBy configName tyname, PrettyParens (SomeTypeIn uni), Pretty ann) => PrettyBy (PrettyConfigClassic configName) (Type tyname uni ann) # 
Instance details

Defined in PlutusCore.Core.Instance.Pretty.Classic

Methods

prettyBy :: PrettyConfigClassic configName -> Type tyname uni ann -> Doc ann0 #

prettyListBy :: PrettyConfigClassic configName -> [Type tyname uni ann] -> Doc ann0 #

(PrettyReadableBy configName tyname, PrettyParens (SomeTypeIn uni)) => PrettyBy (PrettyConfigReadable configName) (Type tyname uni a) # 
Instance details

Defined in PlutusCore.Core.Instance.Pretty.Readable

Methods

prettyBy :: PrettyConfigReadable configName -> Type tyname uni a -> Doc ann #

prettyListBy :: PrettyConfigReadable configName -> [Type tyname uni a] -> Doc ann #

(PrettyClassic name, PrettyUni uni, Pretty fun, Pretty ann) => PrettyBy (PrettyConfigClassic PrettyConfigName) (UnrestrictedProgram name uni fun ann) # 
Instance details

Defined in UntypedPlutusCore.Core.Instance.Flat

Methods

prettyBy :: PrettyConfigClassic PrettyConfigName -> UnrestrictedProgram name uni fun ann -> Doc ann0 #

prettyListBy :: PrettyConfigClassic PrettyConfigName -> [UnrestrictedProgram name uni fun ann] -> Doc ann0 #

(PrettyClassicBy configName (Term name uni fun ann), Pretty ann) => PrettyBy (PrettyConfigClassic configName) (Program name uni fun ann) # 
Instance details

Defined in UntypedPlutusCore.Core.Instance.Pretty.Classic

Methods

prettyBy :: PrettyConfigClassic configName -> Program name uni fun ann -> Doc ann0 #

prettyListBy :: PrettyConfigClassic configName -> [Program name uni fun ann] -> Doc ann0 #

(PrettyClassicBy configName name, PrettyUni uni, Pretty fun, Pretty ann) => PrettyBy (PrettyConfigClassic configName) (Term name uni fun ann) # 
Instance details

Defined in UntypedPlutusCore.Core.Instance.Pretty.Classic

Methods

prettyBy :: PrettyConfigClassic configName -> Term name uni fun ann -> Doc ann0 #

prettyListBy :: PrettyConfigClassic configName -> [Term name uni fun ann] -> Doc ann0 #

(PrettyReadable name, PrettyUni uni, Pretty fun) => PrettyBy (PrettyConfigReadable PrettyConfigName) (UnrestrictedProgram name uni fun ann) # 
Instance details

Defined in UntypedPlutusCore.Core.Instance.Flat

Methods

prettyBy :: PrettyConfigReadable PrettyConfigName -> UnrestrictedProgram name uni fun ann -> Doc ann0 #

prettyListBy :: PrettyConfigReadable PrettyConfigName -> [UnrestrictedProgram name uni fun ann] -> Doc ann0 #

(PrettyReadableBy configName tyname, PrettyReadableBy configName name, PrettyUni uni) => PrettyBy (PrettyConfigReadable configName) (VarDecl tyname name uni ann) # 
Instance details

Defined in PlutusCore.Core.Instance.Pretty.Readable

Methods

prettyBy :: PrettyConfigReadable configName -> VarDecl tyname name uni ann -> Doc ann0 #

prettyListBy :: PrettyConfigReadable configName -> [VarDecl tyname name uni ann] -> Doc ann0 #

PrettyReadableBy configName (Term name uni fun a) => PrettyBy (PrettyConfigReadable configName) (Program name uni fun a) # 
Instance details

Defined in UntypedPlutusCore.Core.Instance.Pretty.Readable

Methods

prettyBy :: PrettyConfigReadable configName -> Program name uni fun a -> Doc ann #

prettyListBy :: PrettyConfigReadable configName -> [Program name uni fun a] -> Doc ann #

(PrettyReadableBy configName name, PrettyUni uni, Pretty fun, Show configName) => PrettyBy (PrettyConfigReadable configName) (Term name uni fun a) # 
Instance details

Defined in UntypedPlutusCore.Core.Instance.Pretty.Readable

Methods

prettyBy :: PrettyConfigReadable configName -> Term name uni fun a -> Doc ann #

prettyListBy :: PrettyConfigReadable configName -> [Term name uni fun a] -> Doc ann #

(PrettyClassicBy configName (Term tyname name uni fun ann), Pretty ann) => PrettyBy (PrettyConfigClassic configName) (Program tyname name uni fun ann) # 
Instance details

Defined in PlutusCore.Core.Instance.Pretty.Classic

Methods

prettyBy :: PrettyConfigClassic configName -> Program tyname name uni fun ann -> Doc ann0 #

prettyListBy :: PrettyConfigClassic configName -> [Program tyname name uni fun ann] -> Doc ann0 #

(PrettyClassicBy configName tyname, PrettyClassicBy configName name, PrettyUni uni, Pretty fun, Pretty ann) => PrettyBy (PrettyConfigClassic configName) (Term tyname name uni fun ann) # 
Instance details

Defined in PlutusCore.Core.Instance.Pretty.Classic

Methods

prettyBy :: PrettyConfigClassic configName -> Term tyname name uni fun ann -> Doc ann0 #

prettyListBy :: PrettyConfigClassic configName -> [Term tyname name uni fun ann] -> Doc ann0 #

PrettyReadableBy configName (Term tyname name uni fun a) => PrettyBy (PrettyConfigReadable configName) (Program tyname name uni fun a) # 
Instance details

Defined in PlutusCore.Core.Instance.Pretty.Readable

Methods

prettyBy :: PrettyConfigReadable configName -> Program tyname name uni fun a -> Doc ann #

prettyListBy :: PrettyConfigReadable configName -> [Program tyname name uni fun a] -> Doc ann #

(PrettyReadableBy configName tyname, PrettyReadableBy configName name, PrettyUni uni, Pretty fun) => PrettyBy (PrettyConfigReadable configName) (Term tyname name uni fun a) # 
Instance details

Defined in PlutusCore.Core.Instance.Pretty.Readable

Methods

prettyBy :: PrettyConfigReadable configName -> Term tyname name uni fun a -> Doc ann #

prettyListBy :: PrettyConfigReadable configName -> [Term tyname name uni fun a] -> Doc ann #

type family HasPrettyDefaults config :: Bool #

Determines whether a pretty-printing config allows default pretty-printing for types that support it. I.e. it's possible to create a new config and get access to pretty-printing for all types supporting default pretty-printing just by providing the right type instance. Example:

>>> data DefCfg = DefCfg
>>> type instance HasPrettyDefaults DefCfg = 'True
>>> prettyBy DefCfg (['a', 'b', 'c'], (1 :: Int), Just True)
(abc, 1, True)

The set of types supporting default pretty-printing is determined by the prettyprinter library: whatever there has a Pretty instance also supports default pretty-printing in this library and the behavior of pretty x and prettyBy config_with_defaults x must be identical when x is one of such types.

It is possible to override default pretty-printing. For this you need to specify that HasPrettyDefaults is 'False for your config and then define a NonDefaultPrettyBy config instance for each of the types supporting default pretty-printing that you want to pretty-print values of. Note that once HasPrettyDefaults is specified to be 'False, all defaults are lost for your config, so you can't override default pretty-printing for one type and keep the defaults for all the others. I.e. if you have

>>> data NonDefCfg = NonDefCfg
>>> type instance HasPrettyDefaults NonDefCfg = 'False

then you have no defaults available and an attempt to pretty-print a value of a type supporting default pretty-printing

prettyBy NonDefCfg True

results in a type error:

• No instance for (NonDefaultPrettyBy NonDef Bool)
     arising from a use of ‘prettyBy’

As the error suggests you need to provide a NonDefaultPrettyBy instance explicitly:

>>> instance NonDefaultPrettyBy NonDefCfg Bool where nonDefaultPrettyBy _ b = if b then "t" else "f"
>>> prettyBy NonDefCfg True
t

It is also possible not to provide any implementation for nonDefaultPrettyBy, in which case it defaults to being the default pretty-printing for the given type. This can be useful to recover default pretty-printing for types pretty-printing of which you don't want to override:

>>> instance NonDefaultPrettyBy NonDefCfg Int
>>> prettyBy NonDefCfg (42 :: Int)
42

Look into test/NonDefault.hs for an extended example.

We could give the user more fine-grained control over what defaults to override instead of requiring to explicitly provide all the instances whenever there's a need to override any default behavior, but that would complicate the library even more, so we opted for not doing that at the moment.

Note that you can always override default behavior by wrapping a type in newtype and providing a PrettyBy config_name instance for that newtype.

Also note that if you want to extend the set of types supporting default pretty-printing it's not enough to provide a Pretty instance for your type (such logic is hardly expressible in present day Haskell). Read the docs of DefaultPrettyBy for how to extend the set of types supporting default pretty-printing.

Instances

Instances details
type HasPrettyDefaults PrettyConfigName # 
Instance details

Defined in PlutusCore.Pretty.ConfigName

type HasPrettyDefaults PrettyConfigName = 'NonStuckHasPrettyDefaults config) config #

PrettyDefaultBy config a is the same thing as PrettyBy config a, when a supports default pretty-printing. Thus PrettyDefaultBy config a and PrettyBy config a are interchangeable constraints for such types, but the latter throws an annoying "this makes type inference for inner bindings fragile" warning, unlike the former. PrettyDefaultBy config a reads as "a supports default pretty-printing and can be pretty-printed via config in either default or non-default manner depending on whether config supports default pretty-printing".

newtype PrettyAny a #

A newtype wrapper around a provided for the purporse of defining PrettyBy instances handling any a. For example you can wrap values with the PrettyAny constructor directly like in this last line of

>>> data ViaShow = ViaShow
>>> instance Show a => PrettyBy ViaShow (PrettyAny a) where prettyBy ViaShow = pretty . show . unPrettyAny
>>> prettyBy ViaShow $ PrettyAny True
True

or you can use the type to via-derive instances:

>>> data D = D deriving stock (Show)
>>> deriving via PrettyAny D instance PrettyBy ViaShow D
>>> prettyBy ViaShow D
D

One important use case is handling sum-type configs. For example having two configs you can define their sum and derive PrettyBy for the unified config in terms of its components:

>>> data UpperCase = UpperCase
>>> data LowerCase = LowerCase
>>> data Case = CaseUpperCase UpperCase | CaseLowerCase LowerCase
>>> instance (PrettyBy UpperCase a, PrettyBy LowerCase a) => PrettyBy Case (PrettyAny a) where prettyBy (CaseUpperCase upper) = prettyBy upper . unPrettyAny; prettyBy (CaseLowerCase lower) = prettyBy lower . unPrettyAny

Then having a data type implementing both PrettyBy UpperCase and PrettyBy LowerCase you can derive PrettyBy Case for that data type:

>>> data D = D
>>> instance PrettyBy UpperCase D where prettyBy UpperCase D = "D"
>>> instance PrettyBy LowerCase D where prettyBy LowerCase D = "d"
>>> deriving via PrettyAny D instance PrettyBy Case D
>>> prettyBy UpperCase D
D
>>> prettyBy LowerCase D
d

Look into test/Universal.hs for an extended example.

Constructors

PrettyAny 

Fields

Instances

Instances details
Text #

class Default a where #

Minimal complete definition

Nothing

Methods

def :: a #

Instances

Instances details
Default All 
Instance details

Defined in Data.Default.Internal

Methods

def :: All #

Default Any 
Instance details

Defined in Data.Default.Internal

Methods

def :: Any #

Default CBool 
Instance details

Defined in Data.Default.Internal

Methods

def :: CBool #

Default CClock 
Instance details

Defined in Data.Default.Internal

Methods

def :: CClock #

Default CDouble 
Instance details

Defined in Data.Default.Internal

Methods

def :: CDouble #

Default CFloat 
Instance details

Defined in Data.Default.Internal

Methods

def :: CFloat #

Default CInt 
Instance details

Defined in Data.Default.Internal

Methods

def :: CInt #

Default CIntMax 
Instance details

Defined in Data.Default.Internal

Methods

def :: CIntMax #

Default CIntPtr 
Instance details

Defined in Data.Default.Internal

Methods

def :: CIntPtr #

Default CLLong 
Instance details

Defined in Data.Default.Internal

Methods

def :: CLLong #

Default CLong 
Instance details

Defined in Data.Default.Internal

Methods

def :: CLong #

Default CPtrdiff 
Instance details

Defined in Data.Default.Internal

Methods

def :: CPtrdiff #

Default CSUSeconds 
Instance details

Defined in Data.Default.Internal

Methods

def :: CSUSeconds #

Default CShort 
Instance details

Defined in Data.Default.Internal

Methods

def :: CShort #

Default CSigAtomic 
Instance details

Defined in Data.Default.Internal

Methods

def :: CSigAtomic #

Default CSize 
Instance details

Defined in Data.Default.Internal

Methods

def :: CSize #

Default CTime 
Instance details

Defined in Data.Default.Internal

Methods

def :: CTime #

Default CUInt 
Instance details

Defined in Data.Default.Internal

Methods

def :: CUInt #

Default CUIntMax 
Instance details

Defined in Data.Default.Internal

Methods

def :: CUIntMax #

Default CUIntPtr 
Instance details

Defined in Data.Default.Internal

Methods

def :: CUIntPtr #

Default CULLong 
Instance details

Defined in Data.Default.Internal

Methods

def :: CULLong #

Default CULong 
Instance details

Defined in Data.Default.Internal

Methods

def :: CULong #

Default CUSeconds 
Instance details

Defined in Data.Default.Internal

Methods

def :: CUSeconds #

Default CUShort 
Instance details

Defined in Data.Default.Internal

Methods

def :: CUShort #

Default IntPtr 
Instance details

Defined in Data.Default.Internal

Methods

def :: IntPtr #

Default WordPtr 
Instance details

Defined in Data.Default.Internal

Methods

def :: WordPtr #

Default Int16 
Instance details

Defined in Data.Default.Internal

Methods

def :: Int16 #

Default Int32 
Instance details

Defined in Data.Default.Internal

Methods

def :: Int32 #

Default Int64 
Instance details

Defined in Data.Default.Internal

Methods

def :: Int64 #

Default Int8 
Instance details

Defined in Data.Default.Internal

Methods

def :: Int8 #

Default Word16 
Instance details

Defined in Data.Default.Internal

Methods

def :: Word16 #

Default Word32 
Instance details

Defined in Data.Default.Internal

Methods

def :: Word32 #

Default Word64 
Instance details

Defined in Data.Default.Internal

Methods

def :: Word64 #

Default Word8 
Instance details

Defined in Data.Default.Internal

Methods

def :: Word8 #

Default IntSet 
Instance details

Defined in Data.Default.Internal

Methods

def :: IntSet #

Default Ordering 
Instance details

Defined in Data.Default.Internal

Methods

def :: Ordering #

Default Ann # 
Instance details

Defined in PlutusCore.Annotation

Methods

def :: Ann #

Default ModelFiveArguments # 
Instance details

Defined in PlutusCore.Evaluation.Machine.CostingFun.Core

Methods

def :: ModelFiveArguments #

Default ModelFourArguments # 
Instance details

Defined in PlutusCore.Evaluation.Machine.CostingFun.Core

Methods

def :: ModelFourArguments #

Default ModelOneArgument # 
Instance details

Defined in PlutusCore.Evaluation.Machine.CostingFun.Core

Methods

def :: ModelOneArgument #

Default ModelSixArguments # 
Instance details

Defined in PlutusCore.Evaluation.Machine.CostingFun.Core

Methods

def :: ModelSixArguments #

Default ModelThreeArguments # 
Instance details

Defined in PlutusCore.Evaluation.Machine.CostingFun.Core

Methods

def :: ModelThreeArguments #

Default ModelTwoArguments # 
Instance details

Defined in PlutusCore.Evaluation.Machine.CostingFun.Core

Methods

def :: ModelTwoArguments #

Default ShowKinds # 
Instance details

Defined in PlutusCore.Pretty.Readable

Methods

def :: ShowKinds #

Default Integer 
Instance details

Defined in Data.Default.Internal

Methods

def :: Integer #

Default () 
Instance details

Defined in Data.Default.Internal

Methods

def :: () #

Default Bool 
Instance details

Defined in Data.Default.Internal

Methods

def :: Bool #

Default Double 
Instance details

Defined in Data.Default.Internal

Methods

def :: Double #

Default Float 
Instance details

Defined in Data.Default.Internal

Methods

def :: Float #

Default Int 
Instance details

Defined in Data.Default.Internal

Methods

def :: Int #

Default Word 
Instance details

Defined in Data.Default.Internal

Methods

def :: Word #

(Default a, RealFloat a) => Default (Complex a) 
Instance details

Defined in Data.Default.Internal

Methods

def :: Complex a #

Default a => Default (Identity a) 
Instance details

Defined in Data.Default.Internal

Methods

def :: Identity a #

Default (First a) 
Instance details

Defined in Data.Default.Internal

Methods

def :: First a #

Default (Last a) 
Instance details

Defined in Data.Default.Internal

Methods

def :: Last a #

Default a => Default (Dual a) 
Instance details

Defined in Data.Default.Internal

Methods

def :: Dual a #

Default (Endo a) 
Instance details

Defined in Data.Default.Internal

Methods

def :: Endo a #

Num a => Default (Product a) 
Instance details

Defined in Data.Default.Internal

Methods

def :: Product a #

Num a => Default (Sum a) 
Instance details

Defined in Data.Default.Internal

Methods

def :: Sum a #

Default (ConstPtr a) 
Instance details

Defined in Data.Default.Internal

Methods

def :: ConstPtr a #

Default (FunPtr a) 
Instance details

Defined in Data.Default.Internal

Methods

def :: FunPtr a #

Default (Ptr a) 
Instance details

Defined in Data.Default.Internal

Methods

def :: Ptr a #

Integral a => Default (Ratio a) 
Instance details

Defined in Data.Default.Internal

Methods

def :: Ratio a #

Default (IntMap v) 
Instance details

Defined in Data.Default.Internal

Methods

def :: IntMap v #

Default (Seq a) 
Instance details

Defined in Data.Default.Internal

Methods

def :: Seq a #

Default (Set v) 
Instance details

Defined in Data.Default.Internal

Methods

def :: Set v #

Default a => Default (Tree a) 
Instance details

Defined in Data.Default.Internal

Methods

def :: Tree a #

CaseBuiltin uni => Default (CaserBuiltin uni) # 
Instance details

Defined in PlutusCore.Builtin.Case

Methods

def :: CaserBuiltin uni #

(Default (BuiltinSemanticsVariant fun1), Default (BuiltinSemanticsVariant fun2)) => Default (BuiltinSemanticsVariant (Either fun1 fun2)) # 
Instance details

Defined in PlutusCore.Examples.Builtins

Methods

def :: BuiltinSemanticsVariant (Either fun1 fun2) #

Default (BuiltinSemanticsVariant DefaultFun) # 
Instance details

Defined in PlutusCore.Default.Builtins

Methods

def :: BuiltinSemanticsVariant DefaultFun #

Default (BuiltinSemanticsVariant ExtensionFun) # 
Instance details

Defined in PlutusCore.Examples.Builtins

Methods

def :: BuiltinSemanticsVariant ExtensionFun #

AllArgumentModels Default f => Default (BuiltinCostModelBase f) # 
Instance details

Defined in PlutusCore.Evaluation.Machine.BuiltinCostModel

Methods

def :: BuiltinCostModelBase f #

Default model => Default (CostingFun model) # 
Instance details

Defined in PlutusCore.Evaluation.Machine.CostingFun.Core

Methods

def :: CostingFun model #

Default (Maybe a) 
Instance details

Defined in Data.Default.Internal

Methods

def :: Maybe a #

Default a => Default (a) 
Instance details

Defined in Data.Default.Internal

Methods

def :: (a) #

Default [a] 
Instance details

Defined in Data.Default.Internal

Methods

def :: [a] #

HasResolution a => Default (Fixed a) 
Instance details

Defined in Data.Default.Internal

Methods

def :: Fixed a #

Default (Proxy a) 
Instance details

Defined in Data.Default.Internal

Methods

def :: Proxy a #

Default (Map k v) 
Instance details

Defined in Data.Default.Internal

Methods

def :: Map k v #

Default (InlineHints name a) # 
Instance details

Defined in PlutusCore.Annotation

Methods

def :: InlineHints name a #

(Default a1, Default a2) => Default (a1, a2) 
Instance details

Defined in Data.Default.Internal

Methods

def :: (a1, a2) #

Default a => Default (Const a b) 
Instance details

Defined in Data.Default.Internal

Methods

def :: Const a b #

(Default a1, Default a2, Default a3) => Default (a1, a2, a3) 
Instance details

Defined in Data.Default.Internal

Methods

def :: (a1, a2, a3) #

(Default a1, Default a2, Default a3, Default a4) => Default (a1, a2, a3, a4) 
Instance details

Defined in Data.Default.Internal

Methods

def :: (a1, a2, a3, a4) #

(Default a1, Default a2, Default a3, Default a4, Default a5) => Default (a1, a2, a3, a4, a5) 
Instance details

Defined in Data.Default.Internal

Methods

def :: (a1, a2, a3, a4, a5) #

(Default a1, Default a2, Default a3, Default a4, Default a5, Default a6) => Default (a1, a2, a3, a4, a5, a6) 
Instance details

Defined in Data.Default.Internal

Methods

def :: (a1, a2, a3, a4, a5, a6) #

(Default a1, Default a2, Default a3, Default a4, Default a5, Default a6, Default a7) => Default (a1, a2, a3, a4, a5, a6, a7) 
Instance details

Defined in Data.Default.Internal

Methods

def :: (a1, a2, a3, a4, a5, a6, a7) #

(Default a1, Default a2, Default a3, Default a4, Default a5, Default a6, Default a7, Default a8) => Default (a1, a2, a3, a4, a5, a6, a7, a8) 
Instance details

Defined in Data.Default.Internal

Methods

def :: (a1, a2, a3, a4, a5, a6, a7, a8) #

(Default a1, Default a2, Default a3, Default a4, Default a5, Default a6, Default a7, Default a8, Default a9) => Default (a1, a2, a3, a4, a5, a6, a7, a8, a9) 
Instance details

Defined in Data.Default.Internal

Methods

def :: (a1, a2, a3, a4, a5, a6, a7, a8, a9) #

(Default a1, Default a2, Default a3, Default a4, Default a5, Default a6, Default a7, Default a8, Default a9, Default a10) => Default (a1, a2, a3, a4, a5, a6, a7, a8, a9, a10) 
Instance details

Defined in Data.Default.Internal

Methods

def :: (a1, a2, a3, a4, a5, a6, a7, a8, a9, a10) #

(Default a1, Default a2, Default a3, Default a4, Default a5, Default a6, Default a7, Default a8, Default a9, Default a10, Default a11) => Default (a1, a2, a3, a4, a5, a6, a7, a8, a9, a10, a11) 
Instance details

Defined in Data.Default.Internal

Methods

def :: (a1, a2, a3, a4, a5, a6, a7, a8, a9, a10, a11) #

(Default a1, Default a2, Default a3, Default a4, Default a5, Default a6, Default a7, Default a8, Default a9, Default a10, Default a11, Default a12) => Default (a1, a2, a3, a4, a5, a6, a7, a8, a9, a10, a11, a12) 
Instance details

Defined in Data.Default.Internal

Methods

def :: (a1, a2, a3, a4, a5, a6, a7, a8, a9, a10, a11, a12) #

(Default a1, Default a2, Default a3, Default a4, Default a5, Default a6, Default a7, Default a8, Default a9, Default a10, Default a11, Default a12, Default a13) => Default (a1, a2, a3, a4, a5, a6, a7, a8, a9, a10, a11, a12, a13) 
Instance details

Defined in Data.Default.Internal

Methods

def :: (a1, a2, a3, a4, a5, a6, a7, a8, a9, a10, a11, a12, a13) #

(Default a1, Default a2, Default a3, Default a4, Default a5, Default a6, Default a7, Default a8, Default a9, Default a10, Default a11, Default a12, Default a13, Default a14) => Default (a1, a2, a3, a4, a5, a6, a7, a8, a9, a10, a11, a12, a13, a14) 
Instance details

Defined in Data.Default.Internal

Methods

def :: (a1, a2, a3, a4, a5, a6, a7, a8, a9, a10, a11, a12, a13, a14) #

(Default a1, Default a2, Default a3, Default a4, Default a5, Default a6, Default a7, Default a8, Default a9, Default a10, Default a11, Default a12, Default a13, Default a14, Default a15) => Default (a1, a2, a3, a4, a5, a6, a7, a8, a9, a10, a11, a12, a13, a14, a15) 
Instance details

Defined in Data.Default.Internal

Methods

def :: (a1, a2, a3, a4, a5, a6, a7, a8, a9, a10, a11, a12, a13, a14, a15) #

(Default a1, Default a2, Default a3, Default a4, Default a5, Default a6, Default a7, Default a8, Default a9, Default a10, Default a11, Default a12, Default a13, Default a14, Default a15, Default a16) => Default (a1, a2, a3, a4, a5, a6, a7, a8, a9, a10, a11, a12, a13, a14, a15, a16) 
Instance details

Defined in Data.Default.Internal

Methods

def :: (a1, a2, a3, a4, a5, a6, a7, a8, a9, a10, a11, a12, a13, a14, a15, a16) #

(Default a1, Default a2, Default a3, Default a4, Default a5, Default a6, Default a7, Default a8, Default a9, Default a10, Default a11, Default a12, Default a13, Default a14, Default a15, Default a16, Default a17) => Default (a1, a2, a3, a4, a5, a6, a7, a8, a9, a10, a11, a12, a13, a14, a15, a16, a17) 
Instance details

Defined in Data.Default.Internal

Methods

def :: (a1, a2, a3, a4, a5, a6, a7, a8, a9, a10, a11, a12, a13, a14, a15, a16, a17) #

(Default a1, Default a2, Default a3, Default a4, Default a5, Default a6, Default a7, Default a8, Default a9, Default a10, Default a11, Default a12, Default a13, Default a14, Default a15, Default a16, Default a17, Default a18) => Default (a1, a2, a3, a4, a5, a6, a7, a8, a9, a10, a11, a12, a13, a14, a15, a16, a17, a18) 
Instance details

Defined in Data.Default.Internal

Methods

def :: (a1, a2, a3, a4, a5, a6, a7, a8, a9, a10, a11, a12, a13, a14, a15, a16, a17, a18) #

(Default a1, Default a2, Default a3, Default a4, Default a5, Default a6, Default a7, Default a8, Default a9, Default a10, Default a11, Default a12, Default a13, Default a14, Default a15, Default a16, Default a17, Default a18, Default a19) => Default (a1, a2, a3, a4, a5, a6, a7, a8, a9, a10, a11, a12, a13, a14, a15, a16, a17, a18, a19) 
Instance details

Defined in Data.Default.Internal

Methods

def :: (a1, a2, a3, a4, a5, a6, a7, a8, a9, a10, a11, a12, a13, a14, a15, a16, a17, a18, a19) #

(Default a1, Default a2, Default a3, Default a4, Default a5, Default a6, Default a7, Default a8, Default a9, Default a10, Default a11, Default a12, Default a13, Default a14, Default a15, Default a16, Default a17, Default a18, Default a19, Default a20) => Default (a1, a2, a3, a4, a5, a6, a7, a8, a9, a10, a11, a12, a13, a14, a15, a16, a17, a18, a19, a20) 
Instance details

Defined in Data.Default.Internal

Methods

def :: (a1, a2, a3, a4, a5, a6, a7, a8, a9, a10, a11, a12, a13, a14, a15, a16, a17, a18, a19, a20) #

(Default a1, Default a2, Default a3, Default a4, Default a5, Default a6, Default a7, Default a8, Default a9, Default a10, Default a11, Default a12, Default a13, Default a14, Default a15, Default a16, Default a17, Default a18, Default a19, Default a20, Default a21) => Default (a1, a2, a3, a4, a5, a6, a7, a8, a9, a10, a11, a12, a13, a14, a15, a16, a17, a18, a19, a20, a21) 
Instance details

Defined in Data.Default.Internal

Methods

def :: (a1, a2, a3, a4, a5, a6, a7, a8, a9, a10, a11, a12, a13, a14, a15, a16, a17, a18, a19, a20, a21) #

(Default a1, Default a2, Default a3, Default a4, Default a5, Default a6, Default a7, Default a8, Default a9, Default a10, Default a11, Default a12, Default a13, Default a14, Default a15, Default a16, Default a17, Default a18, Default a19, Default a20, Default a21, Default a22) => Default (a1, a2, a3, a4, a5, a6, a7, a8, a9, a10, a11, a12, a13, a14, a15, a16, a17, a18, a19, a20, a21, a22) 
Instance details

Defined in Data.Default.Internal

Methods

def :: (a1, a2, a3, a4, a5, a6, a7, a8, a9, a10, a11, a12, a13, a14, a15, a16, a17, a18, a19, a20, a21, a22) #

(Default a1, Default a2, Default a3, Default a4, Default a5, Default a6, Default a7, Default a8, Default a9, Default a10, Default a11, Default a12, Default a13, Default a14, Default a15, Default a16, Default a17, Default a18, Default a19, Default a20, Default a21, Default a22, Default a23) => Default (a1, a2, a3, a4, a5, a6, a7, a8, a9, a10, a11, a12, a13, a14, a15, a16, a17, a18, a19, a20, a21, a22, a23) 
Instance details

Defined in Data.Default.Internal

Methods

def :: (a1, a2, a3, a4, a5, a6, a7, a8, a9, a10, a11, a12, a13, a14, a15, a16, a17, a18, a19, a20, a21, a22, a23) #

(Default a1, Default a2, Default a3, Default a4, Default a5, Default a6, Default a7, Default a8, Default a9, Default a10, Default a11, Default a12, Default a13, Default a14, Default a15, Default a16, Default a17, Default a18, Default a19, Default a20, Default a21, Default a22, Default a23, Default a24) => Default (a1, a2, a3, a4, a5, a6, a7, a8, a9, a10, a11, a12, a13, a14, a15, a16, a17, a18, a19, a20, a21, a22, a23, a24) 
Instance details

Defined in Data.Default.Internal

Methods

def :: (a1, a2, a3, a4, a5, a6, a7, a8, a9, a10, a11, a12, a13, a14, a15, a16, a17, a18, a19, a20, a21, a22, a23, a24) #

(Default a1, Default a2, Default a3, Default a4, Default a5, Default a6, Default a7, Default a8, Default a9, Default a10, Default a11, Default a12, Default a13, Default a14, Default a15, Default a16, Default a17, Default a18, Default a19, Default a20, Default a21, Default a22, Default a23, Default a24, Default a25) => Default (a1, a2, a3, a4, a5, a6, a7, a8, a9, a10, a11, a12, a13, a14, a15, a16, a17, a18, a19, a20, a21, a22, a23, a24, a25) 
Instance details

Defined in Data.Default.Internal

Methods

def :: (a1, a2, a3, a4, a5, a6, a7, a8, a9, a10, a11, a12, a13, a14, a15, a16, a17, a18, a19, a20, a21, a22, a23, a24, a25) #

(Default a1, Default a2, Default a3, Default a4, Default a5, Default a6, Default a7, Default a8, Default a9, Default a10, Default a11, Default a12, Default a13, Default a14, Default a15, Default a16, Default a17, Default a18, Default a19, Default a20, Default a21, Default a22, Default a23, Default a24, Default a25, Default a26) => Default (a1, a2, a3, a4, a5, a6, a7, a8, a9, a10, a11, a12, a13, a14, a15, a16, a17, a18, a19, a20, a21, a22, a23, a24, a25, a26) 
Instance details

Defined in Data.Default.Internal

Methods

def :: (a1, a2, a3, a4, a5, a6, a7, a8, a9, a10, a11, a12, a13, a14, a15, a16, a17, a18, a19, a20, a21, a22, a23, a24, a25, a26) #

(Default a1, Default a2, Default a3, Default a4, Default a5, Default a6, Default a7, Default a8, Default a9, Default a10, Default a11, Default a12, Default a13, Default a14, Default a15, Default a16, Default a17, Default a18, Default a19, Default a20, Default a21, Default a22, Default a23, Default a24, Default a25, Default a26, Default a27) => Default (a1, a2, a3, a4, a5, a6, a7, a8, a9, a10, a11, a12, a13, a14, a15, a16, a17, a18, a19, a20, a21, a22, a23, a24, a25, a26, a27) 
Instance details

Defined in Data.Default.Internal

Methods

def :: (a1, a2, a3, a4, a5, a6, a7, a8, a9, a10, a11, a12, a13, a14, a15, a16, a17, a18, a19, a20, a21, a22, a23, a24, a25, a26, a27) #

(Default a1, Default a2, Default a3, Default a4, Default a5, Default a6, Default a7, Default a8, Default a9, Default a10, Default a11, Default a12, Default a13, Default a14, Default a15, Default a16, Default a17, Default a18, Default a19, Default a20, Default a21, Default a22, Default a23, Default a24, Default a25, Default a26, Default a27, Default a28) => Default (a1, a2, a3, a4, a5, a6, a7, a8, a9, a10, a11, a12, a13, a14, a15, a16, a17, a18, a19, a20, a21, a22, a23, a24, a25, a26, a27, a28) 
Instance details

Defined in Data.Default.Internal

Methods

def :: (a1, a2, a3, a4, a5, a6, a7, a8, a9, a10, a11, a12, a13, a14, a15, a16, a17, a18, a19, a20, a21, a22, a23, a24, a25, a26, a27, a28) #

(Default a1, Default a2, Default a3, Default a4, Default a5, Default a6, Default a7, Default a8, Default a9, Default a10, Default a11, Default a12, Default a13, Default a14, Default a15, Default a16, Default a17, Default a18, Default a19, Default a20, Default a21, Default a22, Default a23, Default a24, Default a25, Default a26, Default a27, Default a28, Default a29) => Default (a1, a2, a3, a4, a5, a6, a7, a8, a9, a10, a11, a12, a13, a14, a15, a16, a17, a18, a19, a20, a21, a22, a23, a24, a25, a26, a27, a28, a29) 
Instance details

Defined in Data.Default.Internal

Methods

def :: (a1, a2, a3, a4, a5, a6, a7, a8, a9, a10, a11, a12, a13, a14, a15, a16, a17, a18, a19, a20, a21, a22, a23, a24, a25, a26, a27, a28, a29) #

(Default a1, Default a2, Default a3, Default a4, Default a5, Default a6, Default a7, Default a8, Default a9, Default a10, Default a11, Default a12, Default a13, Default a14, Default a15, Default a16, Default a17, Default a18, Default a19, Default a20, Default a21, Default a22, Default a23, Default a24, Default a25, Default a26, Default a27, Default a28, Default a29, Default a30) => Default (a1, a2, a3, a4, a5, a6, a7, a8, a9, a10, a11, a12, a13, a14, a15, a16, a17, a18, a19, a20, a21, a22, a23, a24, a25, a26, a27, a28, a29, a30) 
Instance details

Defined in Data.Default.Internal

Methods

def :: (a1, a2, a3, a4, a5, a6, a7, a8, a9, a10, a11, a12, a13, a14, a15, a16, a17, a18, a19, a20, a21, a22, a23, a24, a25, a26, a27, a28, a29, a30) #

(Default a1, Default a2, Default a3, Default a4, Default a5, Default a6, Default a7, Default a8, Default a9, Default a10, Default a11, Default a12, Default a13, Default a14, Default a15, Default a16, Default a17, Default a18, Default a19, Default a20, Default a21, Default a22, Default a23, Default a24, Default a25, Default a26, Default a27, Default a28, Default a29, Default a30, Default a31) => Default (a1, a2, a3, a4, a5, a6, a7, a8, a9, a10, a11, a12, a13, a14, a15, a16, a17, a18, a19, a20, a21, a22, a23, a24, a25, a26, a27, a28, a29, a30, a31) 
Instance details

Defined in Data.Default.Internal

Methods

def :: (a1, a2, a3, a4, a5, a6, a7, a8, a9, a10, a11, a12, a13, a14, a15, a16, a17, a18, a19, a20, a21, a22, a23, a24, a25, a26, a27, a28, a29, a30, a31) #

Lists

zipExact :: [a] -> [b] -> Maybe [(a, b)] #

Zips two lists of the same length together, returning Nothing if they are not the same length.

allSame :: Eq a => [a] -> Bool #

distinct :: Eq a => [a] -> Bool #

unsafeFromRight :: Show e => Either e a -> a #

Similar to Maybe's fromJust. Returns the Right and errors out with the show instance of the Left.

addTheRest :: [a] -> [(a, [a])] #

Pair each element of the given list with all the other elements.

>>> addTheRest "abcd"
[('a',"bcd"),('b',"acd"),('c',"abd"),('d',"abc")]

lowerInitialChar :: DefaultPrettyBy config (Either a b) #

Default pretty-printing for the spine of Either (elements are pretty-printed the way PrettyBy config constraints specify it).

Instance details

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) #

An instance extending the set of types supporting default pretty-printing with Either.

Instance details

Methods

prettyBy :: config -> Either a b -> Doc ann #

prettyListBy :: config -> [Either a b] -> Doc ann #

(Pretty a, Pretty b) => Pretty (Either a b) # 
Instance details

Methods

pretty :: Either a b -> Doc ann #

prettyList :: [Either a b] -> Doc ann #