Haskell Communities and Activities Report

implicit

Iteratee
newtype EQU a b = EQU{subst:: forall c. c a -> c b}


eq_arr :: EQU a1 a2 -> EQU b1 b2

                    -> EQU (a1->b1) (a2->b2)


-march
-mcpu
$ cabal install ajhc

$ ajhc --version

ajhc 0.8.0.9 (9c264872105597700e2ba403851cf3b

236cb1646)

compiled by ghc-7.6 on a x86_64 running linux

$ echo 'main = print "hoge"' > Hoge.hs

$ ajhc Hoge.hs

$ ./hs.out

"hoge"


cabal install helium
cabal install lvmrun
happstack-authentication
stripe
hyperdrive
nixops
#snapframework
i686
#MateVM @ OFTC
–aoag
–loag
qdata Coin      = {Heads | Tails}

toss ::( ; c:Coin) =

{  q = |0>;     Had q;

   measure q of      |0> => {c = Heads}

                     |1> => {c = Tails}

}


ghc-mod
ghc
cabal build
ghc-mod
ghc-mod
ide-backend
ghc-mod
ghc-mod
ghc-mod
ghc-exactprint
ghc-exactprint
ghc-exactprint
darcs rebase
darcs convert
cab
cab
ghc-pkg
cabal
ghc-pkg
cabal
cab
java-bridge
class A {

public:

  A();

  virtual void Foo();

}; 

class B : public A {

public:

  B();

  virtual void Bar();

}; 


a = myclass "A" [] mempty Nothing

    [ Constructor [] Nothing

    , Virtual void_ "Foo" [ ] Nothing ]

b = myclass "B" [a] mempty Nothing

    [ Constructor [] Nothing

    , Virtual void_ "Bar" [] Nothing ] 


cabal
cabal-devel
:printHeap
:print
> let x = cycle [True, False]

> :printHeap x

_bco

> head x

True

> :printHeap x

let x1 = True : _thunk x1 [False]

in x1

> take 3 x

[True,False,True]

> :printHeap x

let x1 = True : False : x1

in x1


:print
> let f = 0 : 1 : zipWith (+) f (tail f)

> f !! 2

> :view f


-N
-j
testCaseSteps
main =

  defaultMain $

  testCaseSteps "Multi-step test" $

  \step -> do

  step "Step 1"

  -- do something

  step "Step 2"

  -- do something else


UnboxedTuples:                 OK (0.04s)

  Golden file did not exist; created


#tasty
json-autotype
$ json-autotype input.json -o JSONTypes.hs


$ runghc JSONTypes.hs input.json


  (Show b) => (a -> b) -> [a] -> [String]


  \ b -> fmap (\ g -> show (b g))


     (Monad m, Monad n)

  => ([a] -> b -> c) -> m [n a] -> m (n b)

  -> m (n c)


  \ b -> liftA2 (\ i j ->

    liftA2 (\ o p -> b p o) j (sequenceA i))


conduit-combinators
streaming-commons
lens
uniplate
  kinetic_energy :: Mass -> Velocity -> Energy

  kinetic_energy m v = redim $ 0.5 *| m |*| v |*| v

  g_earth :: Acceleration

  g_earth = redim $ 9.8 % (Meter :/ (Second :^ sTwo))


GHC.TypeLits.Nat
(x + 2)^(y + 2)


4*x*(2 + x)^y + 4*(2 + x)^y + (2 + x)^y*x^2


unsafeCoerce
CmpNat (x + 2) (x + 3) ~ 'LT


$ cabal update

$ cabal install ghc-typelits-natnormalise


data Vec :: * -> Integer -> * ^^ where

  Nil    :: Vec a 0

  (:::)  :: a -> Vec a n -> Vec a (1 !+ n)

replicate :: pi n. forall a. a -> Vec a n

replicate ^^ @0  _  = Nil

replicate        x  = x ::: replicate x


nokinds
haskell-src-exts
Ideas
darcs get
uu-interleaved
uu-options
data Prefers  =  Agda | Haskell deriving Show

data Address  =  Address  {  city_ :: String

                          ,  street_ :: String} 

                 deriving Show

data Name     =  Name  {  name_:: String 

                       ,  prefers_:: Prefers

                       ,  ints_ :: [Int]

                       ,  address_ :: Address} 

                 deriving Show

$(deriveLenses ''Name)

$(deriveLenses ''Address)


defaults = Name  "Doaitse"  Haskell [] 

                 (Address  "Utrecht" 

                           "Princetonplein")


oName =

                 name     `option`   (  "name",       pString,

                                        "Name")

            <>   ints     `options`  (  "ints",       pNaturalRaw,  

                                        "Some numbers") 

            <>   prefers  `choose`   [(  "agda",      Agda,         

                                         "Agda preferred")

                                     ,(  "haskell",   Haskell,      

                                         "Haskell preferred")

                                     ] 

            <>   address  `field`

                           (   city     `option`  (  "city",   pString, 

                                                     "Home city")  

                           <>  street   `option`  (  "street" ,pString, 

                                                     "Home Street" )

                           )


Name  {  name_     =  Doaitse

      ,  prefers_  =  Agda

      ,  ints_     =  [7,5,3]

      ,  address_  =  Address 

                      {  city_    =  Tynaarlo

                      ,  street_  =  Zandlust}

      }


./OptionsDemo --street=Zandlust -nDoaitse

-i3 --city=Tynaarlo

 --name     [Char]  optional  Name

 --ints     Int     recurring Some numbers

 Choose at least one from(

 --agda         required  Agda preferred

 --haskell      required  Haskell preferred

    )

 --city     [Char]  optional  Home city

 --street   [Char]  optional  Home Street

 --

 --  Correcting steps:

 --    Inserted  "-a" at position 70 

 --    expecting one of

       [  "--agda", "--agda=", "--haskell", 

          "--haskell=", "--ints=", "--ints", 

          "-i", "-h", "-a"]

 --    Inserted  EOT at position 70 

 --    expecting EOT


