rampion

module ArrowOperatorQuestion where
import Control.Arrow ((***))

f :: u -> v -> w
f _ _ = error "f" 

g :: x -> y -> z
g _ _ = error "g" 

h :: (u,x) -> (v,y) -> (w,z)

qrilka

{-# LANGUAGE OverloadedStrings #-}
import Network.Wai
import Network.Wai.Handler.Warp
import Network.HTTP.Types (status200)
import Blaze.ByteString.Builder (copyByteString)
import qualified Data.ByteString.UTF8 as BU
import Data.Monoid
import Data.Enumerator (Iteratee)
import Data.Pool
import qualified Database.HDBC as H

sjoerdvisscher

import Control.Concurrent
import Control.Concurrent.Async
import Control.Applicative
import Control.Monad

import Data.Traversable

newtype Concurrently a = Concurrently { runConcurrently :: IO a }

instance Functor Concurrently where

xdcrafts

module Quasar.Main where

import Control.Monad
import Data.Char
import System.IO 
import Network
import Data.Time.LocalTime

data RequestType = GET | POST deriving (Show)

YoEight

module Examples where

import Control.Applicative
import Control.Monad.Trans

import Data.Machine

data Bit = EMPTY | One | Zero

instance Show Bit where

dpwiz

import Data.Aeson
import Network.HTTP
 
import System.Environment (getArgs)
import Control.Monad (mapM_)
 
import Data.Maybe (fromMaybe)
import qualified Data.ByteString.Lazy.Char8 as LBS
import qualified Data.Text as T
import qualified Data.HashMap.Strict as HM

t0yv0

Require Import String.

Definition Parser (a : Type) :=
  string -> option (a * string).

Definition Return {a} (x: a) : Parser a :=
  fun s => Some (x, s).

Definition Bind {a b} (x: Parser a) (f: a -> Parser b) : Parser b :=
  fun s =>

xdcrafts

{-# LANGUAGE OverloadedStrings #-}
module Main where

import Data.ByteString.Lazy.Char8 hiding (putStrLn)
import Network.HTTP.Types.Status
import Network.Wai
import Network.Wai.Handler.Warp (run)
import System.IO
import System.Exit
import Control.Concurrent

sigrlami

WARNING This list outdated, for the up to date version visit https://haskellcosm.com

List of companies that use Haskell in Production

Types of work:

• RD - research&development
• PR - product
• IP - in-house product
• CO - consulting

queertypes

{-# LANGUAGE OverloadedStrings #-}
import Control.Applicative
import Data.Attoparsec.Text
import Data.Word

data IP = IP Word8 Word8 Word8 Word8 deriving (Eq, Show)

parseIP :: Parser IP
parseIP = IP <$> dec <*> dec <*> dec <*> decimal <?> "parse IP Address"
  where dot = char '.'