Sketch-Driven Regular Expression Generation from Natural Language and Examples

Greg Durrett; Isil Dillig; Qiaochu Chen; Xinyu Wang; Xi Ye

REVIEW 3 major objections 5 minor 44 references

Sketch-Driven Regular Expression Generation from Natural Language and Examples

T0 review · 3 major / 5 minor · reviewed 2026-08-14 · deepseek-v4-flash

Challenge this review Re-run · record.json Download PDF Read on arXiv ↗ Review JSON

Pith's one-line read This paper argues that regular expressions should be generated from natural language by first parsing the text into an incomplete sketch with holes, then using positive and negative examples to fill those holes, and reports that this…

desk verdict Solid two-stage sketch-driven regex synthesis with real gains; the abstract's 'solves 57%' is top-25 oracle recall, not end-to-end accuracy, so the headline overstates what a user would receive. read the letter →

arxiv 1908.05848 v2 pith:FEENK34N submitted 2019-08-16 cs.CL

Xi Ye , Qiaochu Chen , Xinyu Wang , Isil Dillig , Greg Durrett This is my paper · ORCID

classification cs.CL

keywords regularexpressionsynthesisnaturallanguagetoprogramsketch-basedfromexamplessemanticparsingweaksupervisionStackOverflowdatasetconstrainedholes

verification ladder T0 review T1 audit T2 compute T3 formal

The pith

A machine-rendered reading of the paper's core claim, the machinery that carries it, and where it could break.

The reading

This paper argues that regular expressions are best generated from natural language by first parsing the description into an incomplete program, or sketch, and then letting a program synthesizer fill in the missing pieces using positive and negative string examples. The claim is that this two-stage decomposition beats direct neural translation from text to regex, and the experiments support it on two standard benchmarks and on a new collection of 62 real Stack Overflow posts. If the claim is right, systems that combine language understanding with example-driven search can handle long, under-specified descriptions that end-to-end neural models miss. The paper reports state-of-the-art accuracy on the older benchmarks and a 57 percent solve rate on the real-world set, where transferred neural baselines essentially fail.

What carries the argument

The load-bearing mechanism is the sketch, an unfinished regex in which the ordinary DSL operators may contain constrained holes written $\square\{S_1,\dots,S_m\}$. A concrete regex is admitted by the sketch if at least one subtree of the finished expression matches one of the listed $S_i$, so the hole acts as a soft hint rather than a hard template. The parser produces one or more such sketches from the language, and the synthesizer completes them by enumerating programs from the DSL in increasing depth, preferring programs that overlap with the hole's components, and keeping the first completion consistent with all positive and negative examples.

What would settle it

Take the 62 Stack Overflow posts, add a new set of regex-tagged posts without applying the original curation filters, and count how often the grammar parser produces a parse that leads to a consistent regex; if the solve rate drops sharply on uncurated posts, the reported 57 percent is an artifact of the chosen posts rather than a general method.

Watch

Extended reading notes

Core claim

The paper's central claim is that the best way to synthesize a regular expression from a natural-language description is to treat the description as a source of partial structure, not as a complete specification. A parser, either grammar-based or neural, turns the text into a sketch, a regex tree with constrained holes standing in for unspecified pieces; a program synthesizer then enumerates instantiations of that sketch and returns the first one consistent with the user's positive and negative string examples. On the KB13 and TURK benchmarks the authors report state-of-the-art semantic accuracy, and on 62 real Stack Overflow posts the grammar-sketch model, trained without sketch supervision, solves 56.5 percent of cases within its top 25 outputs, where a transferred neural translation model solves none or near none. The authors interpret this as evidence that decomposing language interpretation from example-guided search makes regex synthesis robust to long, under-specified, and typo-laden real-world descriptions.

Load-bearing premise

The real-world results rest on the assumption that a hand-built grammar of roughly 70 lexical and 60 compositional rules covers the ways people actually describe regular expressions on Stack Overflow, because a description the grammar cannot parse yields no useful sketch.

Editorial extensions

If this is right

