qnikst

import Data.Char (ord)
import Data.Conduit
import Data.Conduit.Binary (sourceHandle, sinkHandle)
import qualified Data.Conduit.Binary as CB
import qualified Data.Conduit.List as CL
import qualified Data.ByteString as S
import qualified Data.ByteString.Char8 as S8
import qualified Data.ByteString.Lazy as SL
import System.Environment (getArgs)
import System.IO 

qnikst

{-# LANGUAGE PackageImports #-}
import Data.Binary.Get
import "mtl" Control.Monad.Writer
import qualified Data.ByteString.Lazy as SL
import Data.Word

main = do
  l <- SL.readFile "test"
  let (a,b) = runWriter $ next l 0
  print a 

qnikst

{-# LANGUAGE PackageImports, TypeFamilies, FlexibleContexts #-}

-- code experiments with using monad stack with conduit
-- it works well except one case - using ResourceT in inner
-- monad (commented out function)

import Data.Conduit
import Data.Conduit.Network
import "mtl" Control.Monad.Reader
import "mtl" Control.Monad.Writer

qnikst

{-# OPTIONS -Wall #-}
import Data.Conduit
import Data.Conduit.Network
import Control.Monad.IO.Class (liftIO)
import Control.Monad.Trans.Resource
import Control.Concurrent.Lifted (fork)
import Control.Concurrent (killThread)

main::IO ()
main =

qnikst

{-# GHC_OPTIONS -O2 -Wall #-}
{-# LANGUAGE BangPatterns #-}

import System.IO

import Data.Word
import Data.Char (ord)
import Data.Array.Unboxed
import Data.Array.ST
import Data.ByteString.Lazy (ByteString)

qnikst

import Control.Concurrent.STM
import Control.Concurrent.STM.TVar
import Control.Concurrent.STM.TChan
import Data.Map (Map)
import qualified Data.Map as Map

reglock  = newTMVar
registry = newTVar empty

addProcess :: (a -> IO ()) -> TVar c -> b -> IO ()

qnikst

{-# LANGUAGE TemplateHaskell #-}
{-# LANGUAGE QuasiQuotes #-}
module Template
    where

import Data.Maybe


--import Language.Haskell.TH.Syntax
--import Language.Haskell.TH.Quote

qnikst

gauss  :: [[Double]] -> [Double]
gauss  m = let (m',is) = gauss0 m
           in order is $ gauss2 $ gauss1 m

gauss0 :: [[Double]] -> ([[Double]],[Int])
gauss0 m = let (     mt,is) = foldr choose (trns m,straight) straight
           in  (trns mt,is)
    where choose k  (mt,is) = let row = m !! (k-1)
                                  q   = (+) 1 $ fromJust $ elemIndex (maximum $ init $ drop (k-1) row) row
                              in (swap' k q mt, swap' k q is)

qnikst

import Control.Monad
import Control.Concurrent
import Control.Concurrent.STM
import Control.Concurrent.STM.TVar
import Control.Concurrent.STM.TMVar
import Data.Maybe


stmTimeout :: Int -> IO a -> IO (Maybe a)
stmTimeout timeout action = do

qnikst

{-# LANGUAGE OverloadedStrings #-}
-- |
-- author: Alexander V Vershilov <alexander.vershilov@gmail.com>
--
-- Module provides simple and extensible paginator widget that doesn't make any 
-- assumptions on Route structure or type of page handling and doesn't load entities
-- that are not needed.
--
-- Basic usage
--