plutus-core-0.1.0.0: Language library for Plutus Core

PlutusPrelude

Synopsis

# Reexports from base

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

& 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 Source #

Fanout: send the input to both argument arrows and combine their output.

The default definition may be overridden with a more efficient version if desired.

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

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] Source # List of elements of a structure, from left to right. Since: base-4.8.0.0 bool :: a -> a -> Bool -> a Source # Case analysis for the Bool type. bool x y p evaluates to x when p is False, and evaluates to y when p is True. This is equivalent to if p then y else x; that is, one can think of it as an if-then-else construct with its arguments reordered. #### Examples Expand Basic usage: >>> bool "foo" "bar" True "bar" >>> bool "foo" "bar" False "foo"  Confirm that bool x y p and if p then y else x are equivalent: >>> let p = True; x = "bar"; y = "foo" >>> bool x y p == if p then y else x True >>> let p = False >>> bool x y p == if p then y else x True  Since: base-4.7.0.0 first :: Bifunctor p => (a -> b) -> p a c -> p b c Source # 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 Source # 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 Source # 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) 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 Source # 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 Source # The fromMaybe function takes a default value and and Maybe value. If the Maybe is Nothing, it returns the default values; 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 () Source # 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 Source # Left-associative fold of a structure but with strict application of the operator. This ensures that each step of the fold is forced to weak head normal form before being applied, avoiding the collection of thunks that would otherwise occur. This is often what you want to strictly reduce a finite list to a single, monolithic result (e.g. length). For a general Foldable structure this should be semantically identical to, foldl' f z = foldl' f z . toList Since: base-4.6.0.0 fold :: (Foldable t, Monoid m) => t m -> m Source # Combine the elements of a structure using a monoid. for :: (Traversable t, Applicative f) => t a -> (a -> f b) -> f (t b) Source # 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 Source # Throw an exception. Exceptions may be thrown from purely functional code, but may only be caught within the IO monad. join :: Monad m => m (m a) -> m a Source # The join function is the conventional monad join operator. It is used to remove one level of monadic structure, projecting its bound argument into the outer level. 'join 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 Source # 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 Source # 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 Source #

Flipped version of <$. Using ApplicativeDo: 'as$> b' can be understood as the do expression

do as
pure b


with an inferred Functor constraint.

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

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

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 void :: Functor f => f a -> f () Source # void value discards or ignores the result of evaluation, such as the return value of an IO action. Using ApplicativeDo: 'void as' can be understood as the do expression do as pure ()  with an inferred Functor constraint. #### 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 Source #

Makes an effectful function ignore its result value and return its input value.

coerce :: forall (k :: RuntimeRep) (a :: TYPE k) (b :: TYPE k). Coercible a b => a -> b Source #

The function coerce allows you to safely convert between values of types that have the same representation with no run-time overhead. In the simplest case you can use it instead of a newtype constructor, to go from the newtype's concrete type to the abstract type. But it also works in more complicated settings, e.g. converting a list of newtypes to a list of concrete types.

This function is runtime-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.

class Generic a Source #

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

#### Instances

Instances details