Where direct sequence-to-sequence translation needs large training sets, sketch-driven synthesis stays effective with a few hundred examples, because the language-to-sketch mapping is simpler to learn than the language-to-regex mapping.
Filtering a neural model's k-best outputs by examples helps, but sketch-driven search helps more: consistency with the examples improves substantially, and the relative rate of inconsistent outputs drops by more than half.
The same framework can be instantiated with different parsers and synthesizers, so progress in either component can be imported without redesigning the whole pipeline.
On real user posts, the grammar-sketch model succeeds even without hand-labeled sketches, meaning weak supervision from the correctness of the synthesized regex is enough in a data-poor regime.
Users of Stack Overflow typically provide enough positive and negative examples to put the synthesizer in an effective regime, which is why the method works on real posts despite short or ambiguous language.

Reading between the lines

Editorial extensions of the paper, not claims the author makes directly.

If the hand-built grammar is the main bottleneck, scaling the parser with many more real-world posts should raise the reported solve rate; the paper's weak-supervision training suggests the sketches themselves do not need manual labels.
The same sketch-and-complete pattern is likely to transfer to other program-synthesis tasks where language is under-specified, such as spreadsheet transformations or database queries, provided the user can supply input-output examples.
A testable extension is that failure cases attributed to missing corner-case examples should improve sharply when a few additional user-supplied negative examples are added, since the synthesizer's search is what fails to disambiguate the intent.
The reported 57 percent figure probably understates what a stronger neural sketch parser trained on real-world-scale data would achieve, because the grammar constrains the sketches while the synthesizer itself is already effective.

Share X Bluesky LinkedIn Reddit HN

Signed reviews

No signed human review yet.

Editorial analysis

A structured set of objections, weighed in public.

Desk editor's note, referee report, and a circularity audit.

Desk Editor's Note

read the letter

Two things worth knowing up front. The paper makes a real contribution: a sketch-with-holes intermediate representation that lets a semantic parser commit to partial structure while a synthesizer fills the gaps from string examples, and an MML training objective that rewards sketches leading to correct synthesized regexes. That is genuinely different from prior regex-from-NL systems, which used examples only as a post-filter. The second thing is that the abstract's 'solves 57%' is not a user-facing solve rate. It is top-25 oracle accuracy from Table 3: a benchmark counts as solved if any of the top 25 sketches synthesizes to the correct regex. The deployment rule in Section 6 picks the highest-ranked sketch that yields an example-consistent regex. With under-specified examples, multiple consistent regexes exist — the paper's own failure case (g) returns a consistent but wrong regex — so a correct sketch later in the list can be blocked by an earlier wrong-but-consistent one. The real end-to-end number is not reported; it is below 56.5% and could be close to the top-1 value of 31.1%. The stress-test note is right, and this concern is more load-bearing than grammar coverage.

What is new and good: the two-stage framework is clean and modular; the ablations are careful; the gains on KB13 and TURK are consistent; the grammar-based parser is a nice fit for low-data regimes; the data-efficiency and beam-size experiments are informative. The new 62-post StackOverflow dataset, with code and data released, is a useful resource. The authors are also honest about the warm start in Section 6.1: the 'no sketch supervision' neural model is bootstrapped from grammar sketches selected using ground-truth correctness. That is not the same as training purely from weak supervision, and the abstract overstates it.

Soft spots in proportion: the missing end-to-end accuracy on StackOverflow is the main one. No error bars on 62 examples is minor but real. Grammar coverage is an open question, but I would not call it fatal. Examples for prior datasets are machine-generated, which makes the comparison fair but synthetic. The citation pattern and data release look honest; no circularity in the evaluation.

Who this is for: anyone working on semantic parsing, program synthesis from examples, or regex tooling. It deserves a serious referee. I would ask the authors to report end-to-end accuracy under their stated selection rule and correct the abstract before acceptance.

Referee Report

3 major / 5 minor

