kseo

pub struct TransactionGroup {
    /// Nonce.
    pub nonce: U256,
    /// Amount of CCC to be paid as a cost for distributing these transactions to the network.
    pub fee: U256,
    /// Transactions
    pub transactions: Vec<Transaction>,
    /// Mainnet or Testnet
    pub network_id: u64,
}

kseo

pub struct AssetOutPoint {
  pub transaction_hash: H256,
  pub index: usize,
  pub asset_type: H256,
  pub amount: u64,
}

kseo

{-# LANGUAGE NamedFieldPuns #-}

import Control.Monad (when)
import qualified Data.ByteString.Char8 as BSC
import Data.Default.Class (def)
import Data.Monoid ((<>))
import System.IO.Error (ioError, userError)

import Data.X509 (CertificateChain (..), HashALG(..))
import Data.X509.CertificateStore (makeCertificateStore)

kseo

{-# LANGUAGE FlexibleInstances #-}
{-# LANGUAGE TypeFamilies #-}

module Beard.DOM
  ( Element(..)
  , Node(..)
  , parseDOM
  ) where

import Control.Monad (when)

kseo

import Control.Monad
import Control.Monad.ST
import Data.STRef

sumST :: Num a => [a] -> a
sumST xs = runST $ do
  n <- newSTRef 0
  forM_ xs $ \x -> modifySTRef n (+x)
  readSTRef n

kseo

-- https://jeltsch.wordpress.com/2013/02/14/the-constraint-kind/
{-# LANGUAGE ConstraintKinds, TypeFamilies #-}

import Prelude hiding (Monad (..))
import Data.Set
import GHC.Exts (Constraint)

setReturn :: el -> Set el
setReturn = singleton

kseo

import Prelude hiding (foldr)
import Data.Monoid

foldComposing :: (a -> (b -> b)) -> [a] -> Endo b
foldComposing f = foldMap (Endo . f)

foldr :: (a -> (b -> b)) -> b -> [a] -> b
foldr f z xs = appEndo (foldComposing f xs) z

kseo

odule Eval where

import Control.Monad.Identity
import Control.Monad.Error
import Control.Monad.Reader
import Control.Monad.State
import Control.Monad.Writer
import Data.Maybe
import qualified Data.Map as Map

kseo

{-# LANGUAGE FlexibleInstances #-}
{-# LANGUAGE MultiParamTypeClasses #-}
{-# LANGUAGE UndecidableInstances #-}

import Control.Monad
import Control.Monad.State
import Control.Monad.Trans

newtype MaybeT m a = MaybeT {
  runMaybeT :: m (Maybe a)

kseo

-- http://research.microsoft.com/en-us/um/people/simonpj/papers/assoc-types/fun-with-type-funs/typefun.pdf
{-# LANGUAGE TypeFamilies #-}

class Memo a where
  data Table a :: * -> *
  toTable :: (a -> w) -> Table a w
  fromTable :: Table a w -> (a -> w)

instance Memo Bool where
  data Table Bool w = TBool w w