scholarly journals Strict and lazy semantics for effects: layering monads and comonads

2018 ◽  
Vol 2 (ICFP) ◽  
pp. 1-30 ◽  
Author(s):  
Andrew K. Hirsch ◽  
Ross Tate
Keyword(s):  
Lazy Semantics

From natural semantics to C: A formal derivation of two STG machines

2009 ◽  
Vol 19 (1) ◽  
pp. 47-94 ◽  
Author(s):  
ALBERTO DE LA ENCINA ◽  
RICARDO PEÑA
Keyword(s):  
Functional Programming ◽  
Functional Language ◽  
Levels Of Abstraction ◽  
Additional Information ◽  
Formal Derivation ◽  
Derivation Step ◽  
Starting Point ◽  
Efficient Code ◽  
Lazy Semantics ◽  
High Level

AbstractThe Spineless Tag-less G-machine (STG machine) was defined as the target abstract machine for compiling the lazy functional language Haskell. It is at the heart of the Glasgow Haskell Compiler (GHC) which is claimed to be the Haskell compiler that generates the most efficient code. A high-level description of the STG machine can be found in Peyton Jones (In Journal of Functional programming, 2(2), 127–202, 1992), Marlow & Peyton Jones (In Sigplan Not., 39(9), 4–5, 2004), and Marlow & Peyton Jones (In Journal of Functional Programming, 16(4–5), 415–449, 2006). Should the reader be interested in a more detailed view, then the only additional information available is the Haskell code of GHC and the C code of its runtime system.It is hard to prove that this machine correctly implements the lazy semantics of Haskell. Part of the problem lies in the fact that the STG machine executes a bare-bones functional language, called STGL, much lower level than Haskell. Therefore, part of the correctness should be—and it is—established by showing that the translation from Haskell to STGL preserves Haskell's semantics.The other part involves showing that the STG machine correctly implements the lazy semantics of STGL. In this paper we provide a step-by-step formal derivation of the STG machine and of its compilation to C, starting from a natural semantics of STGL. Thus, our starting point is higher level than the descriptions found Peyton Jones (In Journal of Functional programming, 2(2), 127–202, 1992) and Marlow & Peyton Jones (In Sigplan Not., 39(9), 4–5, 2004), and our arrival point is lower level than those works. Additionally, there has been substantial changes between the so-called push/enter model of the STG machine described in Peyton Jones (In Journal of Functional programming, 2(2), 127–202, 1992), and the eval/apply model of the STG machine described in Marlow & Peyton Jones (In Sigplan Not., 39(9), 4–5, 2004). So, in fact, we derive two machines instead of one, starting from the same initial semantics.At each step we provide enough intuitions and explanations in order to understand the refinement, and then the formal definitions and statements proving that the derivation step is sound and complete. The main contribution of the paper is to show that an efficient machine such as the STG can be presented, understood, and formally reasoned about at different levels of abstraction.

scholarly journals Generating power of lazy semantics

1997 ◽  
Vol 187 (1-2) ◽  
pp. 203-219 ◽  
Author(s):  
Jerzy Karczmarczuk
Keyword(s):  
Lazy Semantics

scholarly journals Structures for lazy semantics

1998 ◽  
pp. 30-48 ◽  
Author(s):  
O. Bastonero ◽  
A. Pravato ◽  
S. Ronchi Rocca
Keyword(s):  
Lazy Semantics

scholarly journals Solving string constraints with Regex-dependent functions through transducers with priorities and variables

2022 ◽  
Vol 6 (POPL) ◽  
pp. 1-31
Author(s):  
Taolue Chen ◽  
Alejandro Flores-Lamas ◽  
Matthew Hague ◽  
Zhilei Han ◽  
Denghang Hu ◽  
...  
Keyword(s):  
Programming Languages ◽  
Formal Language ◽  
Formal Semantics ◽  
Symbolic Execution ◽  
Language Theory ◽  
Regular Expressions ◽  
Constraint Language ◽  
Straight Line ◽  
Finite State ◽  
Lazy Semantics

Regular expressions are a classical concept in formal language theory. Regular expressions in programming languages (RegEx) such as JavaScript, feature non-standard semantics of operators (e.g. greedy/lazy Kleene star), as well as additional features such as capturing groups and references. While symbolic execution of programs containing RegExes appeals to string solvers natively supporting important features of RegEx, such a string solver is hitherto missing. In this paper, we propose the first string theory and string solver that natively provides such support. The key idea of our string solver is to introduce a new automata model, called prioritized streaming string transducers (PSST), to formalize the semantics of RegEx-dependent string functions. PSSTs combine priorities, which have previously been introduced in prioritized finite-state automata to capture greedy/lazy semantics, with string variables as in streaming string transducers to model capturing groups. We validate the consistency of the formal semantics with the actual JavaScript semantics by extensive experiments. Furthermore, to solve the string constraints, we show that PSSTs enjoy nice closure and algorithmic properties, in particular, the regularity-preserving property (i.e., pre-images of regular constraints under PSSTs are regular), and introduce a sound sequent calculus that exploits these properties and performs propagation of regular constraints by means of taking post-images or pre-images. Although the satisfiability of the string constraint language is generally undecidable, we show that our approach is complete for the so-called straight-line fragment. We evaluate the performance of our string solver on over 195000 string constraints generated from an open-source RegEx library. The experimental results show the efficacy of our approach, drastically improving the existing methods (via symbolic execution) in both precision and efficiency.

Sign in / Sign up

Export Citation Format

Share Document