sjoerdvisscher

{-# LANGUAGE PolyKinds #-}
{-# LANGUAGE TypeFamilies #-}
{-# LANGUAGE TypeOperators #-}
{-# LANGUAGE FlexibleContexts #-}
{-# LANGUAGE MultiParamTypeClasses #-}
{-# LANGUAGE RankNTypes #-}
{-# LANGUAGE FlexibleInstances #-}
{-# LANGUAGE StandaloneKindSignatures #-}
{-# LANGUAGE GADTs #-}
{-# LANGUAGE UndecidableInstances #-}

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, (<>))

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)? {

landonf

func main () {
  let typedHeterogeneousList = true =+= "Hello" =+= 1 =+= HNil()
  
  let first: Bool = typedHeterogeneousList.head()
  let second: String = typedHeterogeneousList.tail().head()
  let third: Int = typedHeterogeneousList.tail().tail().head()
}

protocol HList {
  typealias Head

sjoerdvisscher

-- http://www.cs.ox.ac.uk/ralf.hinze/SSGIP10/AdjointFolds.pdf
-- http://www.cs.ox.ac.uk/ralf.hinze/publications/SCP-78-11.pdf
-- https://www.cs.ox.ac.uk/people/nicolas.wu/papers/URS.pdf

{-# LANGUAGE
    MultiParamTypeClasses
  , FunctionalDependencies
  , GADTs
  , PolyKinds
  , DataKinds

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|

nfrisby

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

module InductiveConstraints where

import GHC.Prim (Constraint)