dovin-0.1.0.1: A proof assistant for Magic: The Gathering puzzles.

Dovin.Prelude

Description

Re-exports common internal imports. Not recommended for external use.

Synopsis

# Documentation

at :: At m => Index m -> Lens' m (Maybe (IxValue m)) #

>>> Map.fromList [(1,"world")] ^.at 1
Just "world"

>>> at 1 ?~ "hello" $Map.empty fromList [(1,"hello")]  Note: Map-like containers form a reasonable instance, but not Array-like ones, where you cannot satisfy the Lens laws. non :: Eq a => a -> Iso' (Maybe a) a # If v is an element of a type a, and a' is a sans the element v, then non v is an isomorphism from Maybe a' to a. non ≡ non' . only  Keep in mind this is only a real isomorphism if you treat the domain as being Maybe (a sans v). This is practically quite useful when you want to have a Map where all the entries should have non-zero values. >>> Map.fromList [("hello",1)] & at "hello" . non 0 +~ 2 fromList [("hello",3)]  >>> Map.fromList [("hello",1)] & at "hello" . non 0 -~ 1 fromList []  >>> Map.fromList [("hello",1)] ^. at "hello" . non 0 1  >>> Map.fromList [] ^. at "hello" . non 0 0  This combinator is also particularly useful when working with nested maps. e.g. When you want to create the nested Map when it is missing: >>> Map.empty & at "hello" . non Map.empty . at "world" ?~ "!!!" fromList [("hello",fromList [("world","!!!")])]  and when have deleting the last entry from the nested Map mean that we should delete its entry from the surrounding one: >>> fromList [("hello",fromList [("world","!!!")])] & at "hello" . non Map.empty . at "world" .~ Nothing fromList []  It can also be used in reverse to exclude a given value: >>> non 0 # rem 10 4 Just 2  >>> non 0 # rem 10 5 Nothing  use :: MonadState s m => Getting a s a -> m a # Use the target of a Lens, Iso, or Getter in the current state, or use a summary of a Fold or Traversal that points to a monoidal value. >>> evalState (use _1) (a,b) a  >>> evalState (use _1) ("hello","world") "hello"  use :: MonadState s m => Getter s a -> m a use :: (MonadState s m, Monoid r) => Fold s r -> m r use :: MonadState s m => Iso' s a -> m a use :: MonadState s m => Lens' s a -> m a use :: (MonadState s m, Monoid r) => Traversal' s r -> m r  view :: MonadReader s m => Getting a s a -> m a # View the value pointed to by a Getter, Iso or Lens or the result of folding over all the results of a Fold or Traversal that points at a monoidal value. view . to ≡ id  >>> view (to f) a f a  >>> view _2 (1,"hello") "hello"  >>> view (to succ) 5 6  >>> view (_2._1) ("hello",("world","!!!")) "world"  As view is commonly used to access the target of a Getter or obtain a monoidal summary of the targets of a Fold, It may be useful to think of it as having one of these more restricted signatures: view :: Getter s a -> s -> a view :: Monoid m => Fold s m -> s -> m view :: Iso' s a -> s -> a view :: Lens' s a -> s -> a view :: Monoid m => Traversal' s m -> s -> m  In a more general setting, such as when working with a Monad transformer stack you can use: view :: MonadReader s m => Getter s a -> m a view :: (MonadReader s m, Monoid a) => Fold s a -> m a view :: MonadReader s m => Iso' s a -> m a view :: MonadReader s m => Lens' s a -> m a view :: (MonadReader s m, Monoid a) => Traversal' s a -> m a  modifying :: MonadState s m => ASetter s s a b -> (a -> b) -> m () # This is an alias for (%=). assign :: MonadState s m => ASetter s s a b -> b -> m () # Replace the target of a Lens or all of the targets of a Setter or Traversal in our monadic state with a new value, irrespective of the old. This is an alias for (.=). >>> execState (do assign _1 c; assign _2 d) (a,b) (c,d)  >>> execState (both .= c) (a,b) (c,c)  assign :: MonadState s m => Iso' s a -> a -> m () assign :: MonadState s m => Lens' s a -> a -> m () assign :: MonadState s m => Traversal' s a -> a -> m () assign :: MonadState s m => Setter' s a -> a -> m ()  set :: ASetter s t a b -> b -> s -> t # Replace the target of a Lens or all of the targets of a Setter or Traversal with a constant value. (<$) ≡ set mapped

>>> set _2 "hello" (1,())
(1,"hello")

>>> set mapped () [1,2,3,4]
[(),(),(),()]


Note: Attempting to set a Fold or Getter will fail at compile time with an relatively nice error message.

set :: Setter s t a b    -> b -> s -> t
set :: Iso s t a b       -> b -> s -> t
set :: Lens s t a b      -> b -> s -> t
set :: Traversal s t a b -> b -> s -> t


over :: ASetter s t a b -> (a -> b) -> s -> t #

Modify the target of a Lens or all the targets of a Setter or Traversal with a function.

fmap ≡ over mapped
fmapDefault ≡ over traverse
sets . over ≡ id
over . sets ≡ id


Given any valid Setter l, you can also rely on the law:

over l f . over l g = over l (f . g)


e.g.

>>> over mapped f (over mapped g [a,b,c]) == over mapped (f . g) [a,b,c]
True


Another way to view over is to say that it transforms a Setter into a "semantic editor combinator".

>>> over mapped f (Just a)
Just (f a)

>>> over mapped (*10) [1,2,3]
[10,20,30]

>>> over _1 f (a,b)
(f a,b)

>>> over _1 show (10,20)
("10",20)

over :: Setter s t a b -> (a -> b) -> s -> t
over :: ASetter s t a b -> (a -> b) -> s -> t


unless :: Applicative f => Bool -> f () -> f () #

The reverse of when.

foldM :: (Foldable t, Monad m) => (b -> a -> m b) -> b -> t a -> m b #

The foldM function is analogous to foldl, except that its result is encapsulated in a monad. Note that foldM works from left-to-right over the list arguments. This could be an issue where (>>) and the folded function' are not commutative.

foldM f a1 [x1, x2, ..., xm]

==

do
a2 <- f a1 x1
a3 <- f a2 x2
...
f am xm

If right-to-left evaluation is required, the input list should be reversed.

Note: foldM is the same as foldlM

forM_ :: (Foldable t, Monad m) => t a -> (a -> m b) -> m () #

forM_ is mapM_ with its arguments flipped. For a version that doesn't ignore the results see forM.

As of base 4.8.0.0, forM_ is just for_, specialized to Monad.

when :: Applicative f => Bool -> f () -> f () #

Conditional execution of Applicative expressions. For example,

when debug (putStrLn "Debugging")

will output the string Debugging if the Boolean value debug is True, and otherwise do nothing.

throwError :: MonadError e m => e -> m a #

Is used within a monadic computation to begin exception processing.

catchError :: MonadError e m => m a -> (e -> m a) -> m a #

A handler function to handle previous errors and return to normal execution. A common idiom is:

do { action1; action2; action3 } catchError handler

where the action functions can call throwError. Note that handler` and the do-block must have the same return type.