nkpart

{-# LANGUAGE OverloadedStrings #-}
module Network.Wai.Middleware.FileUpload where

import           Control.Monad.Trans.Resource
import qualified Data.ByteString              as S
import qualified Data.Foldable                as F
import           Data.Monoid
import           Data.String                  (fromString)
import           Network.HTTP.Types.URI       (Query, QueryItem)
import           Network.Wai

nkpart

> import Test.QuickCheck
> import Data.List
> quickCheck (\xs -> (snd . Data.List.splitAt 3) xs === drop 3 xs)
+++ OK, passed 100 tests.
>

nkpart

module Foo where

import Data.Functor.Identity


-- | OK
--
-- We are going to build 2 functions
--   * something that collects all the items in a list of futures
--   * something that recursively gets all the search results from an

nkpart

{-# LANGUAGE TemplateHaskell #-}
{-# LANGUAGE OverloadedStrings #-}
module Data.Omnitrans.OtMatrix.Header where

import Data.Text as T
import Control.Monad
import Data.Serialize as B
import Control.Lens
import Data.Char (chr)
import Data.Word

nkpart

Modules, Errors and Coupling

Suppose you have a few modules in an application which needs to request and parse data from a JSON api:

• Http
• Json parsing
• Business logic, something to do with Images

Each of these can fail in their own way:

nkpart

This would need de-MTL'ing.

We have a process that builds up lots and lots of matrices row by row.

• Each matrix has a header which accessed where it's needed via Reader
• We don't want to write to some of the files but not all, because that's probably a bug (ie. we've missed a row in one of the matrices)
• We track the number of lines written in State
• We error out when the lines don't match.

The calling code calls appendAll a bunch of times for different sub-groups of matrices, and then checkFileWritingConsistency after doing all the sub-groups.

nkpart

--
import Data.Map.Lazy
import Control.Lens

-- We wanted to traverse a structure, but not recompute the function for duplicate keys. And then we also needed cache.
-- It's probably tricky to unlens this.

traverseMemoOf :: (Ord a, Monad f) => Traversal s t a b -> (a -> f b) -> s -> f (t, ML.Map a b)
traverseMemoOf l f z =

nkpart

module EnvParse where

import Control.Lens         (from, view, (^.), over, _Left)
import System.IO (stderr, hPutStrLn, hPrint)
import Control.Monad        ((<=<))
import Control.Monad.Reader (ReaderT (..), runReaderT)
import Data.Validation      (AccValidation, _AccValidation, _Either)
import System.Environment   (getEnvironment)
import System.Exit          (exitFailure)
import Text.Read            (readEither)

nkpart

{-# LANGUAGE NoMonomorphismRestriction #-}
{-# LANGUAGE OverloadedStrings #-}
module Data.Yaml.Extended (module Data.Yaml.Extended, lift) where

import Data.Aeson.Types
import qualified Data.Text as T
import Control.Monad.State.Strict (StateT, runStateT, unless, lift, get, modify)
import qualified Data.HashMap.Strict as HM (null, delete, keys)
import Data.List (intercalate)

nkpart

{-# LANGUAGE GeneralizedNewtypeDeriving #-}
{-# LANGUAGE DeriveTraversable #-}
{-# LANGUAGE FlexibleInstances #-}
{-# LANGUAGE MultiParamTypeClasses #-}
{-# LANGUAGE UndecidableInstances #-}
{-# OPTIONS_GHC -fno-warn-orphans #-}
module NonEmpty where

import Control.Lens
import Control.Lens.Extras