jfischoff

delayOne :: (MonadHold t m, Reflex t) => Event t a -> m (Event t (a, a))
delayOne e = do
  b <- hold Nothing $ Just <$> e
  let eOld = W.catMaybes $ b <@ e
  pure $ liftF2 (,) eOld e

jfischoff

-- The idea is to compose fold like things that can terminate. This is primarily so I can 
-- make a Alternative instance that returns the first finished fold.
-- I copied much of this from foldl and folds but unlike those libraries you cannot call the `extractor` until the 
-- fold is finished.

data StepState = Running | Finished
  deriving (Eq, Show, Ord, Read, Generic)

anyFinished :: StepState -> StepState -> StepState
anyFinished x y = case (x, y) of

jfischoff

{-# LANGUAGE RecordWildCards #-}
module TH where
import Language.Haskell.TH
import System.FilePath
import Control.Monad ((<=<))
import System.Directory (getCurrentDirectory, canonicalizePath)

fileRelativeToAbsolute :: String -> Q Exp
fileRelativeToAbsolute = stringE <=< fileRelativeToAbsoluteStr

jfischoff

waitForServer :: Int -> IO ()
waitForServer port = handle (\(_ :: IOException) -> waitForServer port) $ do
  let hints = S.defaultHints { S.addrFlags = [ S.AI_NUMERICHOST
                                             , S.AI_NUMERICSERV
                                             ]
                             , S.addrSocketType = S.Stream
                             }
  addr:_ <- S.getAddrInfo (Just hints) (Just "127.0.0.1") (Just $ show port)
  bracket (S.socket (S.addrFamily addr) (S.addrSocketType addr) (S.addrProtocol addr))
          S.close

jfischoff

{-# LANGUAGE QuasiQuotes   #-}
module SimpleDBSpec (spec, main) where
import           Database.PostgreSQL.Simple.SqlQQ
import qualified Database.PostgreSQL.Simple as Simple
import           Database.PostgreSQL.Transact
import           Test.Hspec                     (Spec, hspec)
import           Test.Hspec.Expectations.Lifted
import           Test.Hspec.DB
import           Control.Monad

jfischoff

waitForPort :: Int -> IO ()
waitForPort port = handle (\(_ :: IOException) -> threadDelay 10000 >> waitForDB port) $ do
  let hints = defaultHints
              { addrFlags =
                [ AI_NUMERICHOST
                , AI_NUMERICSERV
                ]
              , addrSocketType = Stream
              }
  addr:_ <- getAddrInfo (Just hints) (Just "127.0.0.1") (Just $ show port)

jfischoff

{-# LANGUAGE OverloadedLists #-}
{-# LANGUAGE LambdaCase #-}
module Network.TCP where
import Data.Set (Set)

data PacketFlag = NS | CWR | ECE | URG | ACK | PSH | RST | SYN | FIN
  deriving (Eq, Show, Ord)

type Packet = Set PacketFlag

jfischoff

{-# LANGUAGE FlexibleContexts #-}
module Algebra.Monomial where
import Data.List
import Data.Function
import Text.Parsec hiding (parse)
import qualified Text.Parsec.Token as P
import qualified Text.Parsec.Language as P
import Control.Applicative ((<$>))
import Data.Functor.Identity

jfischoff

{-# LANGUAGE PolyKinds, DataKinds, TemplateHaskell, TypeFamilies,
    GADTs, TypeOperators, RankNTypes, FlexibleContexts, UndecidableInstances,
    FlexibleInstances, ScopedTypeVariables, MultiParamTypeClasses,
    OverlappingInstances, TemplateHaskell #-}
module Oxymoron.Regions.TAssociativeArray where
import Data.Singletons    

singletons [d| data AssocArray a b = AssocArray [(a, b)] |]

type instance ('AssocArray xs) :==: ('AssocArray ys) = 

jfischoff

module Control.Monad.Error.Restricted.Partial where
import Control.Applicative
import Data.Foldable (asum)
import qualified Data.HashMap.Strict as H
import Control.Monad hiding (msum)
import Data.Hashable
import Data.Foldable
import Data.Traversable
import Data.Monoid
import Data.Maybe