Summary. The paper proposes a sketch-driven framework for synthesizing regular expressions from natural-language descriptions and positive/negative string examples. A semantic parser (a neural seq2seq model or a SEMPRE grammar-based parser) first maps the description to a sketch: an incomplete regex tree containing constrained holes. An enumerative program synthesizer then instantiates the holes under the guidance of the examples. Training is done either by MLE on heuristic pseudo-gold sketches or by MML that rewards sketches whose synthesized regex is functionally equivalent to the gold regex. Experiments cover the KB13 and TURK datasets plus a new 62-example Stack Overflow dataset. The best sketch-driven variants improve on earlier translation-based baselines on the prior datasets, and the grammar-based parser reaches 31.1% top-1 and 56.5% top-25 accuracy on Stack Overflow, while translated neural baselines mostly fail.

Significance. If the headline claims are taken at face value, the paper makes a useful contribution: it demonstrates that an intermediate sketch lets a synthesizer exploit examples more effectively than direct neural translation with post-filtering, and it provides one of the first evaluations on real Stack Overflow regex requests. The authors release code, data, and a readable grammar, which supports reproducibility, and the two-stage parser/synthesizer decomposition is clean and modular. However, the main real-world claim is currently supported by a top-N oracle metric that does not match the stated test-time selection rule, so the practical significance of the Stack Overflow result is substantially weaker than the abstract suggests. The prior-dataset state-of-the-art claim is better supported, but it needs a precise qualification.

major comments (3)

[Abstract; Section 1; Section 6.2, Table 3] The abstract and Section 1 state that the system 'solves 57%' of the Stack Overflow dataset, but the best number in Table 3 is 56.5% and it is defined as top-25 accuracy: a benchmark counts as solved if any of the top-25 sketches synthesizes to the correct regex. Section 6 describes a different test-time policy: 'We pick the output of the highest-ranked sketch yielding an example-consistent regex as the answer.' Under-specified examples can admit many consistent regexes, and Figure 6 failure case (g) is exactly a case where the synthesizer returns a consistent but wrong regex. The top-N oracle therefore overestimates the success of the deployed selection rule; the actual end-to-end accuracy under that rule could be much closer to the top-1 value of 31.1% than to 56.5%. Please report the accuracy of the stated selection rule (for example, top-1, top-5, and top-25 under that rule) and revise the abstract and Section 1 accordingly.
[Section 6.1, Table 2] The claim that sketch-driven approaches 'outperform these previous approaches even when they are extended to benefit from examples' is stronger than the table shows. In the no-sketch-supervision block, DEEP SKETCH MLE reaches 76.2% on KB13 versus 77.7% for DEEP REGEX MLE+FILTER, and in the strongest MML comparison DEEP SKETCH MML reaches 84.3% on TURK, tying DEEP REGEX MML+FILTER at 84.3%. The state-of-the-art claim is supported by the best MML and pseudogold variants, but the sentence should be qualified to those variants rather than stated for all sketch-driven approaches.
[Section 3.2; Section 6.2] Section 3.2 asserts that the hand-crafted unified grammar of roughly 70 lexical and 60 compositional rules is 'sufficient to cover the fairly narrow domain of regex descriptions,' and the entire Stack Overflow evaluation in Section 6.2 depends on this grammar. The paper gives no coverage statistics: how often does the grammar produce at least one sketch for the collected posts, and how stable is the 56.5% figure across the five folds? With only 62 benchmarks, such an analysis is feasible and would materially affect the external-validity claim that the framework solves real-world posts. Please add this analysis or weaken the generalization claim.

minor comments (5)

[Table 2] The row 'DEEP REGEX MLE' appears twice with identical values; remove the duplicate.
[Section 6.1] In the paragraph describing warm-starting the neural sketch models, the parenthetical '(DEEP REGEX MML)' appears to be a typo and should presumably read '(DEEP SKETCH MML)'.
[Table 3] For the EMPTY SKETCH row, top-5 and top-25 are listed as '−'; clarify whether these were not run or whether the accuracy was 0%.
[Section 5.2] In the description of manually labeled sketches for Stack Overflow, the phrase 'based on information from the gold sketch' should probably refer to the ground truth regex, since no gold sketch exists yet at that point.
[Section 3.2] The sentence 'Finally, we take the the derivations over the entire natural language description' contains a duplicated 'the'.

Circularity Check

0 steps flagged · score 0.0 of 10

No significant circularity: the sketch-plus-example pipeline is trained and evaluated against external ground-truth regexes, not defined by its inputs.

