piscisaureus

Locate the section for your github remote in the .git/config file. It looks like this:

[remote "origin"]
	fetch = +refs/heads/*:refs/remotes/origin/*
	url = git@github.com:joyent/node.git

Now add the line fetch = +refs/pull/*/head:refs/remotes/origin/pr/* to this section. Obviously, change the github url to match your project's URL. It ends up looking like this:

ant-arctica

{-# LANGUAGE BlockArguments #-}
{-# LANGUAGE LambdaCase #-}
{-# LANGUAGE LinearTypes #-}
{-# LANGUAGE OverloadedRecordDot #-}
{-# LANGUAGE NoImplicitPrelude #-}

-- Quick demonstration that linear-base is enough to implement linear logic

import Data.Array.Destination
import Data.Array.Polarized.Pull

mstewartgallus

{-# LANGUAGE RankNTypes #-}
{-# LANGUAGE FlexibleInstances #-}
{-# LANGUAGE QuantifiedConstraints #-}
import Prelude hiding (id, (.))
import Control.Category
import Control.Monad.State hiding (lift)

class Category k => Terminal k where
  term :: k a ()

marcosh

{-# LANGUAGE AllowAmbiguousTypes     #-}
{-# LANGUAGE MultiParamTypeClasses   #-}
{-# LANGUAGE FlexibleInstances       #-}
{-# LANGUAGE ScopedTypeVariables     #-}
{-# LANGUAGE TypeApplications        #-}

module NamedTypeclass where

import Prelude hiding (Monoid, mempty, (<>))

nfrisby

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

module InductiveConstraints where

import GHC.Prim (Constraint)

ekmett

{-# LANGUAGE TypeFamilies, FlexibleContexts, TypeOperators, UndecidableInstances, GeneralizedNewtypeDeriving #-}
module Numeric.Vector.Space where

import Data.Functor.Representable.Trie hiding (Entry)
import Data.Key (Adjustable(..), Key)
import qualified Data.Key as Key
import qualified Data.Heap as Heap
import Data.Heap (Heap, Entry(..))
import qualified Data.List.NonEmpty as NonEmpty
import Data.List.NonEmpty (NonEmpty(..))

tomlokhorst

func unwrap<T1, T2>(optional1: T1?, optional2: T2?) -> (T1, T2)? {
  switch (optional1, optional2) {
    case let (.Some(value1), .Some(value2)):
      return (value1, value2)
    default:
      return nil
  }
}

func unwrap<T1, T2, T3>(optional1: T1?, optional2: T2?, optional3: T3?) -> (T1, T2, T3)? {

sebastiaanvisser

{-# LANGUAGE GADTs, TypeOperators, TupleSections #-}
module Generics.Algebra where

import Control.Category
import Control.Arrow
import Control.Applicative
import Prelude hiding ((.), id)

import Generics.Combinator

jonsterling

-- Inspired by http://www2.tcs.ifi.lmu.de/~abel/popl13.pdf

[codata|
  codata Stream a where
    head :: Stream a -> a
    tail :: Stream a -> Stream a
|]

fib :: Stream Nat
[copattern|

sebastiaanvisser

{-# LANGUAGE
    GADTs
  , KindSignatures
  , RankNTypes
  , TupleSections
  , TypeOperators
  #-}
module Generics.Morphism where

import Control.Arrow