Module

Puppy.Runtime.Deps

Package: purescript-puppy-runtime
Repository: katsujukou/purescript-puppy-runtime

The standard-library names a generated parser uses, in one place.

Not for you: this is here so that a generated module can be written against Puppy.Runtime.* alone. Without it, every package holding a generated parser has to depend on arrays, either, maybe and tailrec on that file's behalf -- for a file its author did not write and is told not to read.

These are the same names your own code gets from Data.Maybe, Data.Either and the rest; a re-export renames nothing. Import those directly.

Re-exports from Control.Monad.Rec.Class

#MonadRec Source

class MonadRec :: (Type -> Type) -> Constraintclass (Monad m) <= MonadRec m

This type class captures those monads which support tail recursion in constant stack space.

The tailRecM function takes a step function, and applies that step function recursively until a pure value of type b is found.

Instances are provided for standard monad transformers.

For example:

loopWriter :: Int -> WriterT (Additive Int) Effect Unit
loopWriter n = tailRecM go n
  where
  go 0 = do
    traceM "Done!"
    pure (Done unit)
  go i = do
    tell $ Additive i
    pure (Loop (i - 1))

Instances

Re-exports from Data.Array

#index Source

index :: forall a. Array a -> Int -> Maybe a

This function provides a safe way to read a value at a particular index from an array.

sentence = ["Hello", "World", "!"]

index sentence 0 = Just "Hello"
index sentence 7 = Nothing

#find Source

find :: forall a. (a -> Boolean) -> Array a -> Maybe a

Find the first element for which a predicate holds.

find (contains $ Pattern "b") ["a", "bb", "b", "d"] = Just "bb"
find (contains $ Pattern "x") ["a", "bb", "b", "d"] = Nothing

#concat Source

concat :: forall a. Array (Array a) -> Array a

Flatten an array of arrays, creating a new array.

concat [[1, 2, 3], [], [4, 5, 6]] = [1, 2, 3, 4, 5, 6]

Re-exports from Data.Either

#Either Source

data Either a b

The Either type is used to represent a choice between two types of value.

A common use case for Either is error handling, where Left is used to carry an error value and Right is used to carry a success value.

Constructors

Left a
Right b

Instances

Functor (Either a)
The Functor instance allows functions to transform the contents of a Right with the <$> operator:
```
f <$> Right x == Right (f x)
```
Left values are untouched:
```
f <$> Left y == Left y
```
Generic (Either a b) _
Invariant (Either a)
Apply (Either e)
The Apply instance allows functions contained within a Right to transform a value contained within a Right using the (<*>) operator:
```
Right f <*> Right x == Right (f x)
```
Left values are left untouched:
```
Left f <*> Right x == Left f
Right f <*> Left y == Left y
```
Combining Functor's <$> with Apply's <*> can be used to transform a pure function to take Either-typed arguments so f :: a -> b -> c becomes f :: Either l a -> Either l b -> Either l c:
```
f <$> Right x <*> Right y == Right (f x y)
```
The Left-preserving behaviour of both operators means the result of an expression like the above but where any one of the values is Left means the whole result becomes Left also, taking the first Left value found:
```
f <$> Left x <*> Right y == Left x
f <$> Right x <*> Left y == Left y
f <$> Left x <*> Left y == Left x
```
Applicative (Either e)
The Applicative instance enables lifting of values into Either with the pure function:
```
pure x :: Either _ _ == Right x
```
Combining Functor's <$> with Apply's <*> and Applicative's pure can be used to pass a mixture of Either and non-Either typed values to a function that does not usually expect them, by using pure for any value that is not already Either typed:
```
f <$> Right x <*> pure y == Right (f x y)
```
Even though pure = Right it is recommended to use pure in situations like this as it allows the choice of Applicative to be changed later without having to go through and replace Right with a new constructor.
Alt (Either e)
The Alt instance allows for a choice to be made between two Either values with the <|> operator, where the first Right encountered is taken.
```
Right x <|> Right y == Right x
Left x <|> Right y == Right y
Left x <|> Left y == Left y
```

Bind (Either e)

The Bind instance allows sequencing of Either values and functions that return an Either by using the >>= operator:

Left x >>= f = Left x
Right x >>= f = f x

Either's "do notation" can be understood to work like this:

x :: forall e a. Either e a
x = --

y :: forall e b. Either e b
y = --

foo :: forall e a. (a -> b -> c) -> Either e c
foo f = do
  x' <- x
  y' <- y
  pure (f x' y')

...which is equivalent to...

x >>= (\x' -> y >>= (\y' -> pure (f x' y')))

...and is the same as writing...

foo :: forall e a. (a -> b -> c) -> Either e c
foo f = case x of
  Left e ->
    Left e
  Right x -> case y of
    Left e ->
      Left e
    Right y ->
      Right (f x y)

Monad (Either e)
The Monad instance guarantees that there are both Applicative and Bind instances for Either.
Extend (Either e)
The Extend instance allows sequencing of Either values and functions that accept an Either and return a non-Either result using the <<= operator.
```
f <<= Left x = Left x
f <<= Right x = Right (f (Right x))
```
(Show a, Show b) => Show (Either a b)
The Show instance allows Either values to be rendered as a string with show whenever there is an Show instance for both type the Either can contain.
(Eq a, Eq b) => Eq (Either a b)
The Eq instance allows Either values to be checked for equality with == and inequality with /= whenever there is an Eq instance for both types the Either can contain.
(Eq a) => Eq1 (Either a)
(Ord a, Ord b) => Ord (Either a b)
The Ord instance allows Either values to be compared with compare, >, >=, < and <= whenever there is an Ord instance for both types the Either can contain.

