├── README.md ├── dissertations ├── [LS] Purely Functional Data Structures.pdf └── [LS] Type Inference, Haskell and Dependent Types.pdf ├── functional-pearls ├── A SQL to C Compiler in 500 Lines of Code.pdf ├── A Smart View on Datatypes.pdf ├── Bidirectionalization for Free!.pdf ├── Fun With Semirings.pdf ├── Hindley-Milner Elaboration in Applicative Style.pdf ├── I Am Not a Number, I Am a Free Variable.pdf ├── Trouble Shared is Trouble Halved.pdf ├── Two can keep a secret, if one of them uses Haskell.pdf ├── Using Circular Programming for Higher-Order Syntax.pdf └── When Maybe is not good enough.pdf ├── lecture-notes └── Distributors at Work.pdf └── papers ├── 1ML - Core and modules united (F-ing first-class modules).pdf ├── A Concurrency Monad Based on Constructor Primitives.pdf ├── A Direct Algorithm for Type Inference in the Rank 2 Fragment of the Second-Order Lambda-Calculus.pdf ├── A Fast Compiler for NetKAT.pdf ├── A Generalization of the Trie Data Structure.pdf ├── A Generic Abstract Syntax Model for Embedded Languages.pdf ├── A Generic Deriving Mechanism for Haskell.pdf ├── A History of Haskell - Being Lazy With Class.pdf ├── A Library for Light-Weight Information-Flow Security in Haskell.pdf ├── A Library for Secure Multi-threaded Information Flow in Haskell.pdf ├── A Lightweight Interactive Debugger for Haskell.pdf ├── A Monad for Deterministic Parallelism.pdf ├── A New Notation for Arrows.pdf ├── A Predictable Unification Algorithm for Coq Featuring Universe Polymorphism and Overloading.pdf ├── A Relational Framework for Higher-Order Shape Analysis.pdf ├── A Seamless, Client-Centric Programming Model for Type Safe Web Applications.pdf ├── A Simple Semantics for Haskell Overloading.pdf ├── A Theory of Gradual Effect Systems.pdf ├── A Theory of Information-Flow Labels.pdf ├── A Verified Information-Flow Architecture (Long Version).pdf ├── A short cut to deforestation.pdf ├── Abstract Syntax Graphs for Domain Specific Languages.pdf ├── Accelerating Haskell Array Codes with Multicore GPUs.pdf ├── Algebraic Effects and Effect Handlers for Idioms and Arrows.pdf ├── An Extensible Dynamically-Typed Hierarchy of Exceptions.pdf ├── Applicative Bidirectional Programming with Lenses.pdf ├── Arity-Generic Datatype-Generic Programming.pdf ├── Arrows are Strong Monads.pdf ├── Associated Type Synonyms.pdf ├── Asynchronous Exceptions in Haskell.pdf ├── Automatic Refunctionalization to a Language with Copattern Matching - With Applications to the Expression Problem.pdf ├── Backpack - Retrofitting Haskell with Interfaces.pdf ├── Backpack to Work - Towards Practical Mixin Linking for Haskell.pdf ├── Backtracking, Interleaving, and Terminating Monad Transformers.pdf ├── Beautiful Differentiation.pdf ├── Behavioral Software Contracts (keynote).pdf ├── Binders Unbound.pdf ├── Blame Assignment for Higher-Order Contracts with Intersection and Union.pdf ├── Bounded Refinement Types.pdf ├── Boxy Types - Inference for Higher-Rank Types and Impredicativity.pdf ├── Building Embedded Systems with Embedded DSLs.pdf ├── Building Secure systems with LIO (Demo).pdf ├── Call Arity.pdf ├── Call-by-Value is Dual to Call-by-Name.pdf ├── Causal Commutative Arrows and their Optimizations.pdf ├── Causality for Free! Parametricity Implies Causality for Functional Reactive Programming.pdf ├── Certified Symbolic Management of Financial Multi-Party Contracts.pdf ├── Closed Type Families with Overlapping Equations (Extended Edition).pdf ├── Codata and Comonads in Haskell.pdf ├── Combinators for Impure yet Hygenic Code Generation.pdf ├── Comparing the performance of concurrent linked-list implementations in Haskell.pdf ├── Compiling Without Continuations (Join Points).pdf ├── Compiling with Continuations, Continued.pdf ├── Composable Memory Transactions.pdf ├── Compositional Data Types.pdf ├── Compositional Semantics for Composable Continuations.pdf ├── Comprehensive Comprehensions - Comprehensions with ‘Order by’ and ‘Group by’.pdf ├── Computational Lambda-Calculus and Monads.pdf ├── Denotational design with type class morphisms (extended version).pdf ├── Dependently Typed Programming with Singletons.pdf ├── Domain Specific Embedded Compilers.pdf ├── Down with the bureaucracy of syntax! Pattern matching for classical linear logic.pdf ├── Dynamic Witnesses for Static Type Errors.pdf ├── Effect Handlers in Scope.pdf ├── Efficient Communication and Collection with Compact Normal Forms.pdf ├── Elaborating Evaluation-Order Polymorphism.pdf ├── Embedding Effect Systems in Haskell.pdf ├── Encoding Information Flow in Haskell.pdf ├── Expressing Contract Monitors as Patterns of Communication.pdf ├── Extending the Haskell Foreign Function Interface with Concurrency.pdf ├── Extensible Effects - An Alternative to Monad Transformers.pdf ├── FPH - First-class Polymorphism for Haskell.pdf ├── Faster Laziness Using Dynamic Pointer Tagging.pdf ├── First-class Isomorphic Specialization by Staged Evaluation.pdf ├── Fixing Idioms.pdf ├── Flexible Dynamic Information Flow Control in Haskell.pdf ├── Flipping Fold, Reformulating Reduction.pdf ├── Focusing on Binding and Computation.pdf ├── Focusing on Pattern Matching.pdf ├── Foreign Inline Code.pdf ├── Foundational Extensible Corecursion - A Proof Assistant Perspective.pdf ├── Foundations for Structured Programming with GADTs.pdf ├── Free Applicative Functors.pdf ├── Freer Monads, More Extensible Effects.pdf ├── Functional Programming for Dynamic and Large Data with Self-Adjusting Computation.pdf ├── Functional Programming with Structured Graphs.pdf ├── Functional Reactive Animation.pdf ├── Functional Reactive Programming With Liveness Guarantees.pdf ├── Functional Reactive Programming from First Principles.pdf ├── Functional Reactive Programming, Continued.pdf ├── Functional Reactive Types.pdf ├── GADTS Meet Their Match.pdf ├── Generating Performance Portable Code using Rewrite Rules - From High-level Functional Expressions to High-Performance OpenCL Code.pdf ├── Generic Constructors and Eliminators from Descriptions.pdf ├── Generic Programming for Indexed Datatypes.pdf ├── Giving Haskell a Promotion.pdf ├── HLIO - Mixing Static and Dynamic Typing for Information-Flow Control in Haskell.pdf ├── Haddock, A Haskell Documentation Tool.pdf ├── Haskell Session Types with (Almost) No Class.pdf ├── Haskell on a Shared-Memory Multiprocessor.pdf ├── Hasochism - The Pleasure and Pain of Dependently Typed Haskell Programming.pdf ├── Higher-Order Abstract Syntax.pdf ├── Higher-Order Functional Reactive Programming without Spacetime Leaks.pdf ├── Homotopical Patch Theory.pdf ├── Hoopl - A Modular, Reusable Library for Dataflow Analysis and Transformation.pdf ├── How to Keep Your Neighbours in Order.pdf ├── How to make ad-hoc polymorphism less ad hoc.pdf ├── Hygienic Resugaring of Compositional Desugaring.pdf ├── Indentation-Sensitive Parsing for Parsec.pdf ├── Indeterminate Behavior with Determinate Semantics in Parallel Programs.pdf ├── Information Flow Enforcement in Monadic Libraries.pdf ├── Lazy Functional State Threads.pdf ├── Learning Refinement Types.pdf ├── Levity Polymorphism.pdf ├── Lightweight Concurrency Primitives for GHC.pdf ├── Lightweight Monadic Regions.pdf ├── Maximal Sharing in the Lambda Calculus with letrec.pdf ├── Mio - A High-Performance Multicore IO Manager for GHC.pdf ├── Monad Transformers and Modular Interpreters.pdf ├── Monadic Functional Reactive Programming.pdf ├── Monads, Zippers, and Views.pdf ├── Multicore Garbage Collection with Local Heaps.pdf ├── Non-Stop Haskell.pdf ├── Noninterference for Free.pdf ├── Object-Oriented Style Overloading for Haskell.pdf ├── On Understanding Data Abstraction, Revisited.pdf ├── Optimising Purely Functional GPU Programs.pdf ├── Ornaments in Practice.pdf ├── Outline of a Paraconsistent Category Theory.pdf ├── Parallel Generational-Copying Garbage Collection with a Block-Structured Heap.pdf ├── Parametric Higher-Order Abstract Syntax for Mechanized Semantics.pdf ├── Parsing Expression Grammars - A Recognition-Based Syntactic Foundation.pdf ├── Partial Aborts for Transactions via First-Class Continuations.pdf ├── Pattern Matching Without K.pdf ├── Pilsner - A Compositionally Verified Compiler for a Higher-Order Imperative Language.pdf ├── Polish Parsers, Step by Step.pdf ├── Polymorphic Embedding of DSLs.pdf ├── Practical Principled FRP - Forget the past, change the future, FRPNow!.pdf ├── Practical SMT-Based Type Error Localization.pdf ├── Practical and Effective Higher-Order Optimizations.pdf ├── Promoting Functions to Type Families in Haskell.pdf ├── Proof Carrying-Based Information Flow Tracking for Data Secrecy Protection and Hardware Trust.pdf ├── Propositions as Types.pdf ├── Push-Pull Functional Reactive Programming.pdf ├── Putting Type Annotations to Work.pdf ├── Pycket - A Tracing JIT For a Functional Language.pdf ├── RRB Vector - Efficient Immutable Vectors.pdf ├── Refinement Types For Haskell.pdf ├── Reflection without Remorse - Revealing a hidden sequence to speed up monadic reflection.pdf ├── Representing Monads.pdf ├── Rethinking Prolog.pdf ├── Runtime Support for Multicore Haskell.pdf ├── Safe Coercions.pdf ├── Safe Functional Reactive Programming through Dependent Types.pdf ├── Safe Haskell.pdf ├── Scoping Rules on a Platter.pdf ├── Self-Representation in Girard's System U.pdf ├── Session Types in Haskell - Updating Message Passing for the 21st Century.pdf ├── Settable and Non-Interfering Signal Functions for FRP.pdf ├── Shake Before Building - Replacing Make with Haskell.pdf ├── Simple Unification-based Type Inference for GADTs.pdf ├── Simply Easy! - An Implementation of a Dependently Typed Lambda Calculus.pdf ├── Simply efficient functional reactivity.pdf ├── Simulating Qualified Class Constraints.pdf ├── SmallCheck and Lazy SmallCheck.pdf ├── Soft Contract Verification.pdf ├── Sorting With Bialgebras and Distributive Laws.pdf ├── Spans of Lenses.pdf ├── Stream Fusion - From Lists of Streams to Nothing at All.pdf ├── Strongly Typed Heterogeneous Collections.pdf ├── Structures for Structural Recursion.pdf ├── Symmetric Lenses.pdf ├── System FC With Explicit Kind Equality.pdf ├── Tagless Staged Interpreters for Typed Languages.pdf ├── Template Meta-programming for Haskell.pdf ├── Temporal Logic with 'Until', Functional Reactive Programming with Processes, and Concrete Process Categories.pdf ├── The Derivative of a Regular Type is its Type of One-Hole Contexts.pdf ├── The Gentle Art of Levitation.pdf ├── The HdpH DSLs for Scalable Reliable Computation.pdf ├── The Next 1100 Haskell Programmers.pdf ├── The Power of Pi.pdf ├── The Two Dualities of Computation - Negative and Fractional Types.pdf ├── The Yampa Arcade.pdf ├── Theorems for free!.pdf ├── There is no Fork - an Abstraction for Efficient, Concurrent, and Concise Data Access.pdf ├── Total Parser Combinators.pdf ├── Towards Haskell in the Cloud.pdf ├── Towards Typing for Small-Step Direct Reflection.pdf ├── True Sums of Products.pdf ├── Type Checking with Open Type Functions.pdf ├── Type Inference for the Spine View of Data.pdf ├── Type classes - an exploration of the design space.pdf ├── Type-Based Parametric Analysis of Program Families.pdf ├── Type-Safe Observable Sharing in Haskell.pdf ├── Type-checking Polymorphic Units for Astrophysics Reserach in Haskell.pdf ├── Type-indexed data types.pdf ├── Type-level web APIs with Servant.pdf ├── Type-safe runtime code generation with LLVM.pdf ├── Typed Faceted Values for Secure Information Flow in Haskell.pdf ├── Unembedding Domain Specific Languages.pdf ├── Verification of Information Flow and Access Control Policies with Dependent Types.pdf ├── Which simple types have a unique inhabitant.pdf ├── Witnesses and Open Witnesses.pdf ├── Worker-Wrapper-Makes it-Faster.pdf ├── XQuery and Static Typing - Tackling the Problem of Backward Axes.pdf ├── Yi - An Editor in Haskell for Haskell.pdf ├── [LS] A Fast, Minimal Memory, Consistent Hash Algorithm.pdf ├── [LS] Adventures in Three Monads.pdf ├── [LS] Arrows and Computation.pdf ├── [LS] Asymptotic Improvement of Computations over Free Monads.pdf ├── [LS] Automatic Skeletons In Template Haskell.pdf ├── [LS] Boxes Go Bananas - Encoding Higher-Order Abstract Syntax with Parametric Polymorphism (Extended Version).pdf ├── [LS] Call-by-Value is Dual to Call-by-Name, Reloaded.pdf ├── [LS] Comonadic Notions of Computation.pdf ├── [LS] Composing Monads.pdf ├── [LS] Comprehending Monads.pdf ├── [LS] Dependent Types - Easy as PIE.pdf ├── [LS] Efficient and Compositional Evaluation of Untyped Expressions.pdf ├── [LS] Finally Tagless, Partially Evaluated.pdf ├── [LS] Free Applicative Functors.pdf ├── [LS] Fun with type functions.pdf ├── [LS] Functional Differentiation of Computer Programs.pdf ├── [LS] Functional Programming with Bananas, Lenses, Envelopes and Barbed Wire.pdf ├── [LS] Idioms are oblivious, arrows are meticulous, monads are promiscuous.pdf ├── [LS] Implementing Lazy Functional Languages on Stock Hardware - The Spineless Tagless G-machine.pdf ├── [LS] Kan Extensions for Program Optimisation; Or - Art and Dan Explain an Old Trick.pdf ├── [LS] Lock Free Data Structures using STM in Haskell.pdf ├── [LS] Monadic constraint programming.pdf ├── [LS] Monads and composable continuations.pdf ├── [LS] Monads for functional programming.pdf ├── [LS] Nested Datatypes.pdf ├── [LS] NixOS - A Purely Functional Linux Distribution.pdf ├── [LS] Notions of Computation as Monoids.pdf ├── [LS] Optimising Embedded DSLs using Template Haskell.pdf ├── [LS] Parameterized Notions of Computation.pdf ├── [LS] Practical type inference for arbitrary-rank type.pdf ├── [LS] Programming with Arrows.pdf ├── [LS] Recursive Coalgebras from Comonads.pdf ├── [LS] Tackling the Awkward Squad - monadic input-output, concurrency, exceptions, and foreign-language calls in Haskell.pdf ├── [LS] The Arrow Calculus.pdf ├── [LS] The Design of a Pretty Printing Library.pdf ├── [LS] The Dual of Substitution is Redecoration.pdf ├── [LS] The Essence of Dataflow Programming.pdf ├── [LS] The Essence of the Iterator Pattern.pdf ├── [LS] The Genuine Sieve of Eratosthenes.pdf ├── [LS] The essence of functional programming.pdf ├── [LS] The marriage of effects and monads.pdf ├── [LS] Total Functional Programming.pdf └── [LS] Why Functional Programming Matters.pdf /README.md: -------------------------------------------------------------------------------- https://raw.githubusercontent.com/beerendlauwers/haskell-papers-ereader/HEAD/README.md -------------------------------------------------------------------------------- /dissertations/[LS] Purely Functional Data Structures.pdf: -------------------------------------------------------------------------------- https://raw.githubusercontent.com/beerendlauwers/haskell-papers-ereader/HEAD/dissertations/[LS] Purely Functional Data Structures.pdf -------------------------------------------------------------------------------- /dissertations/[LS] Type Inference, Haskell and Dependent Types.pdf: -------------------------------------------------------------------------------- https://raw.githubusercontent.com/beerendlauwers/haskell-papers-ereader/HEAD/dissertations/[LS] Type Inference, Haskell and Dependent Types.pdf -------------------------------------------------------------------------------- /functional-pearls/A SQL to C Compiler in 500 Lines of Code.pdf: -------------------------------------------------------------------------------- https://raw.githubusercontent.com/beerendlauwers/haskell-papers-ereader/HEAD/functional-pearls/A SQL to C Compiler in 500 Lines of Code.pdf -------------------------------------------------------------------------------- /functional-pearls/A Smart View on Datatypes.pdf: -------------------------------------------------------------------------------- https://raw.githubusercontent.com/beerendlauwers/haskell-papers-ereader/HEAD/functional-pearls/A Smart View on Datatypes.pdf -------------------------------------------------------------------------------- /functional-pearls/Bidirectionalization for Free!.pdf: -------------------------------------------------------------------------------- https://raw.githubusercontent.com/beerendlauwers/haskell-papers-ereader/HEAD/functional-pearls/Bidirectionalization for Free!.pdf -------------------------------------------------------------------------------- /functional-pearls/Fun With Semirings.pdf: -------------------------------------------------------------------------------- https://raw.githubusercontent.com/beerendlauwers/haskell-papers-ereader/HEAD/functional-pearls/Fun With Semirings.pdf -------------------------------------------------------------------------------- /functional-pearls/Hindley-Milner Elaboration in Applicative Style.pdf: -------------------------------------------------------------------------------- https://raw.githubusercontent.com/beerendlauwers/haskell-papers-ereader/HEAD/functional-pearls/Hindley-Milner Elaboration in Applicative Style.pdf -------------------------------------------------------------------------------- /functional-pearls/I Am Not a Number, I Am a Free Variable.pdf: -------------------------------------------------------------------------------- https://raw.githubusercontent.com/beerendlauwers/haskell-papers-ereader/HEAD/functional-pearls/I Am Not a Number, I Am a Free Variable.pdf -------------------------------------------------------------------------------- /functional-pearls/Trouble Shared is Trouble Halved.pdf: -------------------------------------------------------------------------------- https://raw.githubusercontent.com/beerendlauwers/haskell-papers-ereader/HEAD/functional-pearls/Trouble Shared is Trouble Halved.pdf -------------------------------------------------------------------------------- /functional-pearls/Two can keep a secret, if one of them uses Haskell.pdf: -------------------------------------------------------------------------------- https://raw.githubusercontent.com/beerendlauwers/haskell-papers-ereader/HEAD/functional-pearls/Two can keep a secret, if one of them uses Haskell.pdf -------------------------------------------------------------------------------- /functional-pearls/Using Circular Programming for Higher-Order Syntax.pdf: -------------------------------------------------------------------------------- https://raw.githubusercontent.com/beerendlauwers/haskell-papers-ereader/HEAD/functional-pearls/Using Circular Programming for Higher-Order Syntax.pdf -------------------------------------------------------------------------------- /functional-pearls/When Maybe is not good enough.pdf: -------------------------------------------------------------------------------- https://raw.githubusercontent.com/beerendlauwers/haskell-papers-ereader/HEAD/functional-pearls/When Maybe is not good enough.pdf -------------------------------------------------------------------------------- /lecture-notes/Distributors at Work.pdf: -------------------------------------------------------------------------------- https://raw.githubusercontent.com/beerendlauwers/haskell-papers-ereader/HEAD/lecture-notes/Distributors at Work.pdf -------------------------------------------------------------------------------- /papers/1ML - Core and modules united (F-ing first-class modules).pdf: -------------------------------------------------------------------------------- https://raw.githubusercontent.com/beerendlauwers/haskell-papers-ereader/HEAD/papers/1ML - Core and modules united (F-ing first-class modules).pdf -------------------------------------------------------------------------------- /papers/A Concurrency Monad Based on Constructor Primitives.pdf: -------------------------------------------------------------------------------- https://raw.githubusercontent.com/beerendlauwers/haskell-papers-ereader/HEAD/papers/A Concurrency Monad Based on Constructor Primitives.pdf -------------------------------------------------------------------------------- /papers/A Direct Algorithm for Type Inference in the Rank 2 Fragment of the Second-Order Lambda-Calculus.pdf: -------------------------------------------------------------------------------- https://raw.githubusercontent.com/beerendlauwers/haskell-papers-ereader/HEAD/papers/A Direct Algorithm for Type Inference in the Rank 2 Fragment of the Second-Order Lambda-Calculus.pdf -------------------------------------------------------------------------------- /papers/A Fast Compiler for NetKAT.pdf: -------------------------------------------------------------------------------- https://raw.githubusercontent.com/beerendlauwers/haskell-papers-ereader/HEAD/papers/A Fast Compiler for NetKAT.pdf -------------------------------------------------------------------------------- /papers/A Generalization of the Trie Data Structure.pdf: -------------------------------------------------------------------------------- https://raw.githubusercontent.com/beerendlauwers/haskell-papers-ereader/HEAD/papers/A Generalization of the Trie Data Structure.pdf -------------------------------------------------------------------------------- /papers/A Generic Abstract Syntax Model for Embedded Languages.pdf: -------------------------------------------------------------------------------- https://raw.githubusercontent.com/beerendlauwers/haskell-papers-ereader/HEAD/papers/A Generic Abstract Syntax Model for Embedded Languages.pdf -------------------------------------------------------------------------------- /papers/A Generic Deriving Mechanism for Haskell.pdf: -------------------------------------------------------------------------------- https://raw.githubusercontent.com/beerendlauwers/haskell-papers-ereader/HEAD/papers/A Generic Deriving Mechanism for Haskell.pdf -------------------------------------------------------------------------------- /papers/A History of Haskell - Being Lazy With Class.pdf: -------------------------------------------------------------------------------- https://raw.githubusercontent.com/beerendlauwers/haskell-papers-ereader/HEAD/papers/A History of Haskell - Being Lazy With Class.pdf -------------------------------------------------------------------------------- /papers/A Library for Light-Weight Information-Flow Security in Haskell.pdf: -------------------------------------------------------------------------------- https://raw.githubusercontent.com/beerendlauwers/haskell-papers-ereader/HEAD/papers/A Library for Light-Weight Information-Flow Security in Haskell.pdf -------------------------------------------------------------------------------- /papers/A Library for Secure Multi-threaded Information Flow in Haskell.pdf: -------------------------------------------------------------------------------- https://raw.githubusercontent.com/beerendlauwers/haskell-papers-ereader/HEAD/papers/A Library for Secure Multi-threaded Information Flow in Haskell.pdf -------------------------------------------------------------------------------- /papers/A Lightweight Interactive Debugger for Haskell.pdf: -------------------------------------------------------------------------------- https://raw.githubusercontent.com/beerendlauwers/haskell-papers-ereader/HEAD/papers/A Lightweight Interactive Debugger for Haskell.pdf -------------------------------------------------------------------------------- /papers/A Monad for Deterministic Parallelism.pdf: -------------------------------------------------------------------------------- https://raw.githubusercontent.com/beerendlauwers/haskell-papers-ereader/HEAD/papers/A Monad for Deterministic Parallelism.pdf -------------------------------------------------------------------------------- /papers/A New Notation for Arrows.pdf: -------------------------------------------------------------------------------- https://raw.githubusercontent.com/beerendlauwers/haskell-papers-ereader/HEAD/papers/A New Notation for Arrows.pdf -------------------------------------------------------------------------------- /papers/A Predictable Unification Algorithm for Coq Featuring Universe Polymorphism and Overloading.pdf: -------------------------------------------------------------------------------- https://raw.githubusercontent.com/beerendlauwers/haskell-papers-ereader/HEAD/papers/A Predictable Unification Algorithm for Coq Featuring Universe Polymorphism and Overloading.pdf -------------------------------------------------------------------------------- /papers/A Relational Framework for Higher-Order Shape Analysis.pdf: -------------------------------------------------------------------------------- https://raw.githubusercontent.com/beerendlauwers/haskell-papers-ereader/HEAD/papers/A Relational Framework for Higher-Order Shape Analysis.pdf -------------------------------------------------------------------------------- /papers/A Seamless, Client-Centric Programming Model for Type Safe Web Applications.pdf: -------------------------------------------------------------------------------- https://raw.githubusercontent.com/beerendlauwers/haskell-papers-ereader/HEAD/papers/A Seamless, Client-Centric Programming Model for Type Safe Web Applications.pdf -------------------------------------------------------------------------------- /papers/A Simple Semantics for Haskell Overloading.pdf: -------------------------------------------------------------------------------- https://raw.githubusercontent.com/beerendlauwers/haskell-papers-ereader/HEAD/papers/A Simple Semantics for Haskell Overloading.pdf -------------------------------------------------------------------------------- /papers/A Theory of Gradual Effect Systems.pdf: -------------------------------------------------------------------------------- https://raw.githubusercontent.com/beerendlauwers/haskell-papers-ereader/HEAD/papers/A Theory of Gradual Effect Systems.pdf -------------------------------------------------------------------------------- /papers/A Theory of Information-Flow Labels.pdf: -------------------------------------------------------------------------------- https://raw.githubusercontent.com/beerendlauwers/haskell-papers-ereader/HEAD/papers/A Theory of Information-Flow Labels.pdf -------------------------------------------------------------------------------- /papers/A Verified Information-Flow Architecture (Long Version).pdf: -------------------------------------------------------------------------------- https://raw.githubusercontent.com/beerendlauwers/haskell-papers-ereader/HEAD/papers/A Verified Information-Flow Architecture (Long Version).pdf -------------------------------------------------------------------------------- /papers/A short cut to deforestation.pdf: -------------------------------------------------------------------------------- https://raw.githubusercontent.com/beerendlauwers/haskell-papers-ereader/HEAD/papers/A short cut to deforestation.pdf -------------------------------------------------------------------------------- /papers/Abstract Syntax Graphs for Domain Specific Languages.pdf: -------------------------------------------------------------------------------- https://raw.githubusercontent.com/beerendlauwers/haskell-papers-ereader/HEAD/papers/Abstract Syntax Graphs for Domain Specific Languages.pdf -------------------------------------------------------------------------------- /papers/Accelerating Haskell Array Codes with Multicore GPUs.pdf: -------------------------------------------------------------------------------- https://raw.githubusercontent.com/beerendlauwers/haskell-papers-ereader/HEAD/papers/Accelerating Haskell Array Codes with Multicore GPUs.pdf -------------------------------------------------------------------------------- /papers/Algebraic Effects and Effect Handlers for Idioms and Arrows.pdf: -------------------------------------------------------------------------------- https://raw.githubusercontent.com/beerendlauwers/haskell-papers-ereader/HEAD/papers/Algebraic Effects and Effect Handlers for Idioms and Arrows.pdf -------------------------------------------------------------------------------- /papers/An Extensible Dynamically-Typed Hierarchy of Exceptions.pdf: -------------------------------------------------------------------------------- https://raw.githubusercontent.com/beerendlauwers/haskell-papers-ereader/HEAD/papers/An Extensible Dynamically-Typed Hierarchy of Exceptions.pdf -------------------------------------------------------------------------------- /papers/Applicative Bidirectional Programming with Lenses.pdf: -------------------------------------------------------------------------------- https://raw.githubusercontent.com/beerendlauwers/haskell-papers-ereader/HEAD/papers/Applicative Bidirectional Programming with Lenses.pdf -------------------------------------------------------------------------------- /papers/Arity-Generic Datatype-Generic Programming.pdf: -------------------------------------------------------------------------------- https://raw.githubusercontent.com/beerendlauwers/haskell-papers-ereader/HEAD/papers/Arity-Generic Datatype-Generic Programming.pdf -------------------------------------------------------------------------------- /papers/Arrows are Strong Monads.pdf: -------------------------------------------------------------------------------- https://raw.githubusercontent.com/beerendlauwers/haskell-papers-ereader/HEAD/papers/Arrows are Strong Monads.pdf -------------------------------------------------------------------------------- /papers/Associated Type Synonyms.pdf: -------------------------------------------------------------------------------- https://raw.githubusercontent.com/beerendlauwers/haskell-papers-ereader/HEAD/papers/Associated Type Synonyms.pdf -------------------------------------------------------------------------------- /papers/Asynchronous Exceptions in Haskell.pdf: -------------------------------------------------------------------------------- https://raw.githubusercontent.com/beerendlauwers/haskell-papers-ereader/HEAD/papers/Asynchronous Exceptions in Haskell.pdf -------------------------------------------------------------------------------- /papers/Automatic Refunctionalization to a Language with Copattern Matching - With Applications to the Expression Problem.pdf: -------------------------------------------------------------------------------- https://raw.githubusercontent.com/beerendlauwers/haskell-papers-ereader/HEAD/papers/Automatic Refunctionalization to a Language with Copattern Matching - With Applications to the Expression Problem.pdf -------------------------------------------------------------------------------- /papers/Backpack - Retrofitting Haskell with Interfaces.pdf: -------------------------------------------------------------------------------- https://raw.githubusercontent.com/beerendlauwers/haskell-papers-ereader/HEAD/papers/Backpack - Retrofitting Haskell with Interfaces.pdf -------------------------------------------------------------------------------- /papers/Backpack to Work - Towards Practical Mixin Linking for Haskell.pdf: -------------------------------------------------------------------------------- https://raw.githubusercontent.com/beerendlauwers/haskell-papers-ereader/HEAD/papers/Backpack to Work - Towards Practical Mixin Linking for Haskell.pdf -------------------------------------------------------------------------------- /papers/Backtracking, Interleaving, and Terminating Monad Transformers.pdf: -------------------------------------------------------------------------------- https://raw.githubusercontent.com/beerendlauwers/haskell-papers-ereader/HEAD/papers/Backtracking, Interleaving, and Terminating Monad Transformers.pdf -------------------------------------------------------------------------------- /papers/Beautiful Differentiation.pdf: -------------------------------------------------------------------------------- https://raw.githubusercontent.com/beerendlauwers/haskell-papers-ereader/HEAD/papers/Beautiful Differentiation.pdf -------------------------------------------------------------------------------- /papers/Behavioral Software Contracts (keynote).pdf: -------------------------------------------------------------------------------- https://raw.githubusercontent.com/beerendlauwers/haskell-papers-ereader/HEAD/papers/Behavioral Software Contracts (keynote).pdf -------------------------------------------------------------------------------- /papers/Binders Unbound.pdf: -------------------------------------------------------------------------------- https://raw.githubusercontent.com/beerendlauwers/haskell-papers-ereader/HEAD/papers/Binders Unbound.pdf -------------------------------------------------------------------------------- /papers/Blame Assignment for Higher-Order Contracts with Intersection and Union.pdf: -------------------------------------------------------------------------------- https://raw.githubusercontent.com/beerendlauwers/haskell-papers-ereader/HEAD/papers/Blame Assignment for Higher-Order Contracts with Intersection and Union.pdf -------------------------------------------------------------------------------- /papers/Bounded Refinement Types.pdf: -------------------------------------------------------------------------------- https://raw.githubusercontent.com/beerendlauwers/haskell-papers-ereader/HEAD/papers/Bounded Refinement Types.pdf -------------------------------------------------------------------------------- /papers/Boxy Types - Inference for Higher-Rank Types and Impredicativity.pdf: -------------------------------------------------------------------------------- https://raw.githubusercontent.com/beerendlauwers/haskell-papers-ereader/HEAD/papers/Boxy Types - Inference for Higher-Rank Types and Impredicativity.pdf -------------------------------------------------------------------------------- /papers/Building Embedded Systems with Embedded DSLs.pdf: -------------------------------------------------------------------------------- https://raw.githubusercontent.com/beerendlauwers/haskell-papers-ereader/HEAD/papers/Building Embedded Systems with Embedded DSLs.pdf -------------------------------------------------------------------------------- /papers/Building Secure systems with LIO (Demo).pdf: -------------------------------------------------------------------------------- https://raw.githubusercontent.com/beerendlauwers/haskell-papers-ereader/HEAD/papers/Building Secure systems with LIO (Demo).pdf -------------------------------------------------------------------------------- /papers/Call Arity.pdf: -------------------------------------------------------------------------------- https://raw.githubusercontent.com/beerendlauwers/haskell-papers-ereader/HEAD/papers/Call Arity.pdf -------------------------------------------------------------------------------- /papers/Call-by-Value is Dual to Call-by-Name.pdf: -------------------------------------------------------------------------------- https://raw.githubusercontent.com/beerendlauwers/haskell-papers-ereader/HEAD/papers/Call-by-Value is Dual to Call-by-Name.pdf -------------------------------------------------------------------------------- /papers/Causal Commutative Arrows and their Optimizations.pdf: -------------------------------------------------------------------------------- https://raw.githubusercontent.com/beerendlauwers/haskell-papers-ereader/HEAD/papers/Causal Commutative Arrows and their Optimizations.pdf -------------------------------------------------------------------------------- /papers/Causality for Free! Parametricity Implies Causality for Functional Reactive Programming.pdf: -------------------------------------------------------------------------------- https://raw.githubusercontent.com/beerendlauwers/haskell-papers-ereader/HEAD/papers/Causality for Free! Parametricity Implies Causality for Functional Reactive Programming.pdf -------------------------------------------------------------------------------- /papers/Certified Symbolic Management of Financial Multi-Party Contracts.pdf: -------------------------------------------------------------------------------- https://raw.githubusercontent.com/beerendlauwers/haskell-papers-ereader/HEAD/papers/Certified Symbolic Management of Financial Multi-Party Contracts.pdf -------------------------------------------------------------------------------- /papers/Closed Type Families with Overlapping Equations (Extended Edition).pdf: -------------------------------------------------------------------------------- https://raw.githubusercontent.com/beerendlauwers/haskell-papers-ereader/HEAD/papers/Closed Type Families with Overlapping Equations (Extended Edition).pdf -------------------------------------------------------------------------------- /papers/Codata and Comonads in Haskell.pdf: -------------------------------------------------------------------------------- https://raw.githubusercontent.com/beerendlauwers/haskell-papers-ereader/HEAD/papers/Codata and Comonads in Haskell.pdf -------------------------------------------------------------------------------- /papers/Combinators for Impure yet Hygenic Code Generation.pdf: -------------------------------------------------------------------------------- https://raw.githubusercontent.com/beerendlauwers/haskell-papers-ereader/HEAD/papers/Combinators for Impure yet Hygenic Code Generation.pdf -------------------------------------------------------------------------------- /papers/Comparing the performance of concurrent linked-list implementations in Haskell.pdf: -------------------------------------------------------------------------------- https://raw.githubusercontent.com/beerendlauwers/haskell-papers-ereader/HEAD/papers/Comparing the performance of concurrent linked-list implementations in Haskell.pdf -------------------------------------------------------------------------------- /papers/Compiling Without Continuations (Join Points).pdf: -------------------------------------------------------------------------------- https://raw.githubusercontent.com/beerendlauwers/haskell-papers-ereader/HEAD/papers/Compiling Without Continuations (Join Points).pdf -------------------------------------------------------------------------------- /papers/Compiling with Continuations, Continued.pdf: -------------------------------------------------------------------------------- https://raw.githubusercontent.com/beerendlauwers/haskell-papers-ereader/HEAD/papers/Compiling with Continuations, Continued.pdf -------------------------------------------------------------------------------- /papers/Composable Memory Transactions.pdf: -------------------------------------------------------------------------------- https://raw.githubusercontent.com/beerendlauwers/haskell-papers-ereader/HEAD/papers/Composable Memory Transactions.pdf -------------------------------------------------------------------------------- /papers/Compositional Data Types.pdf: -------------------------------------------------------------------------------- https://raw.githubusercontent.com/beerendlauwers/haskell-papers-ereader/HEAD/papers/Compositional Data Types.pdf -------------------------------------------------------------------------------- /papers/Compositional Semantics for Composable Continuations.pdf: -------------------------------------------------------------------------------- https://raw.githubusercontent.com/beerendlauwers/haskell-papers-ereader/HEAD/papers/Compositional Semantics for Composable Continuations.pdf -------------------------------------------------------------------------------- /papers/Comprehensive Comprehensions - Comprehensions with ‘Order by’ and ‘Group by’.pdf: -------------------------------------------------------------------------------- https://raw.githubusercontent.com/beerendlauwers/haskell-papers-ereader/HEAD/papers/Comprehensive Comprehensions - Comprehensions with ‘Order by’ and ‘Group by’.pdf -------------------------------------------------------------------------------- /papers/Computational Lambda-Calculus and Monads.pdf: -------------------------------------------------------------------------------- https://raw.githubusercontent.com/beerendlauwers/haskell-papers-ereader/HEAD/papers/Computational Lambda-Calculus and Monads.pdf -------------------------------------------------------------------------------- /papers/Denotational design with type class morphisms (extended version).pdf: -------------------------------------------------------------------------------- https://raw.githubusercontent.com/beerendlauwers/haskell-papers-ereader/HEAD/papers/Denotational design with type class morphisms (extended version).pdf -------------------------------------------------------------------------------- /papers/Dependently Typed Programming with Singletons.pdf: -------------------------------------------------------------------------------- https://raw.githubusercontent.com/beerendlauwers/haskell-papers-ereader/HEAD/papers/Dependently Typed Programming with Singletons.pdf -------------------------------------------------------------------------------- /papers/Domain Specific Embedded Compilers.pdf: -------------------------------------------------------------------------------- https://raw.githubusercontent.com/beerendlauwers/haskell-papers-ereader/HEAD/papers/Domain Specific Embedded Compilers.pdf -------------------------------------------------------------------------------- /papers/Down with the bureaucracy of syntax! Pattern matching for classical linear logic.pdf: -------------------------------------------------------------------------------- https://raw.githubusercontent.com/beerendlauwers/haskell-papers-ereader/HEAD/papers/Down with the bureaucracy of syntax! Pattern matching for classical linear logic.pdf -------------------------------------------------------------------------------- /papers/Dynamic Witnesses for Static Type Errors.pdf: -------------------------------------------------------------------------------- https://raw.githubusercontent.com/beerendlauwers/haskell-papers-ereader/HEAD/papers/Dynamic Witnesses for Static Type Errors.pdf -------------------------------------------------------------------------------- /papers/Effect Handlers in Scope.pdf: -------------------------------------------------------------------------------- https://raw.githubusercontent.com/beerendlauwers/haskell-papers-ereader/HEAD/papers/Effect Handlers in Scope.pdf -------------------------------------------------------------------------------- /papers/Efficient Communication and Collection with Compact Normal Forms.pdf: -------------------------------------------------------------------------------- https://raw.githubusercontent.com/beerendlauwers/haskell-papers-ereader/HEAD/papers/Efficient Communication and Collection with Compact Normal Forms.pdf -------------------------------------------------------------------------------- /papers/Elaborating Evaluation-Order Polymorphism.pdf: -------------------------------------------------------------------------------- https://raw.githubusercontent.com/beerendlauwers/haskell-papers-ereader/HEAD/papers/Elaborating Evaluation-Order Polymorphism.pdf -------------------------------------------------------------------------------- /papers/Embedding Effect Systems in Haskell.pdf: -------------------------------------------------------------------------------- https://raw.githubusercontent.com/beerendlauwers/haskell-papers-ereader/HEAD/papers/Embedding Effect Systems in Haskell.pdf -------------------------------------------------------------------------------- /papers/Encoding Information Flow in Haskell.pdf: -------------------------------------------------------------------------------- https://raw.githubusercontent.com/beerendlauwers/haskell-papers-ereader/HEAD/papers/Encoding Information Flow in Haskell.pdf -------------------------------------------------------------------------------- /papers/Expressing Contract Monitors as Patterns of Communication.pdf: -------------------------------------------------------------------------------- https://raw.githubusercontent.com/beerendlauwers/haskell-papers-ereader/HEAD/papers/Expressing Contract Monitors as Patterns of Communication.pdf -------------------------------------------------------------------------------- /papers/Extending the Haskell Foreign Function Interface with Concurrency.pdf: -------------------------------------------------------------------------------- https://raw.githubusercontent.com/beerendlauwers/haskell-papers-ereader/HEAD/papers/Extending the Haskell Foreign Function Interface with Concurrency.pdf -------------------------------------------------------------------------------- /papers/Extensible Effects - An Alternative to Monad Transformers.pdf: -------------------------------------------------------------------------------- https://raw.githubusercontent.com/beerendlauwers/haskell-papers-ereader/HEAD/papers/Extensible Effects - An Alternative to Monad Transformers.pdf -------------------------------------------------------------------------------- /papers/FPH - First-class Polymorphism for Haskell.pdf: -------------------------------------------------------------------------------- https://raw.githubusercontent.com/beerendlauwers/haskell-papers-ereader/HEAD/papers/FPH - First-class Polymorphism for Haskell.pdf -------------------------------------------------------------------------------- /papers/Faster Laziness Using Dynamic Pointer Tagging.pdf: -------------------------------------------------------------------------------- https://raw.githubusercontent.com/beerendlauwers/haskell-papers-ereader/HEAD/papers/Faster Laziness Using Dynamic Pointer Tagging.pdf -------------------------------------------------------------------------------- /papers/First-class Isomorphic Specialization by Staged Evaluation.pdf: -------------------------------------------------------------------------------- https://raw.githubusercontent.com/beerendlauwers/haskell-papers-ereader/HEAD/papers/First-class Isomorphic Specialization by Staged Evaluation.pdf -------------------------------------------------------------------------------- /papers/Fixing Idioms.pdf: -------------------------------------------------------------------------------- https://raw.githubusercontent.com/beerendlauwers/haskell-papers-ereader/HEAD/papers/Fixing Idioms.pdf -------------------------------------------------------------------------------- /papers/Flexible Dynamic Information Flow Control in Haskell.pdf: -------------------------------------------------------------------------------- https://raw.githubusercontent.com/beerendlauwers/haskell-papers-ereader/HEAD/papers/Flexible Dynamic Information Flow Control in Haskell.pdf -------------------------------------------------------------------------------- /papers/Flipping Fold, Reformulating Reduction.pdf: -------------------------------------------------------------------------------- https://raw.githubusercontent.com/beerendlauwers/haskell-papers-ereader/HEAD/papers/Flipping Fold, Reformulating Reduction.pdf -------------------------------------------------------------------------------- /papers/Focusing on Binding and Computation.pdf: -------------------------------------------------------------------------------- https://raw.githubusercontent.com/beerendlauwers/haskell-papers-ereader/HEAD/papers/Focusing on Binding and Computation.pdf -------------------------------------------------------------------------------- /papers/Focusing on Pattern Matching.pdf: -------------------------------------------------------------------------------- https://raw.githubusercontent.com/beerendlauwers/haskell-papers-ereader/HEAD/papers/Focusing on Pattern Matching.pdf -------------------------------------------------------------------------------- /papers/Foreign Inline Code.pdf: -------------------------------------------------------------------------------- https://raw.githubusercontent.com/beerendlauwers/haskell-papers-ereader/HEAD/papers/Foreign Inline Code.pdf -------------------------------------------------------------------------------- /papers/Foundational Extensible Corecursion - A Proof Assistant Perspective.pdf: -------------------------------------------------------------------------------- https://raw.githubusercontent.com/beerendlauwers/haskell-papers-ereader/HEAD/papers/Foundational Extensible Corecursion - A Proof Assistant Perspective.pdf -------------------------------------------------------------------------------- /papers/Foundations for Structured Programming with GADTs.pdf: -------------------------------------------------------------------------------- https://raw.githubusercontent.com/beerendlauwers/haskell-papers-ereader/HEAD/papers/Foundations for Structured Programming with GADTs.pdf -------------------------------------------------------------------------------- /papers/Free Applicative Functors.pdf: -------------------------------------------------------------------------------- https://raw.githubusercontent.com/beerendlauwers/haskell-papers-ereader/HEAD/papers/Free Applicative Functors.pdf -------------------------------------------------------------------------------- /papers/Freer Monads, More Extensible Effects.pdf: -------------------------------------------------------------------------------- https://raw.githubusercontent.com/beerendlauwers/haskell-papers-ereader/HEAD/papers/Freer Monads, More Extensible Effects.pdf -------------------------------------------------------------------------------- /papers/Functional Programming for Dynamic and Large Data with Self-Adjusting Computation.pdf: -------------------------------------------------------------------------------- https://raw.githubusercontent.com/beerendlauwers/haskell-papers-ereader/HEAD/papers/Functional Programming for Dynamic and Large Data with Self-Adjusting Computation.pdf -------------------------------------------------------------------------------- /papers/Functional Programming with Structured Graphs.pdf: -------------------------------------------------------------------------------- https://raw.githubusercontent.com/beerendlauwers/haskell-papers-ereader/HEAD/papers/Functional Programming with Structured Graphs.pdf -------------------------------------------------------------------------------- /papers/Functional Reactive Animation.pdf: -------------------------------------------------------------------------------- https://raw.githubusercontent.com/beerendlauwers/haskell-papers-ereader/HEAD/papers/Functional Reactive Animation.pdf -------------------------------------------------------------------------------- /papers/Functional Reactive Programming With Liveness Guarantees.pdf: -------------------------------------------------------------------------------- https://raw.githubusercontent.com/beerendlauwers/haskell-papers-ereader/HEAD/papers/Functional Reactive Programming With Liveness Guarantees.pdf -------------------------------------------------------------------------------- /papers/Functional Reactive Programming from First Principles.pdf: -------------------------------------------------------------------------------- https://raw.githubusercontent.com/beerendlauwers/haskell-papers-ereader/HEAD/papers/Functional Reactive Programming from First Principles.pdf -------------------------------------------------------------------------------- /papers/Functional Reactive Programming, Continued.pdf: -------------------------------------------------------------------------------- https://raw.githubusercontent.com/beerendlauwers/haskell-papers-ereader/HEAD/papers/Functional Reactive Programming, Continued.pdf -------------------------------------------------------------------------------- /papers/Functional Reactive Types.pdf: -------------------------------------------------------------------------------- https://raw.githubusercontent.com/beerendlauwers/haskell-papers-ereader/HEAD/papers/Functional Reactive Types.pdf -------------------------------------------------------------------------------- /papers/GADTS Meet Their Match.pdf: -------------------------------------------------------------------------------- https://raw.githubusercontent.com/beerendlauwers/haskell-papers-ereader/HEAD/papers/GADTS Meet Their Match.pdf -------------------------------------------------------------------------------- /papers/Generating Performance Portable Code using Rewrite Rules - From High-level Functional Expressions to High-Performance OpenCL Code.pdf: -------------------------------------------------------------------------------- https://raw.githubusercontent.com/beerendlauwers/haskell-papers-ereader/HEAD/papers/Generating Performance Portable Code using Rewrite Rules - From High-level Functional Expressions to High-Performance OpenCL Code.pdf -------------------------------------------------------------------------------- /papers/Generic Constructors and Eliminators from Descriptions.pdf: -------------------------------------------------------------------------------- https://raw.githubusercontent.com/beerendlauwers/haskell-papers-ereader/HEAD/papers/Generic Constructors and Eliminators from Descriptions.pdf -------------------------------------------------------------------------------- /papers/Generic Programming for Indexed Datatypes.pdf: -------------------------------------------------------------------------------- https://raw.githubusercontent.com/beerendlauwers/haskell-papers-ereader/HEAD/papers/Generic Programming for Indexed Datatypes.pdf -------------------------------------------------------------------------------- /papers/Giving Haskell a Promotion.pdf: -------------------------------------------------------------------------------- https://raw.githubusercontent.com/beerendlauwers/haskell-papers-ereader/HEAD/papers/Giving Haskell a Promotion.pdf -------------------------------------------------------------------------------- /papers/HLIO - Mixing Static and Dynamic Typing for Information-Flow Control in Haskell.pdf: -------------------------------------------------------------------------------- https://raw.githubusercontent.com/beerendlauwers/haskell-papers-ereader/HEAD/papers/HLIO - Mixing Static and Dynamic Typing for Information-Flow Control in Haskell.pdf -------------------------------------------------------------------------------- /papers/Haddock, A Haskell Documentation Tool.pdf: -------------------------------------------------------------------------------- https://raw.githubusercontent.com/beerendlauwers/haskell-papers-ereader/HEAD/papers/Haddock, A Haskell Documentation Tool.pdf -------------------------------------------------------------------------------- /papers/Haskell Session Types with (Almost) No Class.pdf: -------------------------------------------------------------------------------- https://raw.githubusercontent.com/beerendlauwers/haskell-papers-ereader/HEAD/papers/Haskell Session Types with (Almost) No Class.pdf -------------------------------------------------------------------------------- /papers/Haskell on a Shared-Memory Multiprocessor.pdf: -------------------------------------------------------------------------------- https://raw.githubusercontent.com/beerendlauwers/haskell-papers-ereader/HEAD/papers/Haskell on a Shared-Memory Multiprocessor.pdf -------------------------------------------------------------------------------- /papers/Hasochism - The Pleasure and Pain of Dependently Typed Haskell Programming.pdf: -------------------------------------------------------------------------------- https://raw.githubusercontent.com/beerendlauwers/haskell-papers-ereader/HEAD/papers/Hasochism - The Pleasure and Pain of Dependently Typed Haskell Programming.pdf -------------------------------------------------------------------------------- /papers/Higher-Order Abstract Syntax.pdf: -------------------------------------------------------------------------------- https://raw.githubusercontent.com/beerendlauwers/haskell-papers-ereader/HEAD/papers/Higher-Order Abstract Syntax.pdf -------------------------------------------------------------------------------- /papers/Higher-Order Functional Reactive Programming without Spacetime Leaks.pdf: -------------------------------------------------------------------------------- https://raw.githubusercontent.com/beerendlauwers/haskell-papers-ereader/HEAD/papers/Higher-Order Functional Reactive Programming without Spacetime Leaks.pdf -------------------------------------------------------------------------------- /papers/Homotopical Patch Theory.pdf: -------------------------------------------------------------------------------- https://raw.githubusercontent.com/beerendlauwers/haskell-papers-ereader/HEAD/papers/Homotopical Patch Theory.pdf -------------------------------------------------------------------------------- /papers/Hoopl - A Modular, Reusable Library for Dataflow Analysis and Transformation.pdf: -------------------------------------------------------------------------------- https://raw.githubusercontent.com/beerendlauwers/haskell-papers-ereader/HEAD/papers/Hoopl - A Modular, Reusable Library for Dataflow Analysis and Transformation.pdf -------------------------------------------------------------------------------- /papers/How to Keep Your Neighbours in Order.pdf: -------------------------------------------------------------------------------- https://raw.githubusercontent.com/beerendlauwers/haskell-papers-ereader/HEAD/papers/How to Keep Your Neighbours in Order.pdf -------------------------------------------------------------------------------- /papers/How to make ad-hoc polymorphism less ad hoc.pdf: -------------------------------------------------------------------------------- https://raw.githubusercontent.com/beerendlauwers/haskell-papers-ereader/HEAD/papers/How to make ad-hoc polymorphism less ad hoc.pdf -------------------------------------------------------------------------------- /papers/Hygienic Resugaring of Compositional Desugaring.pdf: -------------------------------------------------------------------------------- https://raw.githubusercontent.com/beerendlauwers/haskell-papers-ereader/HEAD/papers/Hygienic Resugaring of Compositional Desugaring.pdf -------------------------------------------------------------------------------- /papers/Indentation-Sensitive Parsing for Parsec.pdf: -------------------------------------------------------------------------------- https://raw.githubusercontent.com/beerendlauwers/haskell-papers-ereader/HEAD/papers/Indentation-Sensitive Parsing for Parsec.pdf -------------------------------------------------------------------------------- /papers/Indeterminate Behavior with Determinate Semantics in Parallel Programs.pdf: -------------------------------------------------------------------------------- https://raw.githubusercontent.com/beerendlauwers/haskell-papers-ereader/HEAD/papers/Indeterminate Behavior with Determinate Semantics in Parallel Programs.pdf -------------------------------------------------------------------------------- /papers/Information Flow Enforcement in Monadic Libraries.pdf: -------------------------------------------------------------------------------- https://raw.githubusercontent.com/beerendlauwers/haskell-papers-ereader/HEAD/papers/Information Flow Enforcement in Monadic Libraries.pdf -------------------------------------------------------------------------------- /papers/Lazy Functional State Threads.pdf: -------------------------------------------------------------------------------- https://raw.githubusercontent.com/beerendlauwers/haskell-papers-ereader/HEAD/papers/Lazy Functional State Threads.pdf -------------------------------------------------------------------------------- /papers/Learning Refinement Types.pdf: -------------------------------------------------------------------------------- https://raw.githubusercontent.com/beerendlauwers/haskell-papers-ereader/HEAD/papers/Learning Refinement Types.pdf -------------------------------------------------------------------------------- /papers/Levity Polymorphism.pdf: -------------------------------------------------------------------------------- https://raw.githubusercontent.com/beerendlauwers/haskell-papers-ereader/HEAD/papers/Levity Polymorphism.pdf -------------------------------------------------------------------------------- /papers/Lightweight Concurrency Primitives for GHC.pdf: -------------------------------------------------------------------------------- https://raw.githubusercontent.com/beerendlauwers/haskell-papers-ereader/HEAD/papers/Lightweight Concurrency Primitives for GHC.pdf -------------------------------------------------------------------------------- /papers/Lightweight Monadic Regions.pdf: -------------------------------------------------------------------------------- https://raw.githubusercontent.com/beerendlauwers/haskell-papers-ereader/HEAD/papers/Lightweight Monadic Regions.pdf -------------------------------------------------------------------------------- /papers/Maximal Sharing in the Lambda Calculus with letrec.pdf: -------------------------------------------------------------------------------- https://raw.githubusercontent.com/beerendlauwers/haskell-papers-ereader/HEAD/papers/Maximal Sharing in the Lambda Calculus with letrec.pdf -------------------------------------------------------------------------------- /papers/Mio - A High-Performance Multicore IO Manager for GHC.pdf: -------------------------------------------------------------------------------- https://raw.githubusercontent.com/beerendlauwers/haskell-papers-ereader/HEAD/papers/Mio - A High-Performance Multicore IO Manager for GHC.pdf -------------------------------------------------------------------------------- /papers/Monad Transformers and Modular Interpreters.pdf: -------------------------------------------------------------------------------- https://raw.githubusercontent.com/beerendlauwers/haskell-papers-ereader/HEAD/papers/Monad Transformers and Modular Interpreters.pdf -------------------------------------------------------------------------------- /papers/Monadic Functional Reactive Programming.pdf: -------------------------------------------------------------------------------- https://raw.githubusercontent.com/beerendlauwers/haskell-papers-ereader/HEAD/papers/Monadic Functional Reactive Programming.pdf -------------------------------------------------------------------------------- /papers/Monads, Zippers, and Views.pdf: -------------------------------------------------------------------------------- https://raw.githubusercontent.com/beerendlauwers/haskell-papers-ereader/HEAD/papers/Monads, Zippers, and Views.pdf -------------------------------------------------------------------------------- /papers/Multicore Garbage Collection with Local Heaps.pdf: -------------------------------------------------------------------------------- https://raw.githubusercontent.com/beerendlauwers/haskell-papers-ereader/HEAD/papers/Multicore Garbage Collection with Local Heaps.pdf -------------------------------------------------------------------------------- /papers/Non-Stop Haskell.pdf: -------------------------------------------------------------------------------- https://raw.githubusercontent.com/beerendlauwers/haskell-papers-ereader/HEAD/papers/Non-Stop Haskell.pdf -------------------------------------------------------------------------------- /papers/Noninterference for Free.pdf: -------------------------------------------------------------------------------- https://raw.githubusercontent.com/beerendlauwers/haskell-papers-ereader/HEAD/papers/Noninterference for Free.pdf -------------------------------------------------------------------------------- /papers/Object-Oriented Style Overloading for Haskell.pdf: -------------------------------------------------------------------------------- https://raw.githubusercontent.com/beerendlauwers/haskell-papers-ereader/HEAD/papers/Object-Oriented Style Overloading for Haskell.pdf -------------------------------------------------------------------------------- /papers/On Understanding Data Abstraction, Revisited.pdf: -------------------------------------------------------------------------------- https://raw.githubusercontent.com/beerendlauwers/haskell-papers-ereader/HEAD/papers/On Understanding Data Abstraction, Revisited.pdf -------------------------------------------------------------------------------- /papers/Optimising Purely Functional GPU Programs.pdf: -------------------------------------------------------------------------------- https://raw.githubusercontent.com/beerendlauwers/haskell-papers-ereader/HEAD/papers/Optimising Purely Functional GPU Programs.pdf -------------------------------------------------------------------------------- /papers/Ornaments in Practice.pdf: -------------------------------------------------------------------------------- https://raw.githubusercontent.com/beerendlauwers/haskell-papers-ereader/HEAD/papers/Ornaments in Practice.pdf -------------------------------------------------------------------------------- /papers/Outline of a Paraconsistent Category Theory.pdf: -------------------------------------------------------------------------------- https://raw.githubusercontent.com/beerendlauwers/haskell-papers-ereader/HEAD/papers/Outline of a Paraconsistent Category Theory.pdf -------------------------------------------------------------------------------- /papers/Parallel Generational-Copying Garbage Collection with a Block-Structured Heap.pdf: -------------------------------------------------------------------------------- https://raw.githubusercontent.com/beerendlauwers/haskell-papers-ereader/HEAD/papers/Parallel Generational-Copying Garbage Collection with a Block-Structured Heap.pdf -------------------------------------------------------------------------------- /papers/Parametric Higher-Order Abstract Syntax for Mechanized Semantics.pdf: -------------------------------------------------------------------------------- https://raw.githubusercontent.com/beerendlauwers/haskell-papers-ereader/HEAD/papers/Parametric Higher-Order Abstract Syntax for Mechanized Semantics.pdf -------------------------------------------------------------------------------- /papers/Parsing Expression Grammars - A Recognition-Based Syntactic Foundation.pdf: -------------------------------------------------------------------------------- https://raw.githubusercontent.com/beerendlauwers/haskell-papers-ereader/HEAD/papers/Parsing Expression Grammars - A Recognition-Based Syntactic Foundation.pdf -------------------------------------------------------------------------------- /papers/Partial Aborts for Transactions via First-Class Continuations.pdf: -------------------------------------------------------------------------------- https://raw.githubusercontent.com/beerendlauwers/haskell-papers-ereader/HEAD/papers/Partial Aborts for Transactions via First-Class Continuations.pdf -------------------------------------------------------------------------------- /papers/Pattern Matching Without K.pdf: -------------------------------------------------------------------------------- https://raw.githubusercontent.com/beerendlauwers/haskell-papers-ereader/HEAD/papers/Pattern Matching Without K.pdf -------------------------------------------------------------------------------- /papers/Pilsner - A Compositionally Verified Compiler for a Higher-Order Imperative Language.pdf: -------------------------------------------------------------------------------- https://raw.githubusercontent.com/beerendlauwers/haskell-papers-ereader/HEAD/papers/Pilsner - A Compositionally Verified Compiler for a Higher-Order Imperative Language.pdf -------------------------------------------------------------------------------- /papers/Polish Parsers, Step by Step.pdf: -------------------------------------------------------------------------------- https://raw.githubusercontent.com/beerendlauwers/haskell-papers-ereader/HEAD/papers/Polish Parsers, Step by Step.pdf -------------------------------------------------------------------------------- /papers/Polymorphic Embedding of DSLs.pdf: -------------------------------------------------------------------------------- https://raw.githubusercontent.com/beerendlauwers/haskell-papers-ereader/HEAD/papers/Polymorphic Embedding of DSLs.pdf -------------------------------------------------------------------------------- /papers/Practical Principled FRP - Forget the past, change the future, FRPNow!.pdf: -------------------------------------------------------------------------------- https://raw.githubusercontent.com/beerendlauwers/haskell-papers-ereader/HEAD/papers/Practical Principled FRP - Forget the past, change the future, FRPNow!.pdf -------------------------------------------------------------------------------- /papers/Practical SMT-Based Type Error Localization.pdf: -------------------------------------------------------------------------------- https://raw.githubusercontent.com/beerendlauwers/haskell-papers-ereader/HEAD/papers/Practical SMT-Based Type Error Localization.pdf -------------------------------------------------------------------------------- /papers/Practical and Effective Higher-Order Optimizations.pdf: -------------------------------------------------------------------------------- https://raw.githubusercontent.com/beerendlauwers/haskell-papers-ereader/HEAD/papers/Practical and Effective Higher-Order Optimizations.pdf -------------------------------------------------------------------------------- /papers/Promoting Functions to Type Families in Haskell.pdf: -------------------------------------------------------------------------------- https://raw.githubusercontent.com/beerendlauwers/haskell-papers-ereader/HEAD/papers/Promoting Functions to Type Families in Haskell.pdf -------------------------------------------------------------------------------- /papers/Proof Carrying-Based Information Flow Tracking for Data Secrecy Protection and Hardware Trust.pdf: -------------------------------------------------------------------------------- https://raw.githubusercontent.com/beerendlauwers/haskell-papers-ereader/HEAD/papers/Proof Carrying-Based Information Flow Tracking for Data Secrecy Protection and Hardware Trust.pdf -------------------------------------------------------------------------------- /papers/Propositions as Types.pdf: -------------------------------------------------------------------------------- https://raw.githubusercontent.com/beerendlauwers/haskell-papers-ereader/HEAD/papers/Propositions as Types.pdf -------------------------------------------------------------------------------- /papers/Push-Pull Functional Reactive Programming.pdf: -------------------------------------------------------------------------------- https://raw.githubusercontent.com/beerendlauwers/haskell-papers-ereader/HEAD/papers/Push-Pull Functional Reactive Programming.pdf -------------------------------------------------------------------------------- /papers/Putting Type Annotations to Work.pdf: -------------------------------------------------------------------------------- https://raw.githubusercontent.com/beerendlauwers/haskell-papers-ereader/HEAD/papers/Putting Type Annotations to Work.pdf -------------------------------------------------------------------------------- /papers/Pycket - A Tracing JIT For a Functional Language.pdf: -------------------------------------------------------------------------------- https://raw.githubusercontent.com/beerendlauwers/haskell-papers-ereader/HEAD/papers/Pycket - A Tracing JIT For a Functional Language.pdf -------------------------------------------------------------------------------- /papers/RRB Vector - Efficient Immutable Vectors.pdf: -------------------------------------------------------------------------------- https://raw.githubusercontent.com/beerendlauwers/haskell-papers-ereader/HEAD/papers/RRB Vector - Efficient Immutable Vectors.pdf -------------------------------------------------------------------------------- /papers/Refinement Types For Haskell.pdf: -------------------------------------------------------------------------------- https://raw.githubusercontent.com/beerendlauwers/haskell-papers-ereader/HEAD/papers/Refinement Types For Haskell.pdf -------------------------------------------------------------------------------- /papers/Reflection without Remorse - Revealing a hidden sequence to speed up monadic reflection.pdf: -------------------------------------------------------------------------------- https://raw.githubusercontent.com/beerendlauwers/haskell-papers-ereader/HEAD/papers/Reflection without Remorse - Revealing a hidden sequence to speed up monadic reflection.pdf -------------------------------------------------------------------------------- /papers/Representing Monads.pdf: -------------------------------------------------------------------------------- https://raw.githubusercontent.com/beerendlauwers/haskell-papers-ereader/HEAD/papers/Representing Monads.pdf -------------------------------------------------------------------------------- /papers/Rethinking Prolog.pdf: -------------------------------------------------------------------------------- https://raw.githubusercontent.com/beerendlauwers/haskell-papers-ereader/HEAD/papers/Rethinking Prolog.pdf -------------------------------------------------------------------------------- /papers/Runtime Support for Multicore Haskell.pdf: -------------------------------------------------------------------------------- https://raw.githubusercontent.com/beerendlauwers/haskell-papers-ereader/HEAD/papers/Runtime Support for Multicore Haskell.pdf -------------------------------------------------------------------------------- /papers/Safe Coercions.pdf: -------------------------------------------------------------------------------- https://raw.githubusercontent.com/beerendlauwers/haskell-papers-ereader/HEAD/papers/Safe Coercions.pdf -------------------------------------------------------------------------------- /papers/Safe Functional Reactive Programming through Dependent Types.pdf: -------------------------------------------------------------------------------- https://raw.githubusercontent.com/beerendlauwers/haskell-papers-ereader/HEAD/papers/Safe Functional Reactive Programming through Dependent Types.pdf -------------------------------------------------------------------------------- /papers/Safe Haskell.pdf: -------------------------------------------------------------------------------- https://raw.githubusercontent.com/beerendlauwers/haskell-papers-ereader/HEAD/papers/Safe Haskell.pdf -------------------------------------------------------------------------------- /papers/Scoping Rules on a Platter.pdf: -------------------------------------------------------------------------------- https://raw.githubusercontent.com/beerendlauwers/haskell-papers-ereader/HEAD/papers/Scoping Rules on a Platter.pdf -------------------------------------------------------------------------------- /papers/Self-Representation in Girard's System U.pdf: -------------------------------------------------------------------------------- https://raw.githubusercontent.com/beerendlauwers/haskell-papers-ereader/HEAD/papers/Self-Representation in Girard's System U.pdf -------------------------------------------------------------------------------- /papers/Session Types in Haskell - Updating Message Passing for the 21st Century.pdf: -------------------------------------------------------------------------------- https://raw.githubusercontent.com/beerendlauwers/haskell-papers-ereader/HEAD/papers/Session Types in Haskell - Updating Message Passing for the 21st Century.pdf -------------------------------------------------------------------------------- /papers/Settable and Non-Interfering Signal Functions for FRP.pdf: -------------------------------------------------------------------------------- https://raw.githubusercontent.com/beerendlauwers/haskell-papers-ereader/HEAD/papers/Settable and Non-Interfering Signal Functions for FRP.pdf -------------------------------------------------------------------------------- /papers/Shake Before Building - Replacing Make with Haskell.pdf: -------------------------------------------------------------------------------- https://raw.githubusercontent.com/beerendlauwers/haskell-papers-ereader/HEAD/papers/Shake Before Building - Replacing Make with Haskell.pdf -------------------------------------------------------------------------------- /papers/Simple Unification-based Type Inference for GADTs.pdf: -------------------------------------------------------------------------------- https://raw.githubusercontent.com/beerendlauwers/haskell-papers-ereader/HEAD/papers/Simple Unification-based Type Inference for GADTs.pdf -------------------------------------------------------------------------------- /papers/Simply Easy! - An Implementation of a Dependently Typed Lambda Calculus.pdf: -------------------------------------------------------------------------------- https://raw.githubusercontent.com/beerendlauwers/haskell-papers-ereader/HEAD/papers/Simply Easy! - An Implementation of a Dependently Typed Lambda Calculus.pdf -------------------------------------------------------------------------------- /papers/Simply efficient functional reactivity.pdf: -------------------------------------------------------------------------------- https://raw.githubusercontent.com/beerendlauwers/haskell-papers-ereader/HEAD/papers/Simply efficient functional reactivity.pdf -------------------------------------------------------------------------------- /papers/Simulating Qualified Class Constraints.pdf: -------------------------------------------------------------------------------- https://raw.githubusercontent.com/beerendlauwers/haskell-papers-ereader/HEAD/papers/Simulating Qualified Class Constraints.pdf -------------------------------------------------------------------------------- /papers/SmallCheck and Lazy SmallCheck.pdf: -------------------------------------------------------------------------------- https://raw.githubusercontent.com/beerendlauwers/haskell-papers-ereader/HEAD/papers/SmallCheck and Lazy SmallCheck.pdf -------------------------------------------------------------------------------- /papers/Soft Contract Verification.pdf: -------------------------------------------------------------------------------- https://raw.githubusercontent.com/beerendlauwers/haskell-papers-ereader/HEAD/papers/Soft Contract Verification.pdf -------------------------------------------------------------------------------- /papers/Sorting With Bialgebras and Distributive Laws.pdf: -------------------------------------------------------------------------------- https://raw.githubusercontent.com/beerendlauwers/haskell-papers-ereader/HEAD/papers/Sorting With Bialgebras and Distributive Laws.pdf -------------------------------------------------------------------------------- /papers/Spans of Lenses.pdf: -------------------------------------------------------------------------------- https://raw.githubusercontent.com/beerendlauwers/haskell-papers-ereader/HEAD/papers/Spans of Lenses.pdf -------------------------------------------------------------------------------- /papers/Stream Fusion - From Lists of Streams to Nothing at All.pdf: -------------------------------------------------------------------------------- https://raw.githubusercontent.com/beerendlauwers/haskell-papers-ereader/HEAD/papers/Stream Fusion - From Lists of Streams to Nothing at All.pdf -------------------------------------------------------------------------------- /papers/Strongly Typed Heterogeneous Collections.pdf: -------------------------------------------------------------------------------- https://raw.githubusercontent.com/beerendlauwers/haskell-papers-ereader/HEAD/papers/Strongly Typed Heterogeneous Collections.pdf -------------------------------------------------------------------------------- /papers/Structures for Structural Recursion.pdf: -------------------------------------------------------------------------------- https://raw.githubusercontent.com/beerendlauwers/haskell-papers-ereader/HEAD/papers/Structures for Structural Recursion.pdf -------------------------------------------------------------------------------- /papers/Symmetric Lenses.pdf: -------------------------------------------------------------------------------- https://raw.githubusercontent.com/beerendlauwers/haskell-papers-ereader/HEAD/papers/Symmetric Lenses.pdf -------------------------------------------------------------------------------- /papers/System FC With Explicit Kind Equality.pdf: -------------------------------------------------------------------------------- https://raw.githubusercontent.com/beerendlauwers/haskell-papers-ereader/HEAD/papers/System FC With Explicit Kind Equality.pdf -------------------------------------------------------------------------------- /papers/Tagless Staged Interpreters for Typed Languages.pdf: -------------------------------------------------------------------------------- https://raw.githubusercontent.com/beerendlauwers/haskell-papers-ereader/HEAD/papers/Tagless Staged Interpreters for Typed Languages.pdf -------------------------------------------------------------------------------- /papers/Template Meta-programming for Haskell.pdf: -------------------------------------------------------------------------------- https://raw.githubusercontent.com/beerendlauwers/haskell-papers-ereader/HEAD/papers/Template Meta-programming for Haskell.pdf -------------------------------------------------------------------------------- /papers/Temporal Logic with 'Until', Functional Reactive Programming with Processes, and Concrete Process Categories.pdf: -------------------------------------------------------------------------------- https://raw.githubusercontent.com/beerendlauwers/haskell-papers-ereader/HEAD/papers/Temporal Logic with 'Until', Functional Reactive Programming with Processes, and Concrete Process Categories.pdf -------------------------------------------------------------------------------- /papers/The Derivative of a Regular Type is its Type of One-Hole Contexts.pdf: -------------------------------------------------------------------------------- https://raw.githubusercontent.com/beerendlauwers/haskell-papers-ereader/HEAD/papers/The Derivative of a Regular Type is its Type of One-Hole Contexts.pdf -------------------------------------------------------------------------------- /papers/The Gentle Art of Levitation.pdf: -------------------------------------------------------------------------------- https://raw.githubusercontent.com/beerendlauwers/haskell-papers-ereader/HEAD/papers/The Gentle Art of Levitation.pdf -------------------------------------------------------------------------------- /papers/The HdpH DSLs for Scalable Reliable Computation.pdf: -------------------------------------------------------------------------------- https://raw.githubusercontent.com/beerendlauwers/haskell-papers-ereader/HEAD/papers/The HdpH DSLs for Scalable Reliable Computation.pdf -------------------------------------------------------------------------------- /papers/The Next 1100 Haskell Programmers.pdf: -------------------------------------------------------------------------------- https://raw.githubusercontent.com/beerendlauwers/haskell-papers-ereader/HEAD/papers/The Next 1100 Haskell Programmers.pdf -------------------------------------------------------------------------------- /papers/The Power of Pi.pdf: -------------------------------------------------------------------------------- https://raw.githubusercontent.com/beerendlauwers/haskell-papers-ereader/HEAD/papers/The Power of Pi.pdf -------------------------------------------------------------------------------- /papers/The Two Dualities of Computation - Negative and Fractional Types.pdf: -------------------------------------------------------------------------------- https://raw.githubusercontent.com/beerendlauwers/haskell-papers-ereader/HEAD/papers/The Two Dualities of Computation - Negative and Fractional Types.pdf -------------------------------------------------------------------------------- /papers/The Yampa Arcade.pdf: -------------------------------------------------------------------------------- https://raw.githubusercontent.com/beerendlauwers/haskell-papers-ereader/HEAD/papers/The Yampa Arcade.pdf -------------------------------------------------------------------------------- /papers/Theorems for free!.pdf: -------------------------------------------------------------------------------- https://raw.githubusercontent.com/beerendlauwers/haskell-papers-ereader/HEAD/papers/Theorems for free!.pdf -------------------------------------------------------------------------------- /papers/There is no Fork - an Abstraction for Efficient, Concurrent, and Concise Data Access.pdf: -------------------------------------------------------------------------------- https://raw.githubusercontent.com/beerendlauwers/haskell-papers-ereader/HEAD/papers/There is no Fork - an Abstraction for Efficient, Concurrent, and Concise Data Access.pdf -------------------------------------------------------------------------------- /papers/Total Parser Combinators.pdf: -------------------------------------------------------------------------------- https://raw.githubusercontent.com/beerendlauwers/haskell-papers-ereader/HEAD/papers/Total Parser Combinators.pdf -------------------------------------------------------------------------------- /papers/Towards Haskell in the Cloud.pdf: -------------------------------------------------------------------------------- https://raw.githubusercontent.com/beerendlauwers/haskell-papers-ereader/HEAD/papers/Towards Haskell in the Cloud.pdf -------------------------------------------------------------------------------- /papers/Towards Typing for Small-Step Direct Reflection.pdf: -------------------------------------------------------------------------------- https://raw.githubusercontent.com/beerendlauwers/haskell-papers-ereader/HEAD/papers/Towards Typing for Small-Step Direct Reflection.pdf -------------------------------------------------------------------------------- /papers/True Sums of Products.pdf: -------------------------------------------------------------------------------- https://raw.githubusercontent.com/beerendlauwers/haskell-papers-ereader/HEAD/papers/True Sums of Products.pdf -------------------------------------------------------------------------------- /papers/Type Checking with Open Type Functions.pdf: -------------------------------------------------------------------------------- https://raw.githubusercontent.com/beerendlauwers/haskell-papers-ereader/HEAD/papers/Type Checking with Open Type Functions.pdf -------------------------------------------------------------------------------- /papers/Type Inference for the Spine View of Data.pdf: -------------------------------------------------------------------------------- https://raw.githubusercontent.com/beerendlauwers/haskell-papers-ereader/HEAD/papers/Type Inference for the Spine View of Data.pdf -------------------------------------------------------------------------------- /papers/Type classes - an exploration of the design space.pdf: -------------------------------------------------------------------------------- https://raw.githubusercontent.com/beerendlauwers/haskell-papers-ereader/HEAD/papers/Type classes - an exploration of the design space.pdf -------------------------------------------------------------------------------- /papers/Type-Based Parametric Analysis of Program Families.pdf: -------------------------------------------------------------------------------- https://raw.githubusercontent.com/beerendlauwers/haskell-papers-ereader/HEAD/papers/Type-Based Parametric Analysis of Program Families.pdf -------------------------------------------------------------------------------- /papers/Type-Safe Observable Sharing in Haskell.pdf: -------------------------------------------------------------------------------- https://raw.githubusercontent.com/beerendlauwers/haskell-papers-ereader/HEAD/papers/Type-Safe Observable Sharing in Haskell.pdf -------------------------------------------------------------------------------- /papers/Type-checking Polymorphic Units for Astrophysics Reserach in Haskell.pdf: -------------------------------------------------------------------------------- https://raw.githubusercontent.com/beerendlauwers/haskell-papers-ereader/HEAD/papers/Type-checking Polymorphic Units for Astrophysics Reserach in Haskell.pdf -------------------------------------------------------------------------------- /papers/Type-indexed data types.pdf: -------------------------------------------------------------------------------- https://raw.githubusercontent.com/beerendlauwers/haskell-papers-ereader/HEAD/papers/Type-indexed data types.pdf -------------------------------------------------------------------------------- /papers/Type-level web APIs with Servant.pdf: -------------------------------------------------------------------------------- https://raw.githubusercontent.com/beerendlauwers/haskell-papers-ereader/HEAD/papers/Type-level web APIs with Servant.pdf -------------------------------------------------------------------------------- /papers/Type-safe runtime code generation with LLVM.pdf: -------------------------------------------------------------------------------- https://raw.githubusercontent.com/beerendlauwers/haskell-papers-ereader/HEAD/papers/Type-safe runtime code generation with LLVM.pdf -------------------------------------------------------------------------------- /papers/Typed Faceted Values for Secure Information Flow in Haskell.pdf: -------------------------------------------------------------------------------- https://raw.githubusercontent.com/beerendlauwers/haskell-papers-ereader/HEAD/papers/Typed Faceted Values for Secure Information Flow in Haskell.pdf -------------------------------------------------------------------------------- /papers/Unembedding Domain Specific Languages.pdf: -------------------------------------------------------------------------------- https://raw.githubusercontent.com/beerendlauwers/haskell-papers-ereader/HEAD/papers/Unembedding Domain Specific Languages.pdf -------------------------------------------------------------------------------- /papers/Verification of Information Flow and Access Control Policies with Dependent Types.pdf: -------------------------------------------------------------------------------- https://raw.githubusercontent.com/beerendlauwers/haskell-papers-ereader/HEAD/papers/Verification of Information Flow and Access Control Policies with Dependent Types.pdf -------------------------------------------------------------------------------- /papers/Which simple types have a unique inhabitant.pdf: -------------------------------------------------------------------------------- https://raw.githubusercontent.com/beerendlauwers/haskell-papers-ereader/HEAD/papers/Which simple types have a unique inhabitant.pdf -------------------------------------------------------------------------------- /papers/Witnesses and Open Witnesses.pdf: -------------------------------------------------------------------------------- https://raw.githubusercontent.com/beerendlauwers/haskell-papers-ereader/HEAD/papers/Witnesses and Open Witnesses.pdf -------------------------------------------------------------------------------- /papers/Worker-Wrapper-Makes it-Faster.pdf: -------------------------------------------------------------------------------- https://raw.githubusercontent.com/beerendlauwers/haskell-papers-ereader/HEAD/papers/Worker-Wrapper-Makes it-Faster.pdf -------------------------------------------------------------------------------- /papers/XQuery and Static Typing - Tackling the Problem of Backward Axes.pdf: -------------------------------------------------------------------------------- https://raw.githubusercontent.com/beerendlauwers/haskell-papers-ereader/HEAD/papers/XQuery and Static Typing - Tackling the Problem of Backward Axes.pdf -------------------------------------------------------------------------------- /papers/Yi - An Editor in Haskell for Haskell.pdf: -------------------------------------------------------------------------------- https://raw.githubusercontent.com/beerendlauwers/haskell-papers-ereader/HEAD/papers/Yi - An Editor in Haskell for Haskell.pdf -------------------------------------------------------------------------------- /papers/[LS] A Fast, Minimal Memory, Consistent Hash Algorithm.pdf: -------------------------------------------------------------------------------- https://raw.githubusercontent.com/beerendlauwers/haskell-papers-ereader/HEAD/papers/[LS] A Fast, Minimal Memory, Consistent Hash Algorithm.pdf -------------------------------------------------------------------------------- /papers/[LS] Adventures in Three Monads.pdf: -------------------------------------------------------------------------------- https://raw.githubusercontent.com/beerendlauwers/haskell-papers-ereader/HEAD/papers/[LS] Adventures in Three Monads.pdf -------------------------------------------------------------------------------- /papers/[LS] Arrows and Computation.pdf: -------------------------------------------------------------------------------- https://raw.githubusercontent.com/beerendlauwers/haskell-papers-ereader/HEAD/papers/[LS] Arrows and Computation.pdf -------------------------------------------------------------------------------- /papers/[LS] Asymptotic Improvement of Computations over Free Monads.pdf: -------------------------------------------------------------------------------- https://raw.githubusercontent.com/beerendlauwers/haskell-papers-ereader/HEAD/papers/[LS] Asymptotic Improvement of Computations over Free Monads.pdf -------------------------------------------------------------------------------- /papers/[LS] Automatic Skeletons In Template Haskell.pdf: -------------------------------------------------------------------------------- https://raw.githubusercontent.com/beerendlauwers/haskell-papers-ereader/HEAD/papers/[LS] Automatic Skeletons In Template Haskell.pdf -------------------------------------------------------------------------------- /papers/[LS] Boxes Go Bananas - Encoding Higher-Order Abstract Syntax with Parametric Polymorphism (Extended Version).pdf: -------------------------------------------------------------------------------- https://raw.githubusercontent.com/beerendlauwers/haskell-papers-ereader/HEAD/papers/[LS] Boxes Go Bananas - Encoding Higher-Order Abstract Syntax with Parametric Polymorphism (Extended Version).pdf -------------------------------------------------------------------------------- /papers/[LS] Call-by-Value is Dual to Call-by-Name, Reloaded.pdf: -------------------------------------------------------------------------------- https://raw.githubusercontent.com/beerendlauwers/haskell-papers-ereader/HEAD/papers/[LS] Call-by-Value is Dual to Call-by-Name, Reloaded.pdf -------------------------------------------------------------------------------- /papers/[LS] Comonadic Notions of Computation.pdf: -------------------------------------------------------------------------------- https://raw.githubusercontent.com/beerendlauwers/haskell-papers-ereader/HEAD/papers/[LS] Comonadic Notions of Computation.pdf -------------------------------------------------------------------------------- /papers/[LS] Composing Monads.pdf: -------------------------------------------------------------------------------- https://raw.githubusercontent.com/beerendlauwers/haskell-papers-ereader/HEAD/papers/[LS] Composing Monads.pdf -------------------------------------------------------------------------------- /papers/[LS] Comprehending Monads.pdf: -------------------------------------------------------------------------------- https://raw.githubusercontent.com/beerendlauwers/haskell-papers-ereader/HEAD/papers/[LS] Comprehending Monads.pdf -------------------------------------------------------------------------------- /papers/[LS] Dependent Types - Easy as PIE.pdf: -------------------------------------------------------------------------------- https://raw.githubusercontent.com/beerendlauwers/haskell-papers-ereader/HEAD/papers/[LS] Dependent Types - Easy as PIE.pdf -------------------------------------------------------------------------------- /papers/[LS] Efficient and Compositional Evaluation of Untyped Expressions.pdf: -------------------------------------------------------------------------------- https://raw.githubusercontent.com/beerendlauwers/haskell-papers-ereader/HEAD/papers/[LS] Efficient and Compositional Evaluation of Untyped Expressions.pdf -------------------------------------------------------------------------------- /papers/[LS] Finally Tagless, Partially Evaluated.pdf: -------------------------------------------------------------------------------- https://raw.githubusercontent.com/beerendlauwers/haskell-papers-ereader/HEAD/papers/[LS] Finally Tagless, Partially Evaluated.pdf -------------------------------------------------------------------------------- /papers/[LS] Free Applicative Functors.pdf: -------------------------------------------------------------------------------- https://raw.githubusercontent.com/beerendlauwers/haskell-papers-ereader/HEAD/papers/[LS] Free Applicative Functors.pdf -------------------------------------------------------------------------------- /papers/[LS] Fun with type functions.pdf: -------------------------------------------------------------------------------- https://raw.githubusercontent.com/beerendlauwers/haskell-papers-ereader/HEAD/papers/[LS] Fun with type functions.pdf -------------------------------------------------------------------------------- /papers/[LS] Functional Differentiation of Computer Programs.pdf: -------------------------------------------------------------------------------- https://raw.githubusercontent.com/beerendlauwers/haskell-papers-ereader/HEAD/papers/[LS] Functional Differentiation of Computer Programs.pdf -------------------------------------------------------------------------------- /papers/[LS] Functional Programming with Bananas, Lenses, Envelopes and Barbed Wire.pdf: -------------------------------------------------------------------------------- https://raw.githubusercontent.com/beerendlauwers/haskell-papers-ereader/HEAD/papers/[LS] Functional Programming with Bananas, Lenses, Envelopes and Barbed Wire.pdf -------------------------------------------------------------------------------- /papers/[LS] Idioms are oblivious, arrows are meticulous, monads are promiscuous.pdf: -------------------------------------------------------------------------------- https://raw.githubusercontent.com/beerendlauwers/haskell-papers-ereader/HEAD/papers/[LS] Idioms are oblivious, arrows are meticulous, monads are promiscuous.pdf -------------------------------------------------------------------------------- /papers/[LS] Implementing Lazy Functional Languages on Stock Hardware - The Spineless Tagless G-machine.pdf: -------------------------------------------------------------------------------- https://raw.githubusercontent.com/beerendlauwers/haskell-papers-ereader/HEAD/papers/[LS] Implementing Lazy Functional Languages on Stock Hardware - The Spineless Tagless G-machine.pdf -------------------------------------------------------------------------------- /papers/[LS] Kan Extensions for Program Optimisation; Or - Art and Dan Explain an Old Trick.pdf: -------------------------------------------------------------------------------- https://raw.githubusercontent.com/beerendlauwers/haskell-papers-ereader/HEAD/papers/[LS] Kan Extensions for Program Optimisation; Or - Art and Dan Explain an Old Trick.pdf -------------------------------------------------------------------------------- /papers/[LS] Lock Free Data Structures using STM in Haskell.pdf: -------------------------------------------------------------------------------- https://raw.githubusercontent.com/beerendlauwers/haskell-papers-ereader/HEAD/papers/[LS] Lock Free Data Structures using STM in Haskell.pdf -------------------------------------------------------------------------------- /papers/[LS] Monadic constraint programming.pdf: -------------------------------------------------------------------------------- https://raw.githubusercontent.com/beerendlauwers/haskell-papers-ereader/HEAD/papers/[LS] Monadic constraint programming.pdf -------------------------------------------------------------------------------- /papers/[LS] Monads and composable continuations.pdf: -------------------------------------------------------------------------------- https://raw.githubusercontent.com/beerendlauwers/haskell-papers-ereader/HEAD/papers/[LS] Monads and composable continuations.pdf -------------------------------------------------------------------------------- /papers/[LS] Monads for functional programming.pdf: -------------------------------------------------------------------------------- https://raw.githubusercontent.com/beerendlauwers/haskell-papers-ereader/HEAD/papers/[LS] Monads for functional programming.pdf -------------------------------------------------------------------------------- /papers/[LS] Nested Datatypes.pdf: -------------------------------------------------------------------------------- https://raw.githubusercontent.com/beerendlauwers/haskell-papers-ereader/HEAD/papers/[LS] Nested Datatypes.pdf -------------------------------------------------------------------------------- /papers/[LS] NixOS - A Purely Functional Linux Distribution.pdf: -------------------------------------------------------------------------------- https://raw.githubusercontent.com/beerendlauwers/haskell-papers-ereader/HEAD/papers/[LS] NixOS - A Purely Functional Linux Distribution.pdf -------------------------------------------------------------------------------- /papers/[LS] Notions of Computation as Monoids.pdf: -------------------------------------------------------------------------------- https://raw.githubusercontent.com/beerendlauwers/haskell-papers-ereader/HEAD/papers/[LS] Notions of Computation as Monoids.pdf -------------------------------------------------------------------------------- /papers/[LS] Optimising Embedded DSLs using Template Haskell.pdf: -------------------------------------------------------------------------------- https://raw.githubusercontent.com/beerendlauwers/haskell-papers-ereader/HEAD/papers/[LS] Optimising Embedded DSLs using Template Haskell.pdf -------------------------------------------------------------------------------- /papers/[LS] Parameterized Notions of Computation.pdf: -------------------------------------------------------------------------------- https://raw.githubusercontent.com/beerendlauwers/haskell-papers-ereader/HEAD/papers/[LS] Parameterized Notions of Computation.pdf -------------------------------------------------------------------------------- /papers/[LS] Practical type inference for arbitrary-rank type.pdf: -------------------------------------------------------------------------------- https://raw.githubusercontent.com/beerendlauwers/haskell-papers-ereader/HEAD/papers/[LS] Practical type inference for arbitrary-rank type.pdf -------------------------------------------------------------------------------- /papers/[LS] Programming with Arrows.pdf: -------------------------------------------------------------------------------- https://raw.githubusercontent.com/beerendlauwers/haskell-papers-ereader/HEAD/papers/[LS] Programming with Arrows.pdf -------------------------------------------------------------------------------- /papers/[LS] Recursive Coalgebras from Comonads.pdf: -------------------------------------------------------------------------------- https://raw.githubusercontent.com/beerendlauwers/haskell-papers-ereader/HEAD/papers/[LS] Recursive Coalgebras from Comonads.pdf -------------------------------------------------------------------------------- /papers/[LS] Tackling the Awkward Squad - monadic input-output, concurrency, exceptions, and foreign-language calls in Haskell.pdf: -------------------------------------------------------------------------------- https://raw.githubusercontent.com/beerendlauwers/haskell-papers-ereader/HEAD/papers/[LS] Tackling the Awkward Squad - monadic input-output, concurrency, exceptions, and foreign-language calls in Haskell.pdf -------------------------------------------------------------------------------- /papers/[LS] The Arrow Calculus.pdf: -------------------------------------------------------------------------------- https://raw.githubusercontent.com/beerendlauwers/haskell-papers-ereader/HEAD/papers/[LS] The Arrow Calculus.pdf -------------------------------------------------------------------------------- /papers/[LS] The Design of a Pretty Printing Library.pdf: -------------------------------------------------------------------------------- https://raw.githubusercontent.com/beerendlauwers/haskell-papers-ereader/HEAD/papers/[LS] The Design of a Pretty Printing Library.pdf -------------------------------------------------------------------------------- /papers/[LS] The Dual of Substitution is Redecoration.pdf: -------------------------------------------------------------------------------- https://raw.githubusercontent.com/beerendlauwers/haskell-papers-ereader/HEAD/papers/[LS] The Dual of Substitution is Redecoration.pdf -------------------------------------------------------------------------------- /papers/[LS] The Essence of Dataflow Programming.pdf: -------------------------------------------------------------------------------- https://raw.githubusercontent.com/beerendlauwers/haskell-papers-ereader/HEAD/papers/[LS] The Essence of Dataflow Programming.pdf -------------------------------------------------------------------------------- /papers/[LS] The Essence of the Iterator Pattern.pdf: -------------------------------------------------------------------------------- https://raw.githubusercontent.com/beerendlauwers/haskell-papers-ereader/HEAD/papers/[LS] The Essence of the Iterator Pattern.pdf -------------------------------------------------------------------------------- /papers/[LS] The Genuine Sieve of Eratosthenes.pdf: -------------------------------------------------------------------------------- https://raw.githubusercontent.com/beerendlauwers/haskell-papers-ereader/HEAD/papers/[LS] The Genuine Sieve of Eratosthenes.pdf -------------------------------------------------------------------------------- /papers/[LS] The essence of functional programming.pdf: -------------------------------------------------------------------------------- https://raw.githubusercontent.com/beerendlauwers/haskell-papers-ereader/HEAD/papers/[LS] The essence of functional programming.pdf -------------------------------------------------------------------------------- /papers/[LS] The marriage of effects and monads.pdf: -------------------------------------------------------------------------------- https://raw.githubusercontent.com/beerendlauwers/haskell-papers-ereader/HEAD/papers/[LS] The marriage of effects and monads.pdf -------------------------------------------------------------------------------- /papers/[LS] Total Functional Programming.pdf: -------------------------------------------------------------------------------- https://raw.githubusercontent.com/beerendlauwers/haskell-papers-ereader/HEAD/papers/[LS] Total Functional Programming.pdf -------------------------------------------------------------------------------- /papers/[LS] Why Functional Programming Matters.pdf: -------------------------------------------------------------------------------- https://raw.githubusercontent.com/beerendlauwers/haskell-papers-ereader/HEAD/papers/[LS] Why Functional Programming Matters.pdf --------------------------------------------------------------------------------