maurisvh

-- to watch:   telnet localhost 8887
-- to stream:  script -f >( (echo hello streamname; cat -) | nc -q5 localhost 8888 > /dev/tty )

{-# LANGUAGE OverloadedStrings #-}
module Main where

import Control.Concurrent
import Control.Concurrent.Chan
import Control.Concurrent.MVar
import Control.Monad

paf31

{-# LANGUAGE MultiParamTypeClasses, FlexibleInstances #-}

module Main where

import Test.QuickCheck

class Arbiter f r where
  arbiter :: f -> Gen r

instance Arbiter r r where

andrewthad

{-# LANGUAGE GADTs, DataKinds, KindSignatures, TypeOperators, TypeFamilies, 
             MultiParamTypeClasses, FlexibleInstances, PolyKinds, FlexibleContexts,
             UndecidableInstances, ConstraintKinds, OverlappingInstances, ScopedTypeVariables #-}

import GHC.TypeLits
import Data.Type.Bool
import Data.Type.Equality
import Data.Proxy
import Control.Applicative ((<$>), (<*>))
import Data.Maybe (catMaybes)

aaronlevin

# This template will give you a prompt with:
#    - ghc
#    - cabal
#    - ghc-mod
#    - the libraries: free, mtl, transformers
#
# to run: nix-shell haskell-project.nix
#
# to specify specific version of haskell, you can: 
#     nix-shell --arg haskellPackages 'with import <nixpkgs> {}; haskellPackages_ghc783_profiling'

nkpart

fmap . fmap . fmap

Functors and Traversables compose.

You might have seen this statement before. This is how you can take advantage of it.

Composing many fmap calls gives you a function that will drill down into a structure and modify it at a certain depth in that nested structure.

jozefg

module queue
import Data.Vect

-- Here's the port of the Liquid Haskell blog post on amortized
-- queues. The tricksy bit is that the "amortized" bit depends on
-- laziness. This means that while in the REPL (where Idris is lazy)
-- this is reasonably efficient. It compiles absolutely horribly
-- though because each time push or pop something we rotate the whole
-- damned thing.

nkpart

{-# LANGUAGE NoMonomorphismRestriction #-}
{-# LANGUAGE TemplateHaskell           #-}
{-# OPTIONS_GHC -fwarn-missing-methods #-}
module Err where

import Control.Lens
import Control.Monad.Error
import Control.Monad.Error.Lens

-- Here is a fairly typical situation, where we have low level errors in certain

tonymorris

{-# LANGUAGE RankNTypes #-}

module Functor where

import Prelude(
    foldr
  , (.)
  , Maybe(Nothing, Just)
  , maybe
  )

tonymorris

CAUTION: this rant has not been proof-read to any extent at all

The condenscension police are here, with their double-standards and unquestionable claim to a moral high-ground. Persistently engaged in disgusting conduct, I ask, "do they ever look at themselves?"

I know the answer to this question. I tested it. At one point in time, I was concerned that the charge directed at me had merit. Were they right? Were they a bit wrong, but mostly right? I wanted to know the answer to this question. No, I really really wanted to know it. So I invested some effort toward answering

chrisdotcode

module Promise where

import Control.Applicative (Applicative(..))
import Data.Monoid (Monoid(..))

newtype Error = Error { unString :: String } deriving (Eq, Ord, Read, Show)

data Promise a = Failed Error | Deferred | Fulfilled a
  deriving (Eq, Ord, Read, Show)