Haskell Communities and Activities Report

derives

yield
yield :: MonadPlus m => e -> EitherT e m ()

yield x = raise x `mplus` return ()


procedure findodd(s1, s2)

   every i := find(s1, s2) do

      if i % 2 = 1 then suspend i

end


findodd2 :: (Monad m, LogicT t, MonadPlus (t m)) =>

            String -> String -> EitherT Int (t m) ()

findodd2 s1 s2 = iterE Nothing $ do

  i <- findIM s1 s2

  if i `mod` 2 == 1 then yield i else return ()|])


foldable_gen :: (MonadPlus m, F.Foldable t) =>

         t a -> EitherT a m ()

foldable_gen = F.mapM_ yield


$ 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
ghc-mod
ghc
ghc-mod
ghc-mod
ghc-mod
ghc-mod
ghc-mod
ghc-exactprint
ghc-exactprint
ghc-exactprint
HLint
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


-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]


  \ f1 -> fmap (show . f1)


     (Monad m, Monad n)

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

  -> m (n c)


  \ f1 -> liftA2 (\ hs i ->

    liftA2 (\ n os -> f1 os n) i (sequenceA hs))


TODO
FIXME
[tag]
send
lineWidth
strokeStyle
Canvas
send        :: Device -> Canvas a -> IO a

lineWidth   :: Double             -> Canvas ()

strokeStyle :: Text               -> Canvas ()


lineWidth
send
lineWidth
send device (lineWidth 10)


strokeStyle
send
strokeStyle
send device (strokeStyle "red")


send device (lineWidth 10 >> strokeStyle "red")


isPointInPath :: (Double,Double) -> Canvas Bool


   send device $ do

      inside <- isPointInPath (0,0)

      lineWidth (if inside then 10 else 2)

      ...


send
  do res <- send device (isPointInPath (0,0))

     ...


send
isOdd :: Int -> Bool

isOdd n = isEven (plusOne n)


isEven :: Int -> Bool

isEven n = mod2 n == 0


plusOne :: Int -> Int

plusOne n = n + 1


mod2 :: Int -> Int

mod2 n = div n 2


prop_isOdd :: Int -> Bool

prop_isOdd x = isOdd (2*x+1)


main :: IO ()

main = printO (prop_isOdd 1)


main :: IO ()

main = quickcheck prop_isOdd


./MyProgram

*** Failed! Falsifiable (after 1 test): 1


import Debug.Hoed.Pure


isOdd :: Int -> Bool

isOdd = observe "isOdd" isOdd'

isOdd' n = isEven (plusOne n)


isEven :: Int -> Bool

isEven = observe "isEven" isEven'

isEven' n = mod2 n == 0


plusOne :: Int -> Int

plusOne = observe "plusOne" plusOne'

plusOne' n = n + 1


mod2 :: Int -> Int

mod2 = observe "mod2" mod2'

mod2' n = div n 2


prop_isOdd :: Int -> Bool

prop_isOdd x = isOdd (2*x+1)


main :: IO ()

main = printO (prop_isOdd 1)


./MyProgram

False

Listening on http://127.0.0.1:10000/


isOdd
(2*x+1)
conduit-combinators
streaming-commons
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
criterion
haskell-src-exts
Ideas
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)


$(take 10 [1.0 .. ])
hs_
hs_x
x
x :: Chan t
ch_x
hs_x <- f()
f()
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
petsc-hs
inline-c
petsc-hs
combinat
graphviz
diagrams
fixplate

uniplate
generics-sop
DeriveGeneric
generic-deriving
generics-sop
generics-sop
selectList [ PersonFirstName ==. "Simon",

             PersonLastName ==. "Jones"] []


0.3.3.0
darcs get
0.6.0.3
1.0.0.0
stepper
Event
threepenny-gui
fltks
fltks
fltks
fltks
fltks
fltks
fltks
vect
diagrams-pandoc
stack
#diagrams
hmidi
launchpad-control
text-icu
Prose
Numerals
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


Vector
Vector
feldspar-io
hledger
hledger
hledger
hledger
hledger
hledger-ui
hledger-diff

  hledger-interest
hledger-irr
hledger

  -V
hledger
hledger
hledger-web
hledger
hledger
#hledger
hledger
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)


binary
binary-serialise-cbor
generics-sop
binary-serialise-cbor
generics-sop
snap
postgres-simple
ekg
blaze-html
stack

Haskell Communities and Activities Report

http://tinyurl.com/haskcar

pdf version

Twenty-Ninth Edition – November 2015

Mihai Maruseac (ed.)

Andreas Abel

Chris Allen

Christopher Anand

Francesco Ariis

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

Manuel M. T. Chakravarty

Roman Cheplyaka

Olaf Chitil

Alberto Gomez Corona

Duncan Coutts

Atze Dijkstra

Péter Divianszky

Corentin Dupont

Richard Eisenberg

Tom Ellis

Maarten Faddegon

Andrew Farmer

Dennis Felsing

Julian Fleischer

Phil Freeman

PALI Gabor Janos

Michal J. Gajda

Andrew Gibiansky

Brett G. Giles

Andrew Gill

Alexander Granin

Mark Grebe

Daniel Gröber

Jurriaan Hage

Greg Hale

Bastiaan Heeren

Joey Hess

Nicu Ionita

Bob Ippolito

Robin KAY

Anton Kholomiov

Ian-Woo Kim

Oleg Kiselyov

Edward Kmett

Balazs K om uves

Eric Kow

Nickolay Kudasov

Rob Leslie

Ben Lippmeier

Andres Löh

Rita Loogen

Boris Lykah

Ian Lynagh

José Pedro Magalhães

Ketil Malde

Douglas McClean

Simon Michael

Mantas Markevicius

Dino Morelli

Natalia Muska

Rishiyur Nikhil

Antonio Nikishaev

Ulf Norell

Kiwamu Okabe

Ivan Perez

Jens Petersen

Haskell Consultancy Munich

Simon Peyton Jones

Matthew Pickering

Gracjan Polak

Generators: `yield` = exception + non-determinism