full rationale

The paper's derivation chain is self-contained against external ground truth. The semantic parser produces a sketch from natural language; the synthesizer completes it against user-provided examples; and success is measured by functional equivalence to held-out ground-truth regexes. MML training uses the ground-truth regex only as a reward to select among sketches on the training split (Section 3.3), which is standard weak supervision rather than a fitted parameter being renamed as a prediction. Pseudogold and manual sketches are likewise derived from the training split's ground truth and used only for MLE training (Section 5.2). No load-bearing claim invokes a self-citation: citations to prior work supply tools or baselines, not the paper's conclusion. The gap between reported top-25 accuracy and the stated test-time selection rule (Section 6, Table 3) is a metric-transparency concern, not circularity, because even if the reported number overstates deployable accuracy, the target regex is not an input to the derivation. Therefore no circular step is present.

Assumptions & free parameters 3 free parameters · 5 assumptions · 1 invented entities

The central claim rests mainly on a hand-crafted grammar, machine-generated examples, a curated StackOverflow sample, and a beam-search approximation of MML. These are transparently described in the paper, but they condition the headline results.

free parameters (3)

Number of generated examples = 10 positive and 10 negative
KB13 and TURK have no human-provided examples, so these are generated from ground-truth automata (Section 5.2). Table 4 shows accuracy varies with the count, so the comparison depends on this setting.
Beam size for sketch list = 20 for KB13/TURK, 25 for StackOverflow
The StackOverflow headline '57%' corresponds to top-25 accuracy. Table 5 shows beam size affects accuracy, so the headline claim depends on this choice.
Synthesizer timeout = 2s for KB13/TURK, 30s for StackOverflow
Longer timeouts would likely solve more instances; the 57% result is within a 30s budget per sketch.

assumptions (5)

ad hoc to paper The hand-written unified grammar covers the range of English used to describe regexes in Stack Overflow posts.
Introduced in Section 3.2 ('sufficient to cover the fairly narrow domain of regex descriptions'). The best StackOverflow results (GRAMMAR SKETCH MML) depend on this coverage.
domain assumption Automatically generated examples from ground-truth regexes are a valid proxy for human-written examples on KB13 and TURK.
Section 5.2 generates 10 positive and 10 negative examples from automata. Human examples may be harder, so gains on these benchmarks may not transfer.
domain assumption The 62 filtered Stack Overflow posts represent the real-world regex synthesis problem.
Section 5.1 excludes abstract concepts and visual formatting and only uses top posts; selection may exclude common types of requests.
domain assumption Beam search with beam size 10 (neural MML) or 200 (grammar MML) gives a good enough approximation of the MML gradient.
Section 3.3 says the sum over sketches is intractable, so gradients are estimated by samples from beam search; if the beam misses good sketches, training quality degrades.
standard math The regex DSL is equivalent in power to standard regular expressions, so synthesized regexes can match any regular language.
Stated in Section 2; not load-bearing for the empirical comparison but grounds the DSL.

invented entities (1)

Constrained hole (□{S1,...,Sm})
purpose: Serves as the incomplete part of a sketch, allowing the parser to commit to fragments while leaving structure to the synthesizer.
A new formal construct introduced in the sketch DSL (Section 2). Its value is demonstrated only through the paper's own experiments; it has no falsifiable handle outside this work.

how reviews work

0 comments

Cite this review

Pith. "Pith review of Sketch-Driven Regular Expression Generation from Natural Language and Examples." pith.science (2026). https://pith.science/paper/FEENK34N

