User loginNavigation 
Type TheoryHow OCaml type checker works  or what polymorphism and garbage collection have in commonHow OCaml type checker works  or what polymorphism and garbage collection have in common
As usual with Oleg, there's a lot going on here. Personally, I see parallels with "lambda with letrec" and "callbypushvalue," although making the connection with the latter takes some squinting through some of Levy's work other than his CBPV thesis. Study this to understand OCaml type inference and/or MLF, or for insights into region typing, or, as the title suggests, for suggestive analogies between polymorphism and garbage collection. By Paul Snively at 20130310 16:25  Functional  Implementation  Type Theory  1 comment  other blogs  16399 reads
Records, sums, cases, and exceptions: Rowpolymorphism at workVideo: Records, sums, cases, and exceptions: Rowpolymorphism at work, Matthias Blume.
Found this to be an enjoyable and thorough overview of MLPolyR, a language created for a PL course that goes allout on various dimensions of row polymorphism, resulting in a small yet powerful language. (previously) By Manuel J. Simoni at 20121101 10:12  Implementation  Type Theory  4 comments  other blogs  17675 reads
Koka a function oriented language with effect inference
Koka extends the idea of using row polymorphism to encode an effect system and the relations between them. Daan Leijen is the primary researcher behind it and his research was featured previously on LtU, mainly on row polymorphism in the Morrow Language. So far there's no paper available on the language design, just the slides from a Lang.Next talk (which doesn't seem to have video available at Channel 9), but it's in the program for HOPE 2012. By Daniel Yokomizo at 20120816 05:40  Functional  Software Engineering  Type Theory  3 comments  other blogs  20220 reads
How to Make Ad Hoc Proof Automation Less Ad HocHow to Make Ad Hoc Proof Automation Less Ad Hoc
If you've ever toyed with Coq but run into the difficulties that many encounter in trying to construct robust, comprehensible proof scripts using tactics, which manipulate the proof state and can leave you with the "ground" of the proof rather than the "figure," if you will, in addition to being fragile in the face of change, you may wish to give this a read. It frankly never would have occurred to me to try to turn Ltac scripts into lemmas at all. This is much more appealing than most other approaches to the subject I've seen. By Paul Snively at 20120622 15:41  Functional  Implementation  Logic/Declarative  Type Theory  9 comments  other blogs  9452 reads
Tool Demo: ScalaVirtualized
Scala has always had a quite good EDSL story thanks to implicits, dot and pareninference, and methodsasoperators. Lately there are proposals to provide it with both macrosinthecamlp4sense and support for multistage programming. This paper goes into some depth on the foundations of the latter subject. By Paul Snively at 20120526 22:28  DSL  Implementation  MetaProgramming  ObjectFunctional  Scala  Semantics  Type Theory  login or register to post comments  other blogs  10378 reads
Programming as collaborative referenceProgramming as collaborative reference (extended abstract and slides) by everybody's favorite PLT tag team, Oleg and Chungchieh, from the Offthebeaten track workshop affiliated with POPL 2012:
By Manuel J. Simoni at 20120204 16:48  Paradigms  Type Theory  12 comments  other blogs  9412 reads
The Algebra of Data, and the Calculus of MutationKalani Thielen's The Algebra of Data, and the Calculus of Mutation is a very good explanation of ADTs, and also scratches the surfaces of Zippers:
(hat tip to Daniel Yokomizo, who used to be an LtU member...) By Manuel J. Simoni at 20120203 15:53  Teaching & Learning  Type Theory  11 comments  other blogs  12482 reads
Vellvm: Formalizing the LLVM Intermediate Representation for Verified Program TransformationsVellvm: Formalizing the LLVM Intermediate Representation for Verified Program Transformations by Jianzhou Zhao, Santosh Nagarakatte, Milo M. K. Martin, and Steve Zdancewic, POPL 2012
This obviously represents huge progress in marrying the theoretical benefits of tools like Coq with the practical benefits of tools like LLVM. We can only hope that this spurs further development in practical certified software development. By Paul Snively at 20120128 15:57  Functional  Lambda Calculus  Semantics  Type Theory  16 comments  other blogs  13124 reads
Deca, an LtUfriendly bare metal systems programming languageThe Deca programming language is "a language designed to provide the advanced features of sophisticated, highlevel programming languages while still programming as close as possible to the bare metal. It brings in the functional, objectoriented, and generic programming paradigms without requiring a garbage collector or a threading system, so programmers really only pay in performance for the features they use." The latter link provides a list of features that Deca does, will, and won't provide. Features provided include type inference, universally and existentially quantified types, and "a strong regionandeffect system that prohibits unsafe escaping pointers and doublefree errors". The Deca language and ideas behind it are documented in a thesis, The design and implementation of a modern systems programming language (PDF):
The source code for the Deca compiler, decac, is available here. The compiler is implemented in Scala and generates LLVM bytecode. (The author points out in the comments below that this implementation is a work in progress.) The author of Deca is LtU member Eli Gottlieb, who back in 2008 posted in the forum asking for feedback on his language: Practical Bits of Making a Compiler for a New Language. There's some more discussion of Deca over at Hacker News. By Anton van Straaten at 20120102 02:40  Implementation  Lambda Calculus  ObjectFunctional  Type Theory  52 comments  other blogs  36485 reads
LTL types FRP
Alan Jeffrey (to appear 2012) LTL types FRP: Lineartime Temporal Logic Propositions as Types, Proofs as Functional Reactive Programs. To be presented at next year's Programming Languages meets Program Verification, (PLPV 2012).
Functional Reactive Programming (FRP) is a form of reactive programming whose model is pure functions over signals. FRP is often expressed in terms of arrows with loops, which is the type class for a Freyd category (that is a premonoidal category with a cartesian centre) equipped with a premonoidal trace. This type system sufï¬ces to deï¬ne the dataï¬‚ow structure of a reactive program, but does not express its temporal properties. In this paper, we show that Lineartime Temporal Logic (LTL) is a natural extension of the type system for FRP, which constrains the temporal behaviour of reactive programs. We show that a constructive LTL can be deï¬ned in a dependently typed functional language, and that reactive programs form proofs of constructive LTL properties. In particular, implication in LTL gives rise to stateless functions on streams, and the â€œconstrainsâ€ modality gives rise to causal functions. We show that reactive programs form a partially traced monoidal category, and hence can be given as a form of arrows with loops, where the type system enforces that only decoupled functions can be looped.Via Alan's G+ feed. By Charles Stewart at 20111114 10:48  Functional  Type Theory  35 comments  other blogs  19058 reads

Browse archivesActive forum topics 
Recent comments
1 week 11 hours ago
1 week 1 day ago
1 week 2 days ago
2 weeks 4 days ago
2 weeks 5 days ago
2 weeks 5 days ago
2 weeks 5 days ago
2 weeks 5 days ago
2 weeks 6 days ago
2 weeks 6 days ago