paf31

module Control.Monad.List.Trans where

import Prelude

import Data.List
import Data.Either

import Control.Apply
import Control.Bind
import Control.Monad.Eff

Teggy

{-# LANGUAGE TypeSynonymInstances #-}

import Data.Monoid
import Data.Maybe

-- How much water does a "histogram" hold?
--
-- Inspired by Guy Steele's talk "Four Solutions to a Trivial Problem"
-- https://www.youtube.com/watch?v=ftcIcn8AmSY

ekmett

{-# language KindSignatures #-}
{-# language PolyKinds #-}
{-# language DataKinds #-}
{-# language TypeFamilies #-}
{-# language RankNTypes #-}
{-# language NoImplicitPrelude #-}
{-# language FlexibleContexts #-}
{-# language MultiParamTypeClasses #-}
{-# language GADTs #-}
{-# language ConstraintKinds #-}

phadej

{-# LANGUAGE CPP #-}
{-# LANGUAGE ScopedTypeVariables #-}
{-# LANGUAGE FlexibleInstances, FlexibleContexts #-}
{-# LANGUAGE DataKinds, GADTs, KindSignatures, TypeOperators, UndecidableInstances #-}

#if __GLASGOW_HASKELL__ < 708
#error "requires GHC 7.10 or newer"
#endif
module Main (main) where

harpocrates

Control.Arrow
=============
  "compose/arr"   forall f g .
                  (arr f) . (arr g) = arr (f . g)
  "first/arr"     forall f .
                  first (arr f) = arr (first f)
  "second/arr"    forall f .
                  second (arr f) = arr (second f)
  "product/arr"   forall f g .
                  arr f *** arr g = arr (f *** g)

chrisdone

-- RHS size: {terms: 254, types: 135, coercions: 0}
Xeno.$wparse [InlPrag=[0]]
  :: GHC.Prim.Addr#
     -> GHC.ForeignPtr.ForeignPtrContents
     -> GHC.Prim.Int#
     -> GHC.Prim.Int#
     -> ()
[GblId,
 Arity=4,
 Str=DmdType <L,U><L,U><L,U><S,U>,

madidier

-- I haven't been able to actually run the program (broken archlinux packages), but it typechecks

open import Data.String
open import Function
open import IO.Primitive

Either : Set → Set → Set₁
Either l r = {a : Set} → (l → a) → (r → a) → a 

Left  : { l r : Set } → l → Either l r

lexi-lambda

{-# LANGUAGE GeneralizedNewtypeDeriving #-}

module Language.HigherRank.Main
  ( Expr(..)
  , EVar(..)
  , Type(..)
  , TVar(..)
  , TEVar(..)
  , runInfer
  ) where

i-am-tom

module Main where

-- | JSON is an incredibly simple format. Even its lists are untyped.
-- | As with all languages, functional programming encourages us to
-- | make a domain-specific language (or DSL) to capture the "ideas"
-- | of the language, which we can then use to talk about its content.

-- | In this little snippet, we'll build a JSON DSL, transform it into
-- | a recursive structure, and then use that result to generate some

i-am-tom

module MapRecordWithComments where

-- | Type-level Tomfoolery. A million thankyous to @kcsongor and his
-- | unparallelled patience with me while I try to figure this stuff
-- | out.

import Prelude (($), (+), (<>), discard, show)

import Control.Monad.Eff (Eff)
import Control.Monad.Eff.Console (CONSOLE, log)