Parsec
  s (f <<< s % n ||| g <<< n ... h)


parsec
parsec
Parser
base
ReadP
trifecta
Alternative
MonadPlus
Parser
clang
parsers
trifecta
$(take 10 [1.0 .. ])
hs_
hs_x
x
x :: Chan t
ch_x
hs_x <- f()
f()
statistics
semigroups
semigroupoids
semigroupoids 4.0
groupoids
semigroupoid-extras
compensated
approximate
intervals
log-domain
profunctors
profunctor-extras
representable-profunctors
mtl
comonad 4.0
comonad
comonad-transformers
comonads-fd packages
codo-notation
kan-extensions
genfft
hblas
hblas
hblas
hblas
import Data.Random.Distribution.Normal

import HROOT

main :: IO () 

main = do 

  tcanvas <- newTCanvas "Test" "Test" 640 480

  h2 <- newTH2F "test" "test"

                100 (-5.0) 5.0 100 (-5.0) 5.0 

  let dist1 = Normal (0 :: Double)

                     (2 :: Double)

  let go n | n < 0 = return () 

           | otherwise = do 

               histfill dist1 dist2 h2

               go (n-1) 

  go 1000000

  draw h2 "lego"

  saveAs tcanvas "random2d.pdf" ""

histfill :: Normal Double -> TH2F -> IO () 

histfill dist1 hist = do 

  x <- sample dist1

  y <- sample dist1 

  fill2 hist x y 

  return () 


numerical
numerical
numerical
concurrent-supply
parsers
trifecta
either
either 4.0
eithers

either-unwrap
tagged

base
undefined
void
tables
ixset
data-store
lens
selectList [ PersonFirstName ==. "Simon",

             PersonLastName ==. "Jones"] []


0.3.3.0
darcs get
0.6.0.1
Foreign.JavaScript
0.8.1.2
t
fltks
fltks
fltks
fltks
fltks
fltks
fltks
diagrams-html5
diagrams-pgf
Double
linear
vector-space
diagrams
#diagrams
darcs get
aeson
hyph-utf8
expr :: Grammar r String (Prod r String String Expr)

expr = mdo

  x1 <- rule $ Add <$> x1 <* namedSymbol "+" <*> x2

            <|> x2

            <?> "sum"

  x2 <- rule $ Mul <$> x2 <* namedSymbol "*" <*> x3

            <|> x3

            <?> "product"

  x3 <- rule $ Var <$> (satisfy ident <?> "identifier")

            <|> namedSymbol "(" *> x1 <* namedSymbol ")"

  return x1

  where

    ident (x:_) = isAlpha x

    ident _     = False


  fullParses $ parser expr $ words "a + b * ( c + d )"

  = ( [Add (Var "a") (Mul (Var "b")

  (Add (Var "c") (Var "d")))]

    , Report {...}

    )


  p (f <<< c % p % c ||| g <<< e ... h)


axiom p
C
C++
$ cabal update

$ cabal install clash-ghc


authorized_keys
authorized_keys
  webServer :: Host

  webServer = host "webserver.example.com"

    & ipv4 "93.184.216.34"

    & staticSiteDeployedTo "/var/www"

      `requires` Apt.serviceInstalledRunning "apache2"

      `onChange` Apache.reloaded

  staticSiteDeployedTo :: FilePath -> Property NoInfo


  d :: Fractional a => Time a -> Length a

  d t = a / _2 * t ^ pos2

   where a = 9.82 *~ (meter / second ^ pos2)


ghc-events-analyze
ghc-events-analyze
snap
postgres-simple
ekg
blaze-html

Haskell Communities and Activities Report

http://tinyurl.com/haskcar

pdf version

Twenty-Eighth Edition – May 2015

Mihai Maruseac, Alejandro Serrano Mena (eds.)

Andreas Abel

Christopher Anand

Heinrich Apfelmus

Emil Axelsson

Christiaan Baaij

Carl Baatz

Doug Beardsley

Jean-Philippe Bernardy

Alexander Berntsen

Joachim Breitner

Björn Buckwalter

Erik de Castro Lopo

Lucas DiCioccio

Roman Cheplyaka

Olaf Chitil

Alberto Gomez Corona

Duncan Coutts

Atze Dijkstra

Péter Divianszky

Corentin Dupont

Richard Eisenberg

Tom Ellis

Andrew Farmer

Dennis Felsing

Julian Fleischer

Phil Freeman

PALI Gabor Janos

Michal J. Gajda

Andrew Gibiansky

Brett G. Giles

Andrew Gill

Alexander Granin

Daniel Gröber

Jurriaan Hage

Greg Hale

Bastiaan Heeren

Joey Hess

Bob Ippolito

Robin KAY

Anton Kholomiov

Ian-Woo Kim

Oleg Kiselyov

Edward Kmett

Eric Kow

Nickolay Kudasov

Rob Leslie

Ben Lippmeier

Andres Löh

Rita Loogen

Boris Lykah

Ian Lynagh

José Pedro Magalhães

Ketil Malde

Mantas Markevicius

Dino Morelli

JP Moresmau

Natalia Muska

Rishiyur Nikhil

Kiwamu Okabe

Ivan Perez

Jens Petersen

Haskell Consultancy Munich

Simon Peyton Jones

Matthew Pickering

Jeffrey Rosenbluth

Ian Ross

David Sabel

Martijn Schrage

Carter Tazio Schonwald

Tom Schrijvers

Austin Seipp

Jeremy Shaw

Christian Höner zu Siederdissen

Aditya Siram

Gideon Sireling