@misc{pith2026190805848,
  author       = {Pith},
  title        = {Pith review of: Sketch-Driven Regular Expression Generation from Natural Language and Examples},
  year         = {2026},
  howpublished = {\url{https://pith.science/paper/FEENK34N}},
  note         = {Machine review of arXiv:1908.05848}
}

read the original abstract

Recent systems for converting natural language descriptions into regular expressions (regexes) have achieved some success, but typically deal with short, formulaic text and can only produce simple regexes. Realworld regexes are complex, hard to describe with brief sentences, and sometimes require examples to fully convey the user's intent. We present a framework for regex synthesis in this setting where both natural language (NL) and examples are available. First, a semantic parser (either grammar-based or neural) maps the natural language description into an intermediate sketch, which is an incomplete regex containing holes to denote missing components. Then a program synthesizer searches over the regex space defined by the sketch and finds a regex that is consistent with the given string examples. Our semantic parser can be trained purely from weak supervision based on correctness of the synthesized regex, or it can leverage heuristically-derived sketches. We evaluate on two prior datasets (Kushman and Barzilay, 2013; Locascio et al., 2016) and a real-world dataset from Stack Overflow. Our system achieves state-of-the-art performance on the prior datasets and solves 57% of the real-world dataset, which existing neural systems completely fail on.

Figures

Figures reproduced from arXiv: 1908.05848 by the authors.

**Figure 2.** Regex DSL (black) and Sketch DSL (all rules including the last rule in red). C represents either a character class such as <let>, <num> or a single character such as <a>, <1>. k represents an integer. and our synthesizer in Section 4. Regex/Sketch DSL Our regex language (Figure 2) is similar to the one presented in (Locascio et al., 2016) but more expressive. Our DSL adds some additional constructs, such as Repeat… view at source ↗

**Figure 3.** Examples of rules and the parse tree for building one possible derivation. The left side of [PITH_FULL_IMAGE:figures/full_fig_p004_3.png] view at source ↗

Figures from the paper (3 more)

**Figure 4.** Figure 4: Examples of natural language description from each of the three datasets. TURK tends to be very formulaic, while STACKOVERFLOW is longer and much more complex. thetic descriptions are then paraphrased by workers from Mechanical Turk. The generate-and-paraphrase proce…

**Figure 5.** Figure 5: Accuracy on TURK for different training set sizes. Our DEEPSKETCH and GRAMMARSKETCH approaches outperform the DEEPREGEX+FILTER baseline when training data is limited. with long descriptions and sophisticated regexes (e.g., the example in [PITH_FULL_IMAGE:figures/fu…

**Figure 6.** Figure 6: Examples of success and failure pairs from TURK and STACKOVERFLOW. On pairs (a) and (b), our DEEPSKETCH is robust to the issues existing in natural language descriptions. On pairs (c) and (d), our approach fails due to the unrealistic semantics of the desired regexes.…

Discussion (0). Continue with ORCID to comment.

Reference graph

Works this paper leans on

44 extracted references · 41 canonical work pages

[1]

URL: " 'urlintro :=

ENTRY address author booktitle chapter edition editor howpublished institution journal key month note number organization pages publisher school series title type volume year eprint doi pubmed url lastchecked label extra.label sort.label short.list INTEGERS output.state before.all mid.sentence after.sentence after.block STRINGS urlintro eprinturl eprintpr...
[2]

write newline

" write newline "" before.all 'output.state := FUNCTION n.dashify 't := "" t empty not t #1 #1 substring "-" = t #1 #2 substring "--" = not "--" * t #2 global.max substring 't := t #1 #1 substring "-" = "-" * t #2 global.max substring 't := while if t #1 #1 substring * t #2 global.max substring 't := if while FUNCTION word.in bbl.in capitalize " " * FUNCT...
[3]

Alur , R

R. Alur , R. Bodik , G. Juniwal , M. M. K. Martin , M. Raghothaman , S. A. Seshia , R. Singh , A. Solar-Lezama , E. Torlak , and A. Udupa . 2013. Syntax-guided synthesis. In 2013 Formal Methods in Computer-Aided Design (FMCAD)

work page 2013
[4]

Yoav Artzi, Kenton Lee, and Luke Zettlemoyer. 2015. Broad-coverage CCG semantic parsing with AMR . In Proceedings of the Conference on Empirical Methods in Natural Language Processing (EMNLP)

work page 2015
[5]

M Balog, AL Gaunt, M Brockschmidt, S Nowozin, and D Tarlow. 2017. Deepcoder: Learning to write programs. In Proceedings of the International Conference on Learning Representations (ICLR)

work page 2017
[6]

Jonathan Berant, Andrew Chou, Roy Frostig, and Percy Liang. 2013. Semantic parsing on F reebase from question-answer pairs. In Proceedings of the Conference on Empirical Methods in Natural Language Processing (EMNLP)

work page 2013
[7]

Li Dong and Mirella Lapata. 2016. Language to logical form with neural attention. In Proceedings of the Annual Meeting of the Association for Computational Linguistics (ACL)

work page 2016
[8]

Li Dong and Mirella Lapata. 2018. Coarse-to-fine decoding for neural semantic parsing. In Proceedings of the Annual Meeting of the Association for Computational Linguistics (ACL)

work page 2018

Show all 44 references

[9]

Yu Feng, Ruben Martins, Osbert Bastani, and Isil Dillig. 2018. Program synthesis using conflict-driven learning. In Proceedings of the 39th ACM SIGPLAN Conference on Programming Language Design and Implementation (PLDI)

2018
[10]

Sumit Gulwani. 2011. Automating string processing in spreadsheets using input-output examples. In Proceedings of the 38th Annual ACM SIGPLAN-SIGACT Symposium on Principles of Programming Languages (POPL)

2011
[11]

Kelvin Guu, Panupong Pasupat, Evan Liu, and Percy Liang. 2017. From language to programs: Bridging reinforcement learning and maximum marginal likelihood. In Proceedings of the Annual Meeting of the Association for Computational Linguistics (ACL)

2017
[12]

Tihomir Gvero and Viktor Kuncak. 2015. Synthesizing Java Expressions from Free-form Queries . In Proceedings of the 2015 ACM SIGPLAN International Conference on Object-Oriented Programming, Systems, Languages, and Applications (OOPSLA)

2015
[13]

Srinivasan Iyer, Alvin Cheung, and Luke Zettlemoyer. 2019. Learning programmatic idioms for scalable semantic parsing. In Proceedings of the Conference on Empirical Methods in Natural Language Processing (EMNLP)

2019
[14]

Srinivasan Iyer, Ioannis Konstas, Alvin Cheung, Jayant Krishnamurthy, and Luke Zettlemoyer. 2017. Learning a neural semantic parser from user feedback. In Proceedings of the Annual Meeting of the Association for Computational Linguistics (ACL)

2017
[15]

Ashwin Kalyan, Abhishek Mohta, Oleksandr Polozov, Dhruv Batra, Prateek Jain, and Sumit Gulwani. 2018. Neural-guided deductive search for real-time program synthesis from examples. In International Conference on Learning Representations (ICLR)

2018
[16]

Diederik P Kingma and Jimmy Ba. 2015. Adam: A method for stochastic optimization. In Proceedings of the International Conference on Learning Representations (ICLR)

2015
[17]

Sumith Kulal, Panupong Pasupat, Kartik Chandra, Mina Lee, Oded Padon, Alex Aiken, and Percy S Liang. 2019. Spoc: Search-based pseudocode to code. In Proceedings of the Conference on Advances in Neural Information Processing Systems (NeurIPS)

2019
[18]

Nate Kushman and Regina Barzilay. 2013. Using semantic unification to generate regular expressions from natural language. In Proceedings of the 2013 Conference of the North A merican Chapter of the Association for Computational Linguistics: Human Language Technologies (NAACL-HLT)

2013
[19]

Tom Kwiatkowski, Eunsol Choi, Yoav Artzi, and Luke Zettlemoyer. 2013. Scaling semantic parsers with on-the-fly ontology matching. In Proceedings of the Conference on Empirical Methods in Natural Language Processing (EMNLP)

2013
[20]

Mina Lee, Sunbeom So, and Hakjoo Oh. 2016. Synthesizing regular expressions from examples for introductory automata assignments. In Proceedings of the 2016 ACM SIGPLAN International Conference on Generative Programming: Concepts and Experiences (GPCE)

2016
[21]

Xi Victoria Lin, Chenglong Wang, Luke Zettlemoyer, and Michael D. Ernst. 2018. NL2Bash: A Corpus and Semantic Parser for Natural Language Interface to the Linux Operating System . In Proceedings of the International Conference on Language Resources and Evaluation LREC

2018
[22]

Wang Ling, Phil Blunsom, Edward Grefenstette, Karl Moritz Hermann, Tom \'a s Ko c isk \'y , Fumin Wang, and Andrew Senior. 2016. Latent predictor networks for code generation. In Proceedings of the Annual Meeting of the Association for Computational Linguistics (ACL)

2016
[23]

Nicholas Locascio, Karthik Narasimhan, Eduardo DeLeon, Nate Kushman, and Regina Barzilay. 2016. Neural generation of regular expressions from natural language with minimal domain knowledge. In Proceedings of the Conference on Empirical Methods in Natural Language Processing (EMNLP)

2016
[24]

Thang Luong, Hieu Pham, and Christopher D. Manning. 2015. Effective approaches to attention-based neural machine translation. In Proceedings of the Conference on Empirical Methods in Natural Language Processing (EMNLP)

2015
[25]

Anders M ller. 2017. dk.brics.automaton -- finite-state automata and regular expressions for Java . http://www.brics.dk/automaton/

2017
[26]

Maxwell Nye, Luke Hewitt, Joshua Tenenbaum, and Armando Solar-Lezama. 2019. Learning to infer program sketches. In Proceedings of the International Conference on Machine Learning (ICML)

2019
[27]

Augustus Odena and Charles Sutton. 2020. Learning to represent programs with property signatures. In Proceedings of the International Conference on Learning Representations (ICLR)

2020
[28]

Jun-U Park, Sang-Ki Ko, Marco Cognetta, and Yo-Sub Han. 2019. S oft R egex: Generating regex from natural language descriptions using softened regex equivalence. In Proceedings of the Conference on Empirical Methods in Natural Language Processing and the International Joint Co...

2019
[29]

Adam Paszke, Sam Gross, Francisco Massa, Adam Lerer, James Bradbury, Gregory Chanan, Trevor Killeen, Zeming Lin, Natalia Gimelshein, Luca Antiga, Alban Desmaison, Andreas Kopf, Edward Yang, Zachary DeVito, Martin Raison, Alykhan Tejani, Sasank Chilamkurthy, Benoit Steiner, Lu ...

2019
[30]

Illia Polosukhin and Alexander Skidanov. 2018. Neural program search: Solving programming tasks from description and examples. In Workshop at the International Conference on Learning Representations (ICLR Workshop)

2018
[31]

Chris Quirk, Raymond Mooney, and Michel Galley. 2015. Language to code: Learning semantic parsers for if-this-then-that recipes. In Proceedings of the Annual Meeting of the Association for Computational Linguistics and the International Joint Conference on Natural Language Pro...

2015
[32]

Maxim Rabinovich, Mitchell Stern, and Dan Klein. 2017. Abstract syntax networks for code generation and semantic parsing. In Proceedings of the Annual Meeting of the Association for Computational Linguistics (ACL)

2017
[33]

Aarne Ranta. 1998. A multilingual natural-language interface to regular expressions. In Finite State Methods in Natural Language Processing

1998
[34]

Richard Shin, Miltiadis Allamanis, Marc Brockschmidt, and Oleksandr Polozov. 2019. Program synthesis and semantic parsing with learned code idioms. In Advances in Neural Information Processing Systems (NeurIPS)

2019
[35]

Armando Solar-Lezama. 2008. Program Synthesis by Sketching. Ph.D. thesis, University of California at Berkeley

2008
[36]

Alane Suhr, Srinivasan Iyer, and Yoav Artzi. 2018. Learning to map context-dependent sentences to executable formal queries. In Proceedings of the 2018 Conference of the North A merican Chapter of the Association for Computational Linguistics: Human Language Technologies (NAACL-HLT)

2018
[37]

Bailin Wang, Ivan Titov, and Mirella Lapata. 2019. Learning semantic parsers from denotations with latent structured alignments and abstract programs. In Proceedings of the Conference on Empirical Methods in Natural Language Processing and the International Joint Conference on...

2019
[38]

Xinyu Wang, Sumit Gulwani, and Rishabh Singh. 2016. FIDEX: Filtering Spreadsheet Data Using Examples . In Proceedings of the 2016 ACM SIGPLAN International Conference on Object-Oriented Programming, Systems, Languages, and Applications (OOPSLA)

2016
[39]

Navid Yaghmazadeh, Yuepeng Wang, Isil Dillig, and Thomas Dillig. 2017. Sqlizer: query synthesis from natural language. Proceedings of the ACM on Programming Languages, 1(OOPSLA):1--26

2017
[40]

Pengcheng Yin and Graham Neubig. 2017. A syntactic neural model for general-purpose code generation. In Proceedings of the Annual Meeting of the Association for Computational Linguistics (ACL)

2017
[41]

Luke Zettlemoyer and Michael Collins. 2009. Learning context-dependent mappings from sentences to logical form. In Proceedings of the Joint Conference of the Annual Meeting of the Association for Computational Linguistics ACL

2009
[42]

Ruiqi Zhong, Mitchell Stern, and Dan Klein. 2020. Semantic scaffolds for pseudocode-to-code generation. In Proceedings of the Annual Meeting of the Association for Computational Linguistics (ACL)

2020
[43]

Zexuan Zhong, Jiaqi Guo, Wei Yang, Jian Peng, Tao Xie, Jian-Guang Lou, Ting Liu, and Dongmei Zhang. 2018 a . S em R egex: A semantics-based approach for generating regular expressions from natural language specifications. In Proceedings of the Conference on Empirical Methods i...

2018
[44]

Zexuan Zhong, Jiaqi Guo, Wei Yang, Tao Xie, Jian-Guang Lou, Ting Liu, and Dongmei Zhang. 2018 b . Generating regular expressions from natural language specifications: Are we there yet? In Workshops at the AAAI Conference on Artificial Intelligence (AAAI)

2018

Pith tools

Reviewed August 14, 2026 · model on record in the stance chip above.

[1] [1]

URL: " 'urlintro :=

ENTRY address author booktitle chapter edition editor howpublished institution journal key month note number organization pages publisher school series title type volume year eprint doi pubmed url lastchecked label extra.label sort.label short.list INTEGERS output.state before.all mid.sentence after.sentence after.block STRINGS urlintro eprinturl eprintpr...

[2] [2]

write newline

" write newline "" before.all 'output.state := FUNCTION n.dashify 't := "" t empty not t #1 #1 substring "-" = t #1 #2 substring "--" = not "--" * t #2 global.max substring 't := t #1 #1 substring "-" = "-" * t #2 global.max substring 't := while if t #1 #1 substring * t #2 global.max substring 't := if while FUNCTION word.in bbl.in capitalize " " * FUNCT...

[3] [3]

Alur , R

R. Alur , R. Bodik , G. Juniwal , M. M. K. Martin , M. Raghothaman , S. A. Seshia , R. Singh , A. Solar-Lezama , E. Torlak , and A. Udupa . 2013. Syntax-guided synthesis. In 2013 Formal Methods in Computer-Aided Design (FMCAD)

work page 2013

[4] [4]

Yoav Artzi, Kenton Lee, and Luke Zettlemoyer. 2015. Broad-coverage CCG semantic parsing with AMR . In Proceedings of the Conference on Empirical Methods in Natural Language Processing (EMNLP)

work page 2015

[5] [5]

M Balog, AL Gaunt, M Brockschmidt, S Nowozin, and D Tarlow. 2017. Deepcoder: Learning to write programs. In Proceedings of the International Conference on Learning Representations (ICLR)

work page 2017

[6] [6]

Jonathan Berant, Andrew Chou, Roy Frostig, and Percy Liang. 2013. Semantic parsing on F reebase from question-answer pairs. In Proceedings of the Conference on Empirical Methods in Natural Language Processing (EMNLP)

work page 2013

[7] [7]

Li Dong and Mirella Lapata. 2016. Language to logical form with neural attention. In Proceedings of the Annual Meeting of the Association for Computational Linguistics (ACL)

work page 2016

[8] [8]

Li Dong and Mirella Lapata. 2018. Coarse-to-fine decoding for neural semantic parsing. In Proceedings of the Annual Meeting of the Association for Computational Linguistics (ACL)

work page 2018