:: Binary a
=> ByteString	The bytestring to decode
-> b	Default value to return when decoding fails
-> (a -> b)	Function to apply when decoding succeeds
-> b	Final result

Try to decode a Data.Binary value. If decoding succeeds, apply the function to the result. Otherwise, return the default value.

fromRunGet Source

Arguments

:: Binary a
=> Get a	The Get monad to run
-> ByteString	The bytestring to decode
-> b	Default value to return when decoding fails
-> (a -> b)	Function to apply when decoding succeeds
-> b	Final result

Try to run a Data.Binary.Get monad. If decoding succeeds, apply a function to the result. Otherwise, return the default value.

decodeToEither :: Binary a => ByteString -> Either String aSource

Decode a Data.Binary value into the Either monad. A Right value is returned with the result upon success. Otherwise a Left value with the error message is returned.

decodeToMaybe :: Binary a => ByteString -> Maybe aSource

Decode a Data.Binary value into the Maybe monad. A Just value is returned with the result upon success. Otherwise, Nothing is returned.

isolate :: Binary a => Int -> Get a -> Get aSource

Isolate a Data.Binary.Get monad for the next Int bytes. Only the next Int bytes of the input bytestring will be available for the Get monad to consume. This function will fail if the Get monad fails or some of the input is not consumed.

Maybe and Either monad helpers

isLeft :: Either a b -> Bool Source

Returns True if the Either value is Left

isRight :: Either a b -> Bool Source

Returns True if the Either value is Right

fromRight :: Either a b -> bSource

Extract the Right value from an Either value. Fails if the value is Left

fromLeft :: Either a b -> aSource

Extract the Left value from an Either value. Fails if the value is Right

eitherToMaybe :: Either a b -> Maybe bSource

Transforms an Either value into a Maybe value. Right is mapped to Just and Left is mapped to Nothing. The value inside Left is lost.

maybeToEither :: b -> Maybe a -> Either b aSource

Transforms a Maybe value into an Either value. Just is mapped to Right and Nothing is mapped to Left. You also pass in an error value in case Left is returned.

liftEither :: Monad m => Either b a -> EitherT b m aSource

Lift a Either computation into the EitherT monad

liftMaybe :: Monad m => b -> Maybe a -> EitherT b m aSource

Lift a Maybe computation into the EitherT monad

Various helpers

updateIndex Source

Arguments

:: Int	The index of the element to change
-> [a]	The list of elements
-> (a -> a)	The function to apply
-> [a]	The result with one element changed

Applies a function to only one element of a list defined by it's index. If the index is out of the bounds of the list, the original list is returned

matchTemplate Source

Arguments

:: [a]	The input list
-> [b]	The list to serve as a template
-> (a -> b -> Bool)	The comparison function
-> [Maybe a]	Results of the template matching

Use the list [b] as a template and try to match the elements of [a] against it. For each element of [b] return the (first) matching element of [a], or Nothing. Output list has same size as [b] and contains results in same order. Elements of [a] can only appear once.

fst3 :: (a, b, c) -> aSource

snd3 :: (a, b, c) -> bSource

lst3 :: (a, b, c) -> cSource

Build monad

data Build a Source

The Build monad represents computations that can be in one of three states:

Complete
Partial
Broken

It extends the Either monad with an additional Partial value to describe a valid computation flagged with a Partial context. The Build monad is useful when you describe computations where parts of the computation are either complete, partially complete or broken. Combining only Complete computations will produce a Complete result. However, if one of the computations is Partial, the whole computation will be Partial as well. And if some computation is Broken, the whole computation will be broken as well.

The Build monad is used by Haskoin to describe the state of the transaction signing computation. To sign a transaction, all input scripts need to be signed. The whole transaction will be completely signed only if all the input scripts are completely signed. If any of the inputs is partially signed, then the whole transaction will be partially signed as well. And the whole transaction is broken if one of the inputs failed to parse or is broken.

Constructors

Complete	Describes a successful complete computation
Fields runBuild :: a
Partial	Describes a successful but partial computation
Fields runBuild :: a
Broken	Describes a broken computation
Fields runBroken :: String