gelisam

-- Based on https://gist.github.com/jship/d2237fad40cfb34166d82597735fbacf
--
-- The above example demonstrates how to flatten all the routes in a record of
-- records of routes, in order to bind a long list of top-level 'Link'
-- functions.
--
-- Below, I demonstrate how to instead go from a record of records of routes to
-- a record of records of 'Link's, and how to easily navigate the resulting
-- nested record.
{-# LANGUAGE DataKinds, DeriveGeneric, DerivingStrategies, FlexibleContexts, GADTs, TypeApplications, TypeOperators #-}

dagit

{- cabal:
   build-depends: base
   build-depends: transformers
   ghc-options: -threaded

-}

import Control.Concurrent (myThreadId, threadDelay, forkOS)
import Control.Monad (forever,  void)
import Control.Monad.IO.Class (liftIO)

adamwespiser

{- stack --resolver lts-16.8 --install-ghc exec ghci --package "protolude text binary" -}
{-# LANGUAGE DeriveGeneric, DuplicateRecordFields, ExistentialQuantification, FlexibleContexts, RankNTypes, ScopedTypeVariables, StandaloneDeriving #-}
{- ghcid -c "stack X.hs" -}

module Existenial where

import Data.Text
import Data.Binary
import GHC.Generics

carymrobbins

import System.IO.Unsafe

main :: IO ()
main = do
  thing 1
  thing 2
  thing 3

  thing' 1
  thing' 2

gelisam

-- Combining Maps using the Applicative idiom.
{-# LANGUAGE DeriveFunctor, DeriveFoldable, DeriveTraversable #-}
module ApplicativeMap where

import Data.Map.Strict (Map)
import qualified Data.Map as Map

-- When combining multiple Applicative computations, a common Haskell idiom is
-- to use (<$>) and (<*>) to combine the results using a function:

marcosh

module Application where

import Data.Profunctor

newtype Application request response =  Application {unApplication :: request -> IO response}

instance Profunctor Application where
    dimap actOnRequest actOnResponse application = Application $ (fmap actOnResponse) . (unApplication application) . actOnRequest

arianvp

import Control.Monad.IO.Class
import Control.Monad.Codensity
import System.IO


managedActions :: Codensity IO ()
managedActions = do
  input <- Codensity $ withFile "in.txt" ReadMode
  output <- Codensity $ withFile "out.txt" WriteMode
  contents <- liftIO $ hGetContents input

mrkgnao

{-# LANGUAGE ApplicativeDo           #-}
{-# LANGUAGE ConstrainedClassMethods #-}
{-# LANGUAGE ConstraintKinds         #-}
{-# LANGUAGE DataKinds               #-}
{-# LANGUAGE DeriveFunctor           #-}
{-# LANGUAGE DeriveGeneric           #-}
{-# LANGUAGE FlexibleContexts        #-}
{-# LANGUAGE FlexibleInstances       #-}
{-# LANGUAGE IncoherentInstances     #-}
{-# LANGUAGE InstanceSigs            #-}

mtesseract

The Problem

Defining records in Haskell causes accessor functions for the record's fields to be defined. There is no seperate namespace for these accessor functions.

The Goal

Be able to

• use records in Haskell, which share field names.
• use lenses for accessing these fields

chrisdone

{-# LANGUAGE TemplateHaskell #-}
-- | For when you have a record that doesn't have lenses derived for
-- it and you need a lens, just use @$(lens 'thefield)@ and away you go.
module Control.Lens.FieldTH where
import Language.Haskell.TH
lens :: Name -> Q Exp
lens name = do
  [|\f r ->
      fmap
        $(lamE