Haskell

swMATH3521WikidataQ34010 ScholiaQ34010MaRDI QIDQ16052FDOQ16052

Author name not available (Why is that?)

Described by source

• Programming in Haskell
• Programming in Haskell
• Unnamed Publication

Cited In (only showing first 100 items - show all)

• Enclosing the behavior of a hybrid automaton up to and beyond a Zeno point
• Implementing hybrid semantics: from functional to imperative
• Title not available (Why is that?)
• Dependent Types at Work
• Haskell before Haskell: an alternative lesson in practical logics of the ENIAC
• Practical synthesis of reactive systems from LTL specifications via parity games
• A theory of core fudgets
• A theory of core fudgets
• Handlers in action
• Nonrealizable minimal vertex triangulations of surfaces: showing nonrealizability using oriented matroids and satisfiability solvers
• On a machine-checked proof for fraction arithmetic over a GCD domain
• Semantic essence of AsmL
• Title not available (Why is that?)
• Title not available (Why is that?)
• Overview of the Mathemagix Type System
• Observationally-induced algebras in domain theory
• Observationally-induced algebras in domain theory
• Forms/3: A first-order visual language to explore the boundaries of the spreadsheet paradigm
• Experience report
• Refinement types for Haskell
• Comprehending monads
• Quantum data and control made easier
• Secrets of the Glasgow Haskell Compiler inliner
• A domain-specific language for computing on encrypted data. (Invited talk)
• Certification of Termination Proofs Using CeTA
• HLIO: mixing static and dynamic typing for information-flow control in Haskell
• Ghostbuster: a tool for simplifying and converting GADTs
• Friends with Benefits
• A coinductive calculus for asynchronous side-effecting processes
• Computational interpretations of linear logic
• Marimba: A Tool for Verifying Properties of Hidden Markov Models
• Ivor, a Proof Engine
• Ruler: Programming Type Rules
• ``Keep definition, change category -- a practical approach to state-based system calculi
• Order-sorted algebra. I: Equational deduction for multiple inheritance, overloading, exceptions and partial operations
• Isabelle/HOL. A proof assistant for higher-order logic
• Partiality and recursion in interactive theorem provers – an overview
• Title not available (Why is that?)
• Typability and type checking in System F are equivalent and undecidable
• Charting patterns on price history
• On the algebraic structure of declarative programming languages
• Adding equations to System F types
• The probability that a pair of elements of a finite group are conjugate.
• FUNCTIONAL PEARLS: Probabilistic functional programming in Haskell
• Transposing partial components--an exercise on coalgebraic refinement
• FC++: Functional tools for object-oriented tasks
• A dependency pair framework for innermost complexity analysis of term rewrite systems
• Computation semantics of the functional scientific workflow language Cuneiform
• Implementing a computer algebra system in Haskell
• RDA: A Coq Library to Reason about Randomised Distributed Algorithms in the Message Passing Model
• Grammatical Framework
• HTab: a Terminating Tableaux System for Hybrid Logic
• Title not available (Why is that?)
• Ott: Effective tool support for the working semanticist
• Title not available (Why is that?)
• Title not available (Why is that?)
• Practical typed lazy contracts
• Combining effects: sum and tensor
• Implementing a Library for Probabilistic Programming Using Non-strict Non-determinism
• Declarative stream runtime verification (hLola)
• Title not available (Why is that?)
• HALO
• Title not available (Why is that?)
• Preface to the special issue: Interactive theorem proving and the formalization of mathematics
• Title not available (Why is that?)
• Title not available (Why is that?)
• Backpack
• A certified framework for compiling and executing garbage-collected languages
• Binders unbound
• Idris, a general-purpose dependently typed programming language: Design and implementation
• Core FOBS: A hybrid functional and object-oriented language
• A tutorial implementation of a dependently typed lambda calculus
• Towards a linear algebra of programming
• Modeling dynamic programming problems over sequences and trees with inverse coupled rewrite systems
• Google's MapReduce programming model - Revisited
• SAD as a mathematical assistant -- how should we go from here to there?
• The impact of higher-order state and control effects on local relational reasoning
• HasCasl: integrated higher-order specification and program development
• Tackling the awkward squad: Monadic input/output, concurrency, exceptions, and foreign-language calls in Haskell
• A Nominal Axiomatization of the Lambda Calculus
• Polytypic data conversion programs
• Parallelising large irregular programs: An experience with Naira
• Proof-producing translation of higher-order logic into pure and stateful ML
• Programming with higher-order logic.
• \textsc{HasCasl}: towards integrated specification and development of functional programs
• \texttt{vlogsl}: a strategy language for simulation-based verification of hardware
• CoLoR: a Coq library on well-founded rewrite relations and its application to the automated verifications of termination certificates
• Zeno: an automated prover for properties of recursive data structures
• The Verigraph system for graph transformation
• Functional programming concepts and straight-line programs in computer algebra
• The Essence of Multitasking
• Categorical semantics for arrows
• Ampersand. Applying relation algebra in practice
• A purely functional computer algebra system embedded in Haskell
• Hoare type theory, polymorphism and separation
• Secure Microkernels, State Monads and Scalable Refinement
• From natural semantics to C: A formal derivation of two STG machines
• Arrows for secure information flow
• Equational formulas and pattern operations in initial order-sorted algebras
• Proofs, programs, processes

This page was built for software: Haskell