Any Left value is considered to be less than a Right value.
(Ord a) => Ord1 (Either a)
(Bounded a, Bounded b) => Bounded (Either a b)
(Semigroup b) => Semigroup (Either a b)

Re-exports from Data.Maybe

#Maybe Source

data Maybe a

The Maybe type is used to represent optional values and can be seen as something like a type-safe null, where Nothing is null and Just x is the non-null value x.

Constructors

Nothing
Just a

Instances

Functor Maybe
The Functor instance allows functions to transform the contents of a Just with the <$> operator:
```
f <$> Just x == Just (f x)
```
Nothing values are left untouched:
```
f <$> Nothing == Nothing
```
Apply Maybe
The Apply instance allows functions contained within a Just to transform a value contained within a Just using the apply operator:
```
Just f <*> Just x == Just (f x)
```
Nothing values are left untouched:
```
Just f <*> Nothing == Nothing
Nothing <*> Just x == Nothing
```
Combining Functor's <$> with Apply's <*> can be used transform a pure function to take Maybe-typed arguments so f :: a -> b -> c becomes f :: Maybe a -> Maybe b -> Maybe c:
```
f <$> Just x <*> Just y == Just (f x y)
```
The Nothing-preserving behaviour of both operators means the result of an expression like the above but where any one of the values is Nothing means the whole result becomes Nothing also:
```
f <$> Nothing <*> Just y == Nothing
f <$> Just x <*> Nothing == Nothing
f <$> Nothing <*> Nothing == Nothing
```
Applicative Maybe
The Applicative instance enables lifting of values into Maybe with the pure function:
```
pure x :: Maybe _ == Just x
```
Combining Functor's <$> with Apply's <*> and Applicative's pure can be used to pass a mixture of Maybe and non-Maybe typed values to a function that does not usually expect them, by using pure for any value that is not already Maybe typed:
```
f <$> Just x <*> pure y == Just (f x y)
```
Even though pure = Just it is recommended to use pure in situations like this as it allows the choice of Applicative to be changed later without having to go through and replace Just with a new constructor.
Alt Maybe
The Alt instance allows for a choice to be made between two Maybe values with the <|> operator, where the first Just encountered is taken.
```
Just x <|> Just y == Just x
Nothing <|> Just y == Just y
Nothing <|> Nothing == Nothing
```
Plus Maybe
The Plus instance provides a default Maybe value:
```
empty :: Maybe _ == Nothing
```
Alternative Maybe
The Alternative instance guarantees that there are both Applicative and Plus instances for Maybe.
Bind Maybe
The Bind instance allows sequencing of Maybe values and functions that return a Maybe by using the >>= operator:
```
Just x >>= f = f x
Nothing >>= f = Nothing
```

Monad Maybe

The Monad instance guarantees that there are both Applicative and Bind instances for Maybe. This also enables the do syntactic sugar:

do
  x' <- x
  y' <- y
  pure (f x' y')

Which is equivalent to:

x >>= (\x' -> y >>= (\y' -> pure (f x' y')))

Which is equivalent to:

case x of
  Nothing -> Nothing
  Just x' -> case y of
    Nothing -> Nothing
    Just y' -> Just (f x' y')

Extend Maybe
The Extend instance allows sequencing of Maybe values and functions that accept a Maybe a and return a non-Maybe result using the <<= operator.
```
f <<= Nothing = Nothing
f <<= x = Just (f x)
```
Invariant Maybe
(Semigroup a) => Semigroup (Maybe a)
The Semigroup instance enables use of the operator <> on Maybe values whenever there is a Semigroup instance for the type the Maybe contains. The exact behaviour of <> depends on the "inner" Semigroup instance, but generally captures the notion of appending or combining things.
```
Just x <> Just y = Just (x <> y)
Just x <> Nothing = Just x
Nothing <> Just y = Just y
Nothing <> Nothing = Nothing
```
(Semigroup a) => Monoid (Maybe a)
(Semiring a) => Semiring (Maybe a)
(Eq a) => Eq (Maybe a)
The Eq instance allows Maybe values to be checked for equality with == and inequality with /= whenever there is an Eq instance for the type the Maybe contains.
Eq1 Maybe
(Ord a) => Ord (Maybe a)
The Ord instance allows Maybe values to be compared with compare, >, >=, < and <= whenever there is an Ord instance for the type the Maybe contains.

Nothing is considered to be less than any Just value.
Ord1 Maybe
(Bounded a) => Bounded (Maybe a)
(Show a) => Show (Maybe a)
The Show instance allows Maybe values to be rendered as a string with show whenever there is an Show instance for the type the Maybe contains.
Generic (Maybe a) _

#fromMaybe Source

fromMaybe :: forall a. a -> Maybe a -> a

Takes a default value, and a Maybe value. If the Maybe value is Nothing the default value is returned, otherwise the value inside the Just is returned.

fromMaybe x Nothing == x
fromMaybe x (Just y) == y

Modules: Puppy.Runtime; Puppy.Runtime.Deps; Puppy.Runtime.Driver; Puppy.Runtime.Source; Puppy.Runtime.Value