DerivingVia or, How to Turn Hand-Written Instances into an Anti-Pattern
|
|
|
- Horatio Dean
- 5 years ago
- Views:
Transcription
1 DerivingVia or, How to Turn Hand-Written Instances into an Anti-Pattern Baldur Blöndal Ryan Scott 1 Andres Löh 2 1 Indiana University 2 Well-Typed LLP rgscott@indiana.edu github.com/ryanglscott
2 A brief history of deriving Haskell 98 Report (various authors): Derive the Blessed Type Classes data Grade = A B C D F instance Eq Grade where A == A = True B == B = True... _ == _ = False
3 A brief history of deriving Haskell 98 Report (various authors): Derive the Blessed Type Classes data Grade = A B C D F deriving Eq
4 A brief history of deriving Haskell 98 Report (various authors): Derive the Blessed Type Classes data Grade = A B C D F deriving ( Eq, Ord, Read, Show, Enum, Bounded, Ix )
5 A brief history of deriving GHC extensions (various authors): Derive these other blessed classes {-# LANGUAGE DeriveDataTypeable #-} {-# LANGUAGE DeriveGeneric #-} data Grade = A B C D F deriving ( Data, Generic,... )
6 A brief history of deriving GHC extension (Peyton Jones, 2001): Derive anything (through newtypes) instance Num Int where... newtype Age = MkAge Int instance Num Age where MkAge x + MkAge y = MkAge (x + y)...
7 A brief history of deriving GHC extension (Peyton Jones, 2001): Derive anything (through newtypes) {-# LANGUAGE GeneralizedNewtypeDeriving #-} instance Num Int where... newtype Age = MkAge Int deriving Num
8 A brief history of deriving GHC extension (Magalhães, 2014): Derive anything (through empty instances) class Foo a where bar :: a -> String bar _ = Sensible default data Baz = MkBaz instance Foo Baz
9 A brief history of deriving GHC extension (Magalhães, 2014): Derive anything (through empty instances) {-# LANGUAGE DeriveAnyClass #-} class Foo a where bar :: a -> String bar _ = Sensible default data Baz = MkBaz deriving Foo
10 A brief history of deriving GHC extension (Scott, 2016): Be explicit about how you derive things {-# LANGUAGE DerivingStrategies #-} newtype Age = MkAge Int deriving stock (Eq, Ord) deriving newtype Num deriving anyclass Bar
11
12 class Monoid a where mempty :: a mappend :: a -> a -> a class Applicative f where pure :: a -> f a lifta2 :: (a -> b -> c) -> f a -> f b -> f c
13 instance Monoid a => Monoid (IO a) where mempty = pure mempty mappend = lifta2 mappend
14 instance Monoid a => Monoid (ST s a) where mempty = pure mempty mappend = lifta2 mappend
15 instance Monoid b => Monoid (a -> b) where mempty = pure mempty mappend = lifta2 mappend
16 instance (Monoid a, Monoid b) => Monoid (a, b) where mempty = pure mempty mappend = lifta2 mappend
17 instance (Applicative f, Monoid a) => Monoid (f a) where mempty = pure mempty mappend = lifta2 mappend
18 instance (Applicative f, Monoid a) => Monoid (f a) where mempty = pure mempty mappend = lifta2 mappend instance Alternative f => Monoid (f a) where mempty = empty mappend = (< >)
19 instance (Applicative f, Monoid a) => Monoid (f a) where mempty = pure mempty mappend = lifta2 mappend instance Alternative f => Monoid (f a) where mempty = empty mappend = (< >)
20 instance (Applicative f, Monoid a) => Monoid (f a) where mempty = pure mempty mappend = lifta2 mappend Can we abstract this pattern out without the pain of instance overlap?
21 instance (Applicative f, Monoid a) => Monoid (f a) where mempty = pure mempty mappend = lifta2 mappend Can we abstract this pattern out without the pain of instance overlap? Well, sort of...
22 newtype Ap f a = Ap { getap :: f a } Can we abstract this pattern out without the pain of instance overlap? Well, sort of...
23 newtype Ap f a = Ap { getap :: f a } instance (Applicative f, Monoid a) => Monoid (Ap f a) where mempty = Ap (pure mempty) mappend (Ap fa) (Ap fb) = Ap (lifta2 mappend fa fb) Can we abstract this pattern out without the pain of instance overlap? Well, sort of...
24 instance Monoid a => Monoid (IO a) where mempty = pure mempty mappend = lifta2 mappend
25 instance Monoid a => Monoid (IO a) where mempty = getap (mempty :: Ap IO a) mappend p1 p2 = getap (mappend (Ap p1) (Ap p2) :: Ap IO a)
26 instance Monoid a => Monoid (IO a) where mempty = getap (mempty :: Ap IO a) mappend p1 p2 = getap (mappend (Ap p1) (Ap p2) :: Ap IO a) ( ) ( )
27
28 deriving ought to be able to write this code for you!
29 instance Monoid a => Monoid (IO a) where mempty = getap (mempty :: Ap IO a) mappend p1 p2 = getap (mappend (Ap p1) (Ap p2) :: Ap IO a)
30 data IO a =... deriving Monoid???
31 data IO a =... deriving Monoid via (Ap IO a)
32
33 {-# LANGUAGE GeneralizedNewtypeDeriving #-} instance Num Int where... newtype Age = MkAge Int deriving newtype Num
34 instance Num Int where... newtype Age = MkAge Int instance Num Age where MkAge x + MkAge y = MkAge (x + y)...
35 instance Num Int where... newtype Age = MkAge Int instance Num Age where (+) = unsafecoerce ((+) :: Int -> Int -> Int)
36 unsafecoerce :: a -> b instance Num Int where... newtype Age = MkAge Int instance Num Age where (+) = unsafecoerce ((+) :: Int -> Int -> Int)
37 unsafecoerce :: a -> b coerce :: Coercible a b => a -> b instance Num Int where... newtype Age = MkAge Int instance Num Age where (+) = {- unsafecoerce -} coerce ((+) :: Int -> Int -> Int)
38 coerce :: Coercible a b => a -> b Only typechecks if types a and b have the same runtime representation.
39 coerce :: Coercible a b => a -> b Only typechecks if types a and b have the same runtime representation. newtype Age = MkAge Int
40 coerce :: Coercible a b => a -> b Only typechecks if types a and b have the same runtime representation. newtype Age = MkAge Int instance Coercible Age Int instance Coercible Int Age
41 coerce :: Coercible a b => a -> b Only typechecks if types a and b have the same runtime representation. newtype Age = MkAge Int instance Coercible (Age -> Age) (Int -> Int) instance Coercible (Int -> Int) (Age -> Age)
42 coerce :: Coercible a b => a -> b Only typechecks if types a and b have the same runtime representation. newtype Age = MkAge Int succint :: Int -> Int succint i = i + 1 succage :: Age -> Age succage = coerce succint
43 data IO a =... deriving Monoid via (App IO a)
44 data IO a =... deriving Monoid via (App IO a) instance Monoid a => Monoid (IO a) where mempty = coerce (mempty :: Ap IO a) mappend = coerce (mappend :: Ap IO a -> Ap IO a -> Ap IO a)
45 data IO a =... deriving Monoid via (App IO a) instance Monoid a => Monoid (IO a) where mempty = coerce (mempty :: Ap IO a) mappend = coerce (mappend :: Ap IO a -> Ap IO a -> Ap IO a) Typechecks since IO a and Ap IO a have the same runtime representation.
46 DerivingVia is generalized GeneralizedNewtypeDeriving
47 DerivingVia is generalized GeneralizedNewtypeDeriving newtype Age = MkAge Int deriving newtype Num ==> instance Num Age where (+) = coerce ((+) :: Int -> Int -> Int)...
48 DerivingVia is generalized GeneralizedNewtypeDeriving newtype Age = MkAge Int deriving Num via Int ==> instance Num Age where (+) = coerce ((+) :: Int -> Int -> Int)...
49 Case studies QuickCheck Excluding types in datatype-generic algorithms
50 Case study: QuickCheck QuickCheck is a library for testing random properties of Haskell programs. class Arbitrary a where arbitrary :: Gen a -- Generate random a values
51 Case study: QuickCheck QuickCheck is a library for testing random properties of Haskell programs. class Arbitrary a where arbitrary :: Gen a -- Generate random a values > sample (arbitrary :: Gen Bool) [False,False,False,True,True,True,False,True, False,False,True]
52 Case study: QuickCheck QuickCheck is a library for testing random properties of Haskell programs. class Arbitrary a where arbitrary :: Gen a -- Generate random a values > sample (arbitrary :: Gen Int) [0,1,-1,-6,6,-7,5,13,1,8,1]
53 Case study: QuickCheck QuickCheck is a library for testing random properties of Haskell programs. class Arbitrary a where arbitrary :: Gen a -- Generate random a values > sample (arbitrary :: Gen [Int]) [[],[],[3],[1],[1,1,-6,5,-5],[],[7,-11,7],[5], [-16,15,-14,-12,5,-11],[6,1,-8,-16,9,1,15,4,-5, -18,-15,-18,-2],[-16,17,9,-3,-13,-9,11,-18, -6,8,1,-4,-5,-1,-17]]
54 Q: What if we want to generate random values subject to constraints?
55 Q: What if we want to generate random values subject to constraints? A: Use newtypes! newtype NonEmptyList a = NonEmpty [a]
56 Q: What if we want to generate random values subject to constraints? A: Use newtypes! newtype NonEmptyList a = NonEmpty [a] instance Arbitrary a => Arbitrary (NonEmptyList a) where arbitrary = fmap NonEmpty (arbitrary `suchthat` (not. null))
57 newtype Nums = MkNums [Int] deriving newtype Arbitrary > sample (arbitrary :: Gen Nums) [[],[0,-2],[],[0,-2,-3],[5,4,-5,5],[9,0], [-5,1,-5,2,11]]
58 newtype NonEmptyList a = NonEmpty [a] newtype Nums = MkNums [Int] deriving Arbitrary via (NonEmptyList Int) > sample (arbitrary :: Gen Nums) [[2,1],[1],[-3,2],[-6,3,-4,6],[-1,6,7,4,-3], [2,10,9,-7,8,-9,-7,4,4],[12,5,5,9,10]]
59 newtype NonEmptyList a = NonEmpty [a] newtype Positive a = MkPositive a newtype Nums = MkNums [Int] deriving Arbitrary via (NonEmptyList (Positive Int)) > sample (arbitrary :: Gen Nums) [[2],[1,2],[3,4],[2,5],[1],[8,2,4,3,4,5,1,7], [10,6,2,11,10,3,2,11,12]]
60 newtype NonEmptyList a = NonEmpty [a] newtype Positive a = MkPositive a newtype Large a = MkLarge a newtype Nums = MkNums [Int] deriving Arbitrary via (NonEmptyList (Positive (Large Int))) > sample (arbitrary :: Gen Nums) [[2],[2,1],[2,7,8,4],[11,13], [8,40,17,57,16,51,88,58],[249,27],[511,642]]
61 Case studies QuickCheck Excluding types in datatype-generic algorithms
62 Case study: Excluding types How can we derive instances for felds with problematic types? data ModIface {..., mi_fixities :: [(OccName,Fixity)], mi_fix_fn :: OccName -> Maybe Fixity -- ^ Cached lookup for 'mi_fixities'... }
63 Case study: Excluding types How can we derive instances for felds with problematic types? data ModIface {..., mi_fixities :: [(OccName,Fixity)], mi_fix_fn :: OccName -> Maybe Fixity -- ^ Cached lookup for 'mi_fixities'... } deriving Eq via (Excluding [OccName -> Maybe Fixity] ModIface)
64 Case study: Excluding types How can we derive instances for felds with problematic types? data ModIface {..., mi_fixities :: [(OccName,Fixity)], mi_fix_fn :: OccName -> Maybe Fixity -- ^ Cached lookup for 'mi_fixities'... } deriving Eq via (Excluding [OccName -> Maybe Fixity] ModIface) deriving stock Generic
65 import GHC.Generics class GEq (excluded :: [Type]) f where geq :: f a -> f a -> Bool
66 import GHC.Generics class GEq (excluded :: [Type]) f where geq :: f a -> f a -> Bool instance GEq excluded U1 where geq U1 U1 = True
67 import GHC.Generics class GEq (excluded :: [Type]) f where geq :: f a -> f a -> Bool instance (GEq excluded a, GEq excluded b) => GEq excluded (a :*: b) where geq (a1 :*: b1) (a2 :*: b2) = a1 a2 && b1 b2
68 import GHC.Generics class GEq (excluded :: [Type]) f where geq :: f a -> f a -> Bool instance (GEq excluded a, GEq excluded b) => GEq excluded (a :+: b) where geq (L1 a) (L1 b) = a b geq (R1 a) (R1 b) = a b geq = False
69 import GHC.Generics class GEq (excluded :: [Type]) f where geq :: f a -> f a -> Bool instance??? => GEq excluded (Rec0 a) where???
70 import GHC.Generics class GEq (excluded :: [Type]) f where geq :: f a -> f a -> Bool instance (Eq a) => GEq excluded (Rec0 a) where geq (K1 x) (K1 y) = (x == y)
71 import GHC.Generics class GEq (excluded :: [Type]) f where geq :: f a -> f a -> Bool instance (Eq a) => GEq excluded (Rec0 a) where geq (K1 x) (K1 y) = (x == y)
72 import GHC.Generics class GEq (excluded :: [Type]) f where geq :: f a -> f a -> Bool instance ( Unless (Elem a excluded) (Eq a),??? ) => GEq excluded (Rec0 a) where geq (K1 x) (K1 y) =???
73 import GHC.Generics type family class Unless GEq (excluded (a :: Bool) :: (b [Type]) :: Constraint) f where geq :: Constraint f a -> f a where -> Bool Unless True _ = () Unless False b = b instance type family ( Unless (Elem a excluded) (Eq a) Elem (x,??? :: a) ) (xs :: [a]) :: => Bool GEq excluded where (Rec0 a) where geq Elem (K1_ x) '[](K1 y) = False =??? Elem x (x:_) = True Elem x (y:xs) = Elem x xs
74 import GHC.Generics class GEq (excluded :: [Type]) f where geq :: f a -> f a -> Bool instance ( Unless (Elem a excluded) (Eq a),??? ) => GEq excluded (Rec0 a) where geq (K1 x) (K1 y) =???
75 import GHC.Generics class GEq (excluded :: [Type]) f where geq :: f a -> f a -> Bool instance ( Unless (Elem a excluded) (Eq a), SBoolI (Elem a excluded) ) => GEq excluded (Rec0 a) where geq (K1 x) (K1 y) =???
76 import GHC.Generics data SBool :: Bool -> Type where class SFalse GEq (excluded :: SBool :: False [Type]) f where geq STrue :: f :: a -> SBool f a -> TrueBool instance ( Unless (Elem a excluded) (Eq a), SBoolI (Elem a excluded) ) => GEq excluded (Rec0 a) where geq (K1 x) (K1 y) =???
77 import GHC.Generics data SBool :: Bool -> Type where class SFalse GEq (excluded :: SBool :: False [Type]) f where geq STrue :: f :: a -> SBool f a -> TrueBool class SBoolI (b :: Bool) where sbool :: SBool b instance ( Unless SBoolI (Elem False a where excluded) (Eq a) sbool, = SBoolI SFalse(Elem a excluded) ) instance => GEq SBoolI excluded True (Rec0 wherea) where geq sbool (K1 = x) STrue (K1 y) =???
78 import GHC.Generics class GEq (excluded :: [Type]) f where geq :: f a -> f a -> Bool instance ( Unless (Elem a excluded) (Eq a), SBoolI (Elem a excluded) ) => GEq excluded (Rec0 a) where geq (K1 x) (K1 y) =???
79 import GHC.Generics class GEq (excluded :: [Type]) f where geq :: f a -> f a -> Bool instance ( Unless (Elem a excluded) (Eq a), SBoolI (Elem a excluded) ) => GEq excluded (Rec0 a) where geq (K1 x) (K1 y) = case a excluded) of SFalse -> (x == y) STrue -> True
80 import GHC.Generics class GEq (excluded :: [Type]) f where geq :: f a -> f a -> Bool newtype Excluding :: [Type] -> Type -> Type where Excluding :: a -> Excluding excluded a
81 import GHC.Generics class GEq (excluded :: [Type]) f where geq :: f a -> f a -> Bool instance (Generic a, GEq excluded (Rep a)) => Eq (Excluding excluded a) where Excluding x == Excluding y = (from x) (from y)
82 import GHC.Generics data ModIface { class... GEq (excluded :: [Type]) f where, geq mi_fixities :: f a ->:: f [(OccName,Fixity)] a -> Bool, mi_fix_fn :: OccName -> Maybe Fixity -- ^ Cached lookup for 'mi_fixities'... } deriving Eq instance via (Excluding (Generic [OccName a, GEq excluded -> Maybe (Rep Fixity] a)) => ModIface) Eq (Excluding excluded a) where deriving stock Generic Excluding x == Excluding y = (from x) (from y)
83 deriving via lets you quickly write your type class instances with a high power-to-weight ratio. Allows effective use of newtypes without the awkwardness of wrapping/unwrapping them yourself Leverage existing tools in GHC in a way that feels natural Compose programming patterns by codifying them as newtypes, cheaply and cheerfully Debuts in GHC 8.6!
Livin la via loca Coercing Types with Class
Livin la via loca Coercing Types with Class Baldur Blöndal Ryan Scott 1 Andres Löh 2 1 Indiana University 2 Well-Typed LLP rgscott@indiana.edu github.com/ryanglscott Glasgow Haskell Compiler (or, GHC)
DerivingVia or, How to Turn Hand-Written Instances into an Anti-Pattern
1 DerivingVia or, How to Turn Hand-Written Instances into an Anti-Pattern Baldur Blöndal Andres Löh 1 Ryan Scott 2 1 Well-Typed LLP 2 Indiana University Haskell Symposium 2018 St. Louis, MO newtype Pair
Background Type Classes (1B) Young Won Lim 6/14/18
Background Type Classes (1B) Copyright (c) 2016-2017 Young W. Lim. Permission is granted to copy, distribute and/or modify this document under the terms of the GNU Free Documentation License, Version 1.2
Applicative, traversable, foldable
Applicative, traversable, foldable Advanced functional programming - Lecture 3 Wouter Swierstra 1 Beyond the monad So far, we have seen how monads define a common abstraction over many programming patterns.
Background Type Classes (1B) Young Won Lim 6/28/18
Background Type Classes (1B) Copyright (c) 2016-2017 Young W. Lim. Permission is granted to copy, distribute and/or modify this document under the terms of the GNU Free Documentation License, Version 1.2
Applicatives Comparisons (2C) Young Won Lim 3/6/18
Comparisons (2C) Copyright (c) 2016-2018 Young W. Lim. Permission is granted to copy, distribute and/or modify this document under the terms of the GNU Free Documentation License, Version 1.2 or any later
Applicative, traversable, foldable
Applicative, traversable, foldable Advanced functional programming - Lecture 4 Wouter Swierstra and Alejandro Serrano 1 Beyond the monad So far, we have seen how monads define a common abstraction over
QuickCheck, SmallCheck & Reach: Automated Testing in Haskell. Tom Shackell
QuickCheck, SmallCheck & Reach: Automated Testing in Haskell By Tom Shackell A Brief Introduction to Haskell Haskell is a purely functional language. Based on the idea of evaluation of mathematical functions
Type system. Type theory. Haskell type system. EDAN40: Functional Programming Types and Type Classes (revisited)
Type system EDAN40: Functional Programming Types and Type Classes (revisited) Jacek Malec Dept. of Computer Science, Lund University, Sweden April 3rd, 2017 In programming languages, a type system is a
Course year Typeclasses and their instances
Course year 2016-2017 Typeclasses and their instances Doaitse Swierstra and Atze Dijkstra with extra s Utrecht University September 29, 2016 1. The basics 2 Overloading versus parametric polymorphism 1
CIS 194: Homework 6. Due Friday, October 17, Preface. Setup. Generics. No template file is provided for this homework.
CIS 194: Homework 6 Due Friday, October 17, 2014 No template file is provided for this homework. Download the markets.json file from the website, and make your HW06.hs Haskell file with your name, any
Programming with Math and Logic
.. Programming with Math and Logic an invitation to functional programming Ed Morehouse Wesleyan University The Plan why fp? terms types interfaces The What and Why of Functional Programming Computing
Generic programming for the masses
Generic programming for the masses Ryan Scott Indiana University github.com/ryanglscott rgscott@indiana.edu April 12, 2017 Ryan Scott Generic programming for the masses April 12, 2017 1 / 1 Common scenario
Type families and data kinds
Type families and data kinds AFP Summer School Wouter Swierstra 1 Today How do GADTs work? Kinds beyond * Programming with types 2 Calling functions on vectors Given two vectors xs : Vec a n and ys : Vec
Monads. Bonus lecture 2017 David Sands
Monads Bonus lecture 2017 David Sands Our version of the story, so far. Monad is the class of instructions. Instructions can be built using do notation. We have seen two kinds of instructions i.e. two
Haskell Type Constraints Unleashed
Haskell Type Constraints Unleashed Dominic Orchard University of Cambridge Tom Schrijvers KU Leuven Fun in the Afternoon, Standard Chartered. February 17, 2010 C τ Type classestype classes Data types Type
CSC324 Principles of Programming Languages
CSC324 Principles of Programming Languages http://mcs.utm.utoronto.ca/~324 November 21, 2018 Last Class Types terminology Haskell s type system Currying Defining types Value constructors Algebraic data
User-Defined Algebraic Data Types
72 Static Semantics User-Defined Types User-Defined Algebraic Data Types An algebraic data type declaration has the general form: data cx T α 1... α k = K 1 τ 11... τ 1k1... K n τ n1... τ nkn introduces
Solution sheet 1. Introduction. Exercise 1 - Types of values. Exercise 2 - Constructors
Solution sheet 1 Introduction Please note that there can be other solutions than those listed in this document. This is a literate Haskell file which is available as PDF, as well as literate Haskell source
Functional Programming TDA 452, DIT 142
Chalmers Göteborgs Universitet 2016-04-07 Examiner: David Sands dave@chalmers.se. Answering questions on the day of the exam (at approx 15.00): Gregoire Detrez (tel: 073 55 69 550) and at other times by
Structural polymorphism in Generic Haskell
Structural polymorphism in Generic Haskell Andres Löh andres@cs.uu.nl 5 February 2005 Overview About Haskell Genericity and other types of polymorphism Examples of generic functions Generic Haskell Overview
Testing. Wouter Swierstra and Alejandro Serrano. Advanced functional programming - Lecture 2. [Faculty of Science Information and Computing Sciences]
![Testing. Wouter Swierstra and Alejandro Serrano. Advanced functional programming - Lecture 2. [Faculty of Science Information and Computing Sciences]](/thumbs/89/100566300.jpg "Testing. Wouter Swierstra and Alejandro Serrano. Advanced functional programming - Lecture 2. [Faculty of Science Information and Computing Sciences]")
Testing Advanced functional programming - Lecture 2 Wouter Swierstra and Alejandro Serrano 1 Program Correctness 2 Testing and correctness When is a program correct? 3 Testing and correctness When is a
Haskell Overview IV (4A) Young Won Lim 10/24/16
(4A) Copyright (c) 2016 Young W. Lim. Permission is granted to copy, distribute and/or modify this document under the terms of the GNU Free Documentation License, Version 1.2 or any later version published
Informatics 1 Functional Programming Lecture 11. Data Representation. Don Sannella University of Edinburgh
Informatics 1 Functional Programming Lecture 11 Data Representation Don Sannella University of Edinburgh Part I Complexity t = n vs t = n 2 10.4 9.6 8.8 8 7.2 6.4 5.6 4.8 4 3.2 2.4 1.6 0.8 0 0.8 1.6 2.4
Advances in Programming Languages
T O Y H Advances in Programming Languages APL8: Multiparameter Type Classes, Constructor Classes Ian Stark School of Informatics The University of Edinburgh Thursday 4 February Semester 2 Week 4 E H U
CS 360: Programming Languages Lecture 12: More Haskell
CS 360: Programming Languages Lecture 12: More Haskell Geoffrey Mainland Drexel University Adapted from Brent Yorgey s course Introduction to Haskell. Section 1 Administrivia Administrivia Homework 5 due
INTRODUCTION TO HASKELL
INTRODUCTION TO HASKELL PRINCIPLES OF PROGRAMMING LANGUAGES Norbert Zeh Winter 2018 Dalhousie University 1/81 HASKELL: A PURELY FUNCTIONAL PROGRAMMING LANGUAGE Functions are first-class values: Can be
Harvard School of Engineering and Applied Sciences CS 152: Programming Languages
Harvard School of Engineering and Applied Sciences CS 152: Programming Languages Lecture 18 Thursday, March 29, 2018 In abstract algebra, algebraic structures are defined by a set of elements and operations
Giving Haskell a Promotion
Giving Haskell a Promotion José Pedro Magalhães Joint work with Brent A. Yorgey Stephanie Weirich Julien Cretin Simon Peyton Jones Dimitrios Vytiniotis http://www.dreixel.net FP dag 2012, Universiteit
Simon Peyton Jones Microsoft Research August 2013
Simon Peyton Jones Microsoft Research August 2013 reverse :: a. [a] -> [a] xs :: [Bool] foo :: [Bool] foo = reverse xs Instantiate reverse with a unification variable, standing for an as-yet-unknown type.
Haskell Types COMP360
Haskell Types COMP360 Should array indices start at 0 or 1? My compromise of 0.5 was rejected without, I thought, proper consideration. Stan Kelly-Bootle British author, singer-songwriter and computer
Haskell Types, Classes, and Functions, Currying, and Polymorphism
1 CSCE 314: Programming Languages Dr. Flemming Andersen Haskell Types, Classes, and Functions, Currying, and Polymorphism 2 Types A type is a collection of related values. For example, Bool contains the
Trees. Solution: type TreeF a t = BinF t a t LeafF 1 point for the right kind; 1 point per constructor.
Trees 1. Consider the following data type Tree and consider an example inhabitant tree: data Tree a = Bin (Tree a) a (Tree a) Leaf deriving Show tree :: Tree Int tree = Bin (Bin (Bin Leaf 1 Leaf ) 2 (Bin
INDEX. Symbols & Numbers. Learn You a Haskell for Great Good! 2011 by Miran Lipovača
INDEX Symbols & Numbers && (double ampersand) as Boolean operator conjunction, 2 using with folds and lists, 78 79 '(apostrophe) using with functions, 7 using with types, 149 150 * (asterisk) as multiplication
Monads seen so far: IO vs Gen
Monads David Sands Monads seen so far: IO vs Gen IO A Gen A Instructions to build a value of type A by interacting with the operating system Instructions to create a random value of type A Run by the ghc
Applying Type-Level and Generic Programming in Haskell
Summer School on Generic and Effectful Programming Applying Type-Level and Generic Programming in Haskell Andres Löh, Well-Typed LLP July 4, 2015 Contents 1 Introduction and type-level programming 5 1.1
Module Title: Informatics 1 Functional Programming (first sitting) Exam Diet (Dec/April/Aug): December 2014 Brief notes on answers:
Module Title: Informatics 1 Functional Programming (first sitting) Exam Diet (Dec/April/Aug): December 2014 Brief notes on answers: -- Full credit is given for fully correct answers. -- Partial credit
COMP3141 Assignment 2
COMP3141 Assignment 2 Haskell-Augmented Regular Expressions (H.A.R.E.) Version 1.2 Liam O Connor Semester 1, 2018 Marking Total of 20 marks (20% of practical component) Due Date Friday, 25th May, 2018,
Behavior-Driven Development in Haskell
Behavior-Driven Development in Haskell a tutorial introduction Simon Hengel Wimdu GmbH simon.hengel@wimdu.com Abstract Several widely used Haskell libraries do not come with automated tests. Test code
Dependently- Typed Programming in GHC. Stephanie Weirich University of Pennsylvania
Dependently- Typed Programming in GHC Stephanie Weirich University of Pennsylvania Simon Peyton Jones Dimitrios Vy0nio0s Brent Yorgey Richard Eisenberg JusHn Hsu Julien CreHn José Pedro Magalhães Iavor
Logic - CM0845 Introduction to Haskell
Logic - CM0845 Introduction to Haskell Diego Alejandro Montoya-Zapata EAFIT University Semester 2016-1 Diego Alejandro Montoya-Zapata (EAFIT University) Logic - CM0845 Introduction to Haskell Semester
Haskell Overview IV (4A) Young Won Lim 10/13/16
(4A) Copyright (c) 2016 Young W. Lim. Permission is granted to copy, distribute and/or modify this document under the terms of the GNU Free Documentation License, Version 1.2 or any later version published
Typed Racket: Racket with Static Types
Typed Racket: Racket with Static Types Version 5.0.2 Sam Tobin-Hochstadt November 6, 2010 Typed Racket is a family of languages, each of which enforce that programs written in the language obey a type
Informatics 1 Functional Programming Lecture 12. Data Abstraction. Don Sannella University of Edinburgh
Informatics 1 Functional Programming Lecture 12 Data Abstraction Don Sannella University of Edinburgh Part I Sets as lists without abstraction We will look again at our four ways of implementing sets.
(ii) Define a function ulh that takes a list xs, and pairs each element with all other elements in xs.
EXAM FUNCTIONAL PROGRAMMING Tuesday the 1st of October 2016, 08.30 h. - 10.30 h. Name: Student number: Before you begin: Do not forget to write down your name and student number above. If necessary, explain
Software System Design and Implementation
Software System Design and Implementation Controlling Effects Gabriele Keller The University of New South Wales School of Computer Science and Engineering Sydney, Australia COMP3141 18s1 Examples of effects
Overview. Declarative Languages D7012E. Overloading. Overloading Polymorphism Subtyping
Overview Declarative Languages D7012E Lecture 4: The Haskell type system Fredrik Bengtsson / Johan Nordlander Overloading & polymorphism Type classes instances of type classes derived type classes Type
Lecture 4: Higher Order Functions
Lecture 4: Higher Order Functions Søren Haagerup Department of Mathematics and Computer Science University of Southern Denmark, Odense September 26, 2017 HIGHER ORDER FUNCTIONS The order of a function
EXTENDED USES OF TEMPLATE META-PROGRAMMING
MAXWELL SWADLING EXTENDED USES OF TEMPLATE META-PROGRAMMING YOW Lambda Jam 2014 EXTENDED META-PROGRAMMING Construct proofs Inference Create extensible data structures Tools: Template Haskell Constraint
Software System Design and Implementation
Software System Design and Implementation Property-based Testing Gabriele Keller The University of New South Wales School of Computer Science and Engineering Sydney, Australia COMP3141 17s1 Testing in
Deriving Generic Functions by Example
Deriving Generic Functions by Example Neil Mitchell www.cs.york.ac.uk/~ndm/derive Generic Functions Operates on many data types Think of equality Comparing two integers, booleans, lists, trees Usually,
Haskell Overview III (3A) Young Won Lim 10/4/16
(3A) Copyright (c) 2016 Young W. Lim. Permission is granted to copy, distribute and/or modify this document under the terms of the GNU Free Documentation License, Version 1.2 or any later version published
Introduction to Programming: Lecture 10
Introduction to Programming: Lecture 10 K Narayan Kumar Chennai Mathematical Institute http://www.cmi.ac.in/~kumar 10 Sep 2012 Organizing functions as Modules Organize functions into modules. Organizing
Towards a general algorithm for path-finding problems
Towards a general algorithm for path-finding problems Juan Carlos Saenz-Carrasco June 12, 2013 Generalities Nowadays, path-finding problems are commonly found in: on the web, in traffic logistic, in operations
IA014: Advanced Functional Programming
IA014: Advanced Functional Programming 8. GADT Generalized Algebraic Data Types (and type extensions) Jan Obdržálek obdrzalek@fi.muni.cz Faculty of Informatics, Masaryk University, Brno Motivation IA014
Haskell Overloading (1) LiU-FP2016: Lecture 8 Type Classes. Haskell Overloading (3) Haskell Overloading (2)
Haskell Overloading (1) LiU-FP2016: Lecture 8 Type Classes Henrik Nilsson University of Nottingham, UK What is the type of (==)? E.g. the following both work: 1 == 2 a == b I.e., (==) can be used to compare
Homework 4 Due Friday, 10/1/10
Homework 4 Due Friday, 10/1/10 Please turn in your homework solutions online at http://www.dci.pomona.edu/tools-bin/cs131upload.php before the beginning of class on the due date. Note that some of the
Haskell Making Our Own Types and Typeclasses
Haskell Making Our Own Types and Typeclasses http://igm.univ-mlv.fr/~vialette/?section=teaching Stéphane Vialette LIGM, Université Paris-Est Marne-la-Vallée January 13, 2015 Making Our Own Types and Typeclasses
Functional Programming TDA 452, DIT 142
Chalmers Göteborgs Universitet 2018-01-11 Examiner: Thomas Hallgren, D&IT, Answering questions at approx 15.00 (or by phone) Functional Programming TDA 452, DIT 142 2018-01-11 14.00 18.00 Samhällsbyggnad
Monads and all that III Applicative Functors. John Hughes Chalmers University/Quviq AB
Monads and all that III Applicative Functors John Hughes Chalmers University/Quviq AB Recall our expression parser expr = do a
Extended Static Checking for Haskell (ESC/Haskell)
Extended Static Checking for Haskell (ESC/Haskell) Dana N. Xu University of Cambridge advised by Simon Peyton Jones Microsoft Research, Cambridge Program Errors Give Headache! Module UserPgm where f ::
PROGRAMMING IN HASKELL. Chapter 5 - List Comprehensions
PROGRAMMING IN HASKELL Chapter 5 - List Comprehensions 0 Set Comprehensions In mathematics, the comprehension notation can be used to construct new sets from old sets. {x 2 x {1...5}} The set {1,4,9,16,25}
Functional Programming Mid-term exam Tuesday 3/10/2017
Functional Programming Mid-term exam Tuesday 3/10/2017 Name: Student number: Before you begin: Do not forget to write down your name and student number above. If necessary, explain your answers in English.
FUNCTIONAL PROGRAMMING NO.9 TYPE AND CLASS. Tatsuya Hagino
1 FUNCTIONAL PROGRAMMING NO.9 TYPE AND CLASS Tatsuya Hagino hagino@sfc.keio.ac.jp 2 Static Type Checking and Type Inference Type a set of values Bool = { True, False } Char = { 'a', 'b',... } Int = {...
Deriving Generic Functions by Example
Deriving Generic Functions by Example Neil Mitchell University of York, UK http://www.cs.york.ac.uk/~ndm/ Abstract. A function is said to be generic if it operates over values of any data type. For example,
Hierarchy in Generic Programming Libraries
Hierarchy in Generic Programming Libraries José Pedro Magalhães 1 and Andres Löh 2 1 jpm@cs.ox.ac.uk. Department of Computer Science, University of Oxford 2 andres@well-typed.com. Well-Typed LLP Abstract.
CSCE 314 Programming Languages
CSCE 314 Programming Languages Final Review Part I Dr. Hyunyoung Lee 1 Programming Language Characteristics Different approaches to describe computations, to instruct computing devices E.g., Imperative,
The Typed Racket Guide
The Typed Racket Guide Version 5.3.6 Sam Tobin-Hochstadt and Vincent St-Amour August 9, 2013 Typed Racket is a family of languages, each of which enforce
Homework 4 Due Midnight, Thursday, 10/2/2014
A possible layout for the entire code is given below : CSCI 131 Fall 2014 Homework 4 Due Midnight, Thursday, 10/2/2014 Please turn in your homework solutions online at http://www.dci.pomona.edu/tools-bin/cs131upload.php
Static Analysis of Haskell
Static Analysis of Haskell Neil Mitchell http://ndmitchell.com Static Analysis is getting insights at compile time Full branch coverage Terminates Doesn t rely on a test suite Types are static analysis.
Haskell & functional programming, some slightly more advanced stuff. Matteo Pradella
Haskell & functional programming, some slightly more advanced stuff Matteo Pradella pradella@elet.polimi.it IEIIT, Consiglio Nazionale delle Ricerche & DEI, Politecnico di Milano PhD course @ UniMi - Feb
Introduction. Wouter Swierstra. Applied functional programming. Faculty of Science Information and Computing Sciences
Introduction Applied functional programming Wouter Swierstra 1 Welcome to the Utrecht AFP Summer School 2017 2 This morning Introduce myself and the other lecturers Overview of the course Basic Haskell
CSCE 314 TAMU Fall CSCE 314: Programming Languages Dr. Flemming Andersen. Haskell Functions
1 CSCE 314: Programming Languages Dr. Flemming Andersen Haskell Functions 2 Outline Defining Functions List Comprehensions Recursion 3 Conditional Expressions As in most programming languages, functions
Data Structures. Datatype. Data structure. Today: Two examples. A model of something that we want to represent in our program
Datastructures Data Structures Datatype A model of something that we want to represent in our program Data structure A particular way of storing data How? Depending on what we want to do with the data
Advanced features of Functional Programming (Haskell)
Advanced features of Functional Programming (Haskell) Polymorphism and overloading January 10, 2017 Monomorphic and polymorphic types A (data) type specifies a set of values. Examples: Bool: the type of
Advanced Type System Features Tom Schrijvers. Leuven Haskell User Group
Advanced Type System Features Tom Schrijvers Leuven Haskell User Group Data Recursion Genericity Schemes Expression Problem Monads GADTs DSLs Type Type Families Classes Lists and Effect Free Other Handlers
Functional Programming
Functional Programming Monadic Prelude Jevgeni Kabanov Department of Computer Science University of Tartu Introduction Previously on Functional Programming Monadic laws Monad class (>>= and return) MonadPlus
Libraries (1A) Young Won Lim 6/5/17
Libraries (1A) Copyright (c) 2016-2017 Young W. Lim. Permission is granted to copy, distribute and/or modify this document under the terms of the GNU Free Documentation License, Version 1.2 or any later
Polymorphism Overview (1A) Young Won Lim 2/20/18
Polymorphism Overview (1A) Copyright (c) 2016-2017 Young W. Lim. Permission is granted to copy, distribute and/or modify this document under the terms of the GNU Free Documentation License, Version 1.2
Programming with Universes, Generically
Programming with Universes, Generically Andres Löh Well-Typed LLP 24 January 2012 An introduction to Agda Agda Functional programming language Static types Dependent types Pure (explicit effects) Total
Simon Peyton Jones (Microsoft Research) JAOO 2009
Simon Peyton Jones (Microsoft Research) JAOO 2009 A statically typed, purely functional language... designed 20 years ago... by a committee... of pointy-headed academics... as a research language. Doesn
Arbitrary-rank polymorphism in (GHC) Haskell
Arbitrary-rank polymorphism in (GHC) Haskell CAS 743 Stephen Forrest 20 March 2006 Damas-Milner Type System A Damas-Milner type system (also called Hindley-Milner) is a traditional type system for functional
A more elegant specification for FRP
A more elegant specification for FRP Conal Elliott LambdaJam 2015 Conal Elliott A more elegant specification for FRP LambdaJam 2015 1 / 20 The story so far Conal Elliott A more elegant specification for
The Book of Types. Type-Level Programming in Haskell. Sandy Maguire
The Book of Types Type-Level Programming in Haskell Sandy Maguire ii Contents NOTICE v 1 Introduction 1 1.1 The Value of Types.......................... 1 2 Terms, Types and Kinds 3 2.1 The Kind System...........................
EDAF40. 2nd June :00-19:00. WRITE ONLY ON ONE SIDE OF THE PAPER - the exams will be scanned in and only the front/ odd pages will be read.
EDAF40 2nd June 2017 14:00-19:00 WRITE ONLY ON ONE SIDE OF THE PAPER - the exams will be scanned in and only the front/ odd pages will be read. DO NOT WRITE WITH OTHER COLOUR THAN BLACK - coloured text
1 The smallest free number
1 The smallest free number Introduction Consider the problem of computing the smallest natural number not in a given finite set X of natural numbers. The problem is a simplification of a common programming
Generic Programming With Dependent Types: II
Generic Programming With Dependent Types: II Generic Haskell in Agda Stephanie Weirich University of Pennsylvania March 2426, 2010 SSGIP Generic-Haskell style generic programming in Agda Dependently-typed
Simply efficient functional reactivity
LambdaPix technical report 2008-01, April 2008; revised 2008-11-18 1 Simply efficient functional reactivity Conal Elliott LambdaPix conal@conal.net Abstract Functional reactive programming (FRP) has simple
Haskell Types COMP360
Haskell Types COMP360 No computer has ever been designed that is ever aware of what it's doing; but most of the time, we aren't either. Marvin Minsky Haskell Programming Assignment A Haskell programming
PROGRAMMING IN HASKELL. CS Chapter 6 - Recursive Functions
PROGRAMMING IN HASKELL CS-205 - Chapter 6 - Recursive Functions 0 Introduction As we have seen, many functions can naturally be defined in terms of other functions. factorial :: Int Int factorial n product
The Algebra of Programming in Haskell
The Algebra of Programming in Haskell Bruno Oliveira The Algebra of Programming in Haskell p.1/21 Datatype Generic Programming - Motivation/Goals The project is to develop a novel mechanism for parameterizing
Simon Peyton Jones Microsoft Research August 2012
Simon Peyton Jones Microsoft Research August 2012 A functional language Purely functional Lazy Statically typed Designed 1988-1990 By a committee For research, teaching, and practical use Geeks Practitioners
Introduction to Programming: Lecture 6
Introduction to Programming: Lecture 6 K Narayan Kumar Chennai Mathematical Institute http://www.cmi.ac.in/~kumar 28 August 2012 Example: initial segments Write a Haskell function initsegs which returns
CSc 372. Comparative Programming Languages. 18 : Haskell Type Classes. Department of Computer Science University of Arizona
1/20 CSc 372 Comparative Programming Languages 18 : Haskell Type Classes Department of Computer Science University of Arizona collberg@gmail.com Copyright c 2013 Christian Collberg 2/20 Type Classes Type
Papers we love - Utrecht
Papers we love - Utrecht QuickCheck Wouter Swierstra 1 Requirements for a topic A paper that I love 2 Requirements for a topic A paper that I love A paper that is interesting to academics and developers
College Functors, Applicatives
College 2016-2017 Functors, Applicatives Wouter Swierstra with a bit of Jurriaan Hage Utrecht University Contents So far, we have seen monads define a common abstraction over many programming patterns.
Usage of Generic Programming on Hackage Experience report
Usage of Generic Programming on Hackage Experience report Nikolaos Bezirgiannis Johan Jeuring Sean Leather Technical Report UU-CS-2013-014 July 2013 Department of Information and Computing Sciences Utrecht
Monads and all that I. Monads. John Hughes Chalmers University/Quviq AB
Monads and all that I. Monads John Hughes Chalmers University/Quviq AB Binary Trees in Haskell data Tree a = Leaf a Branch (Tree a) (Tree a) deriving (Eq,Show) Cf Coq: Inductive tree (A:Set) : Set := leaf
Ordered Pairs, Products, Sets versus Lists, Lambda Abstraction, Database Query
Ordered Pairs, Products, Sets versus Lists, Lambda Abstraction, Database Query Jan van Eijck May 2, 2003 Abstract Ordered pairs, products, from sets to lists, from lists to sets. Next, we take a further
Haskell An Introduction
Haskell An Introduction What is Haskell? General purpose Purely functional No function can have side-effects IO is done using special types Lazy Strongly typed Polymorphic types Concise and elegant A First