Tootfinder

Fascinating talk on
Type Theory in Type Theory using a Strictified Syntax
Presented by Ambrus Kaposi, joint work with Loïc Pujet.
#icfpsplash25

Type Theory with Single Substitutions
Ambrus Kaposi (E\"otv\"os Lor\'and University), Szumi Xie (E\"otv\"os Lor\'and University)
https://arxiv.org/abs/2510.12303

Type Theory with Single Substitutions
Type theory can be described as a generalised algebraic theory. This automatically gives a notion of model and the existence of the syntax as the initial model, which is a quotient inductive-inductive type. Algebraic definitions of type theory include Ehrhard's definition of model, categories with families (CwFs), contextual categories, Awodey's natural models, C-systems, B-systems. With the exception of B-systems, these notions are based on a parallel substitution calculus where substitutions …

GUPPY: Pythonic Quantum-Classical Programming
Mark Koch, Alan Lawrence, Kartik Singhal, Seyon Sivarajah, Ross Duncan
https://arxiv.org/abs/2510.12582 https://

GUPPY: Pythonic Quantum-Classical Programming
We present ongoing work on Guppy, a domain-specific language embedded in Python that allows users to write high-level hybrid quantum programs with complex control flow in Pythonic syntax, aiming to run them on actual quantum hardware.

Prediction for #csharp 15 syntax: dot shorthand assignment. #dotnet

Large Language Models Are Effective Code Watermarkers
Rui Xu, Jiawei Chen, Zhaoxia Yin, Cong Kong, Xinpeng Zhang
https://arxiv.org/abs/2510.11251 https://a…

Large Language Models Are Effective Code Watermarkers
The widespread use of large language models (LLMs) and open-source code has raised ethical and security concerns regarding the distribution and attribution of source code, including unauthorized redistribution, license violations, and misuse of code for malicious purposes. Watermarking has emerged as a promising solution for source attribution, but existing techniques rely heavily on hand-crafted transformation rules, abstract syntax tree (AST) manipulation, or task-specific training, limiting …

from my link log —
SGML syntax reference.
http://sgmljs.sgml.net/docs/sgmlrefman.html
saved 2025-12-08 https://dotat.at/:/4299U.html…

I just found a relatively new tool for syntax-aware diff/merge operations on git repositories ( #Mergiraf ).
Unlike other tools I've tried in the past, this one is also diff3-friendly .
- https://mergiraf.org/
- https://lwn.net/Articles/1042355/
For the weirdos like me who prefer `rebase` over `merge` this can be a great mood & productivity booster

Polars is a lightning fast DataFrame library/in-memory query engine with parallel execution and cache efficiency. And now you can use is with the tidyverse syntax: #rstats

More Efficient Tidyverse Code, Using Polars in the Background
Polars is a cross-language tool for manipulating very large data. However, one drawback is that the R implementation has a syntax that will look odd to many R users who are not used to Python syntax. The objective of tidypolars is to improve the ease-of-use of Polars in R by providing tidyverse syntax to polars.

On the Formal Metatheory of the Pure Type Systems using One-sorted Variable Names and Multiple Substitutions
Sebasti\'an Urciuoli (Universidad ORT Uruguay)
https://arxiv.org/abs/2510.12300

On the Formal Metatheory of the Pure Type Systems using One-sorted Variable Names and Multiple Substitutions
We develop formal theories of conversion for Church-style lambda-terms with Pi-types in first-order syntax using one-sorted variables names and Stoughton's multiple substitutions. We then formalize the Pure Type Systems along some fundamental metatheoretic properties: weakening, syntactic validity, closure under alpha-conversion and substitution. Finally, we compare our formalization with others related. The whole development has been machine-checked using the Agda system. Our work demonstrate…

@… yeah, I think it’s time. It’s the #1 template syntax that folks use in Eleventy so it makes sense
Made a lot of progress yesterday: https://github.com/11ty/nunjucks/

TIT: A Tree-Structured Instruction Tuning Approach for LLM-Based Code Translation
He Jiang, Yufu Wang, Hao Lin, Peiyu Zou, Zhide Zhou, Ang Jia, Xiaochen Li, Zhilei Ren
https://arxiv.org/abs/2510.09400 …

TIT: A Tree-Structured Instruction Tuning Approach for LLM-Based Code Translation
Large Language Models (LLMs) have shown strong performance in automated source-to-target code translation through pretraining on extensive code corpora. However, mainstream LLM-based code translation methods suffer from two critical limitations. First, they are highly sensitive to language-specific features, which often introduce source-language syntax or lexicon into the output, leading to syntactic confusion. Second, they lack fine-grained semantic alignment due to an over-reliance on functio…

Next TyDe talk ongoing:
Towards a Performance Comparison of Syntax and Type-Directed NbE (Extended Abstract)
Chester Gould University of British Columbia, William J. Bowman University of British Columbia
https://share.google/79PnZU3mzT6VrYgFi

"What color is your function?" is a wonderful title. It's so good, the title alone could win the Sundance Festival.
But that post is about a JavaScript-specific limitation (not applicable to other languages), and some wishful bikeshedding about syntax (which turns out to be a leaky abstraction that makes locking ambiguous, very problematic in low-level languages).
But *color* is so catchy. It's not well defined that post, but you can't have "color"…

AI Coding Sucks by Syntax
#webdev #coding

Syntax-Guided Diffusion Language Models with User-Integrated Personalization
Ruqian Zhang, Yijiao Zhang, Juan Shen, Zhongyi Zhu, Annie Qu
https://arxiv.org/abs/2510.01028 https:…

Syntax-Guided Diffusion Language Models with User-Integrated Personalization
Large language models have made revolutionary progress in generating human-like text, yet their outputs often tend to be generic, exhibiting insufficient structural diversity, which limits personalized expression. Recent advances in diffusion models have opened new opportunities for improving language generation beyond the limitations of autoregressive paradigms. In this work, we propose a syntax-guided diffusion language model that integrates structural supervision and personalized conditionin…

So, since I found a bug in #logseq where pasting formatted notes from MS Teams causes logseq to use incorrect bold markdown syntax ([space]** at the end of a phrase instead of just **), I wrote this sed script to fix the logseq markdown files after I paste content in:
$ cat fix_logseg_bold_journals.sh
#!/bin/bash
cd /Users/faucherd/Documents//Logseq/journals
sed -i '…

Tags are sets. Many apps support tagging of content, but most of them (incl. Mastodon) treat tags only as singular/isolated topic filters, akin to a flat folder-based approach. But tagging can be so, so much more powerful when treating tags as sets and offering users the possibility to combine and query tagged content as sets (think Venn diagrams), i.e. allowing tags to be combined using AND/OR/NOT aka intersection/union/difference operations...
Below is a simple query engine to do jus…

Mergiraf: syntax-aware #merging for #Git
https://lwn.net/Articles/1042355/

Ran into this little quirk of (many) C-syntax languages, yesterday. Hadn't seen it before.
#PHP
```
<?php
function getApiData() {
https://example.org/api
return file_get_contents("

0:th day of the #icfpsplash25 week starts at NUS School of computing, on Computing Drive. (A glorious tree symbolising all the syntax trees we will see during the week;-)

How many years before I get used to the weird-ass syntax that Python has?

A freely available masterclass! 👇

holy cow, painful debugging session
offspring managed to break networkmanager by editing a config file
NM died with an unhelpful error message complaining about the syntax of a [connection] line
it looked ok in vim
it looked ok from cat -v
it looked the same as the file from the source package
but diff said the [connection] lines were invisibly different!
hexdump -C revealed that the broken file started with a UTF-8 BOM
i have encouraged him to…

Syntax is not Semantics
Language is not the same as intelligence.
The entire AI bubble is built on ignoring that.
https://www.theverge.com/ai-artificial-intelligence/827820/large-language-models-ai-intellige…

Large language mistake
Neuroscience indicates language is distinct from thought, raising questions about whether AI large language models are a viable path to artificial general intelligence.

Update: it is no longer clear.
My current work around is to extract the list of linked files and relink my hand after egrep -v list-of-swift-syntax-symbols. What a horrible hack
https://mastodon.social/@Migueldeicaza/115600154465997324

トレンドワードがSyntax errorになっていてほっこりした（しない）

Where rust fails miserably for me it's in the lifetime syntax. The feature is pretty awesome, but the syntax is orrible:
- for some reason giving short names to variables is a bad idea, but somehow the standard around lifetime names is single letters, often just 'a
- it's extremely unclear to me which lifetime is the declaration and which one is the use of it. Example:
impl<'a> Foo for Bar<'a> {}
Which one is the declararion of the two?

TyDe 2025 continues:
Jeremy Siek presenting "Gradual Metaprogramming" with proofs in Agda.
https://conf.researchr.org/details/icfp-splash-2025/tyde-2025-papers/1/Gradual-Metaprogramming

Been updating my personal Mastodon tooling to download and convert my bookmarked toots. Here's how little code is needed to download a single message and convert its HTML content into Markdown, all using these #ThingUmbrella packages:
- https://thi.…

Replaced article(s) found for cs.MS. https://arxiv.org/list/cs.MS/new
[1/1]:
- The Syntax and Semantics of einsum
Maurice Wenig, Paul G. Rump, Mark Blacher, Joachim Giesen

Crosslisted article(s) found for cs.FL. https://arxiv.org/list/cs.FL/new
[1/1]:
- Unraveling Syntax: How Language Models Learn Context-Free Grammars
Laura Ying Schulz, Daniel Mitropolsky, Tomaso Poggio

EvolProver: Advancing Automated Theorem Proving by Evolving Formalized Problems via Symmetry and Difficulty
Yuchen Tian, Ruiyuan Huang, Xuanwu Wang, Jing Ma, Zengfeng Huang, Ziyang Luo, Hongzhan Lin, Da Zheng, Lun Du
https://arxiv.org/abs/2510.00732

EvolProver: Advancing Automated Theorem Proving by Evolving Formalized Problems via Symmetry and Difficulty
Large Language Models (LLMs) for formal theorem proving have shown significant promise, yet they often lack generalizability and are fragile to even minor transformations of problem statements. To address this limitation, we introduce a novel data augmentation pipeline designed to enhance model robustness from two perspectives: symmetry and difficulty. From the symmetry perspective, we propose two complementary methods: EvolAST, an Abstract Syntax Tree (AST) based approach that targets syntacti…

Stable first order theories as simplicial profinite sets
Misha Gavrilovich
https://arxiv.org/abs/2510.00854 https://arxiv.org/pdf/2510.00854

Stable first order theories as simplicial profinite sets
We rewrite simplicially the standard definitions of a complete first order theory, a model of it, and various characterisations of stability of a complete first order theory. In our reformulations the simplicial language replaces the standard definitions based on syntax, making them formally unnecessary. We view a complete first-order theory as a symmetric simplicial object in the category of profinite sets and open continuous maps, defined by the functor sending a finite set of variables int…

I think the sheer existence of particularly https://yaml-multiline.info/ just shows how beautiful YAML is. :D

{nplyr} has helper functions to work on nested dataframes: #rstats #datascience

A Grammar of Nested Data Manipulation
Provides functions for manipulating nested data frames in a list-column using dplyr syntax. Rather than unnesting, then manipulating a data frame, nplyr allows users to manipulate each nested data frame directly. nplyr is a wrapper for dplyr functions that provide tools for common data manipulation steps: filtering rows, selecting columns, summarising grouped data, among others.

from my link log —
META II: a syntax-oriented compiler writing language. (1964)
https://dl.acm.org/doi/10.1145/800257.808896
saved 2020-06-14 https://

The Command Line GUIde: Graphical Interfaces from Man Pages via AI
Saketh Ram Kasibatla, Kiran Medleri Hiremath, Raven Rothkopf, Sorin Lerner, Haijun Xia, Brian Hempel
https://arxiv.org/abs/2510.01453 …

The Command Line GUIde: Graphical Interfaces from Man Pages via AI
Although birthed in the era of teletypes, the command line shell survived the graphical interface revolution of the 1980's and lives on in modern desktop operating systems. The command line provides access to powerful functionality not otherwise exposed on the computer, but requires users to recall textual syntax and carefully scour documentation. In contrast, graphical interfaces let users organically discover and invoke possible actions through widgets and menus. To better expose the power of…

Extended Abstract: Towards a Performance Comparison of Syntax and Type-Directed NbE
Chester J. F. Gould, William J. Bowman
https://arxiv.org/abs/2509.13489 https://

Extended Abstract: Towards a Performance Comparison of Syntax and Type-Directed NbE
A key part of any dependent type-checker is the method for checking whether two types are equal. A common claim is that syntax-directed equality is more performant, although type-directed equality is more expressive. However, this claim is difficult to make precise, since implementations choose only one or the other approach, making a direct comparison impossible. We present some work-in-progress developing a realistic platform for direct, apples-to-apples, comparison of the two approaches, qua…

GramTrans: A Better Code Representation Approach in Code Generation
Zhao Zhang, Qingyuan Liang, Zeyu Sun, Yizhou Chen, Guoqing Wang, Yican Sun, Lu Zhang, Ge Li, Yingfei Xiong
https://arxiv.org/abs/2510.02887

GramTrans: A Better Code Representation Approach in Code Generation
Code generation has shown great promise in assisting software development. A fundamental yet underexplored question is how the choice of code representation affects model performance. While existing studies employ various representations, such as treating code as plain text, grammar rule sequences, or syntax tree sequences, they lack a principled understanding of the relationship between parsing difficulty and model effectiveness. This paper proposes a conjecture: the easier a representation is…

Neither #Affinity nor #Darktable seemingly support 1D LUTs, which would have been too easy and useful for my #DigitalNegative preparation tool... Instead they both insist on using only 3D LUT…

Terminal users who use #accessibility tools, what is your take on emoji in console applications, especially compared to marker characters (eg. angular brackets for directions or hashes for comments) and to explicitly spelled out labels?
Does an "info" emoji render "ℹ️ Some information" (or a warning as in "⚠️ X went wrong") get across well for terminal assi…

Mojo: MLIR-Based Performance-Portable HPC Science Kernels on GPUs for the Python Ecosystem
William F. Godoy, Tatiana Melnichenko, Pedro Valero-Lara, Wael Elwasif, Philip Fackler, Rafael Ferreira Da Silva, Keita Teranishi, Jeffrey S. Vetter
https://arxiv.org/abs/2509.21039

Mojo: MLIR-Based Performance-Portable HPC Science Kernels on GPUs for the Python Ecosystem
We explore the performance and portability of the novel Mojo language for scientific computing workloads on GPUs. As the first language based on the LLVM's Multi-Level Intermediate Representation (MLIR) compiler infrastructure, Mojo aims to close performance and productivity gaps by combining Python's interoperability and CUDA-like syntax for compile-time portable GPU programming. We target four scientific workloads: a seven-point stencil (memory-bound), BabelStream (memory-bound), miniBUDE (co…

Gotta love a "minor" release that completely rewrites configuration syntax and doesn't provide backward compatibility or migration tooling.

A Complete Diagrammatic Calculus for Conditional Gaussian Mixtures
Mateo Torres-Ruiz, Robin Piedeleu, Alexandra Silva, Fabio Zanasi
https://arxiv.org/abs/2510.04649 https://

A Complete Diagrammatic Calculus for Conditional Gaussian Mixtures
We extend the synthetic theories of discrete and Gaussian categorical probability by introducing a diagrammatic calculus for reasoning about hybrid probabilistic models in which continuous random variables, conditioned on discrete ones, follow a multivariate Gaussian distribution. This setting includes important classes of models such as Gaussian mixture models, where each Gaussian component is selected according to a discrete variable. We develop a string diagrammatic syntax for expressing and…

The Syntax and Semantics of einsum
Maurice Wenig, Paul G. Rump, Mark Blacher, Joachim Giesen
https://arxiv.org/abs/2509.20020 https://arxiv.org/pdf/2509.20…

The Syntax and Semantics of einsum
In 2011, einsum was introduced to NumPy as a practical and convenient notation for tensor expressions in machine learning, quantum circuit simulation, and other fields. It has since been implemented in additional Python frameworks such as PyTorch and TensorFlow, as well as in other programming languages such as Julia. Despite its practical success, the einsum notation still lacks a solid theoretical basis, and is not unified across the different frameworks, limiting opportunities for formal rea…

Parametric Distributive Laws: uniform monad composition
Lorenzo Perticone
https://arxiv.org/abs/2509.22208 https://arxiv.org/pdf/2509.22208

Parametric Distributive Laws: uniform monad composition
Monads play an important role in both the syntax and semantics of modern functional programming languages. The problem of combining them has been of profound interest at least since the 90s, and different approaches have been employed to tackle it: currently, the most prevalent notion is that of monad transformers. We provide a novel abstract framework to describe such "compositions" which we call parametric distributive laws. Our description of this framework hinges on the theory of 2-categori…

@… @… @… sounds like you might want to skip syntax highlighting in your RSS feed — the easiest app…

Learning the Wrong Lessons: Syntactic-Domain Spurious Correlations in Language Models
Chantal Shaib, Vinith M. Suriyakumar, Levent Sagun, Byron C. Wallace, Marzyeh Ghassemi
https://arxiv.org/abs/2509.21155

Learning the Wrong Lessons: Syntactic-Domain Spurious Correlations in Language Models
For an LLM to correctly respond to an instruction it must understand both the semantics and the domain (i.e., subject area) of a given task-instruction pair. However, syntax can also convey implicit information Recent work shows that syntactic templates--frequent sequences of Part-of-Speech (PoS) tags--are prevalent in training data and often appear in model outputs. In this work we characterize syntactic templates, domain, and semantics in task-instruction pairs. We identify cases of spurious …

The unwrap thing is the equivalent of ignoring the return value of C functions that can fail.
I still prefer the Rust syntax for this, at least ignoring the error is explicit text in code.
In C ignoring a possible error is silent. To spot the error one would need to know the function signature and documentation in advance.
Side note: exceptions are even worse in my humble opinion. They have the advantage of giving more information about an error than just a null or a negativ…

The Groupoid-syntax of Type Theory is a Set
Thorsten Altenkirch, Ambrus Kaposi, Szumi Xie
https://arxiv.org/abs/2509.14988 https://arxiv.org/pdf/2509.14988…

The Groupoid-syntax of Type Theory is a Set
Categories with families (CwFs) have been used to define the semantics of type theory in type theory. In the setting of Homotopy Type Theory (HoTT), one of the limitations of the traditional notion of CwFs is the requirement to set-truncate types, which excludes models based on univalent categories, such as the standard set model. To address this limitation, we introduce the concept of a Groupoid Category with Families (GCwF). This framework truncates types at the groupoid level and incorporate…

{lubridate} makes working with dates in R just that little bit easier: #rstats #dates<…

Make Dealing with Dates a Little Easier
Functions to work with date-times and time-spans: fast and user friendly parsing of date-time data, extraction and updating of components of a date-time (years, months, days, hours, minutes, and seconds), algebraic manipulation on date-time and time-span objects. The lubridate package has a consistent and memorable syntax that makes working with dates easy and fun.

SolContractEval: A Benchmark for Evaluating Contract-Level Solidity Code Generation
Zhifan Ye, Jiachi Chen, Zhenzhe Shao, Lingfeng Bao, Xiaohu Yang, Zhongxin Liu
https://arxiv.org/abs/2509.23824

SolContractEval: A Benchmark for Evaluating Contract-Level Solidity Code Generation
The rise of blockchain has brought smart contracts into mainstream use, creating a demand for smart contract generation tools. While large language models (LLMs) excel at generating code in general-purpose languages, their effectiveness on Solidity, the primary language for smart contracts, remains underexplored. Solidity constitutes only a small portion of typical LLM training data and differs from general-purpose languages in its version-sensitive syntax and limited flexibility. These factors…

Tiny Wiki 1.1 has become a little bit larger code (13KB), but now supports also tables, images and can be extended by arbitrary javascript functions.
https://belle-nuit.com/tiny-wiki/index.html?name=syntax

Crosslisted article(s) found for cs.MS. https://arxiv.org/list/cs.MS/new
[1/1]:
- The Syntax and Semantics of einsum
Maurice Wenig, Paul G. Rump, Mark Blacher, Joachim Giesen

from my link log —
Arend: a theorem prover based on Homotopy Type Theory.
https://arend-lang.github.io/
saved 2019-08-07 https://dotat.at/:/AR6J2.html

Transporting Theorems about Typeability in LF Across Schematically Defined Contexts
Chase Johnson, Gopalan Nadathur
https://arxiv.org/abs/2509.26362 https://

Transporting Theorems about Typeability in LF Across Schematically Defined Contexts
The dependently-typed lambda calculus LF is often used as a vehicle for formalizing rule-based descriptions of object systems. Proving properties of object systems encoded in this fashion requires reasoning about formulas over LF typing judgements. An important characteristic of LF is that it supports a higher-order abstract syntax representation of binding structure. When such an encoding is used, the typing judgements include contexts that assign types to bound variables and formulas must the…

Make sure your code follows a consitent style using the {lintr} package. #rstats

A Linter for R Code
Checks adherence to a given style, syntax errors and possible semantic issues. Supports on the fly checking of R code edited with RStudio IDE, Emacs, Vim, Sublime Text, Atom and Visual Studio Code.

Automatic layout of railroad diagrams
Shardul Chiplunkar, Cl\'ement Pit-Claudel
https://arxiv.org/abs/2509.15834 https://arxiv.org/pdf/2509.15834

Automatic layout of railroad diagrams
Railroad diagrams (also called "syntax diagrams") are a common, intuitive visualization of grammars, but limited tooling and a lack of formal attention to their layout mostly confines them to hand-drawn documentation. We present the first formal treatment of railroad diagram layout along with a principled, practical implementation. We characterize the problem as compiling a *diagram language* (specifying conceptual components and how they connect and compose) to a *layout language* (specifying …

V-GameGym: Visual Game Generation for Code Large Language Models
Wei Zhang, Jack Yang, Renshuai Tao, Lingzheng Chai, Shawn Guo, Jiajun Wu, Xiaoming Chen, Ganqu Cui, Ning Ding, Xander Xu, Hu Wei, Bowen Zhou
https://arxiv.org/abs/2509.20136

V-GameGym: Visual Game Generation for Code Large Language Models
Code large language models have demonstrated remarkable capabilities in programming tasks, yet current benchmarks primarily focus on single modality rather than visual game development. Most existing code-related benchmarks evaluate syntax correctness and execution accuracy, overlooking critical game-specific metrics such as playability, visual aesthetics, and user engagement that are essential for real-world deployment. To address the gap between current LLM capabilities in algorithmic problem…

Generalization of Variadic Structures with Binders: A Tool for Structural Code Comparison
Alexander Baumgartner, Temur Kutsia
https://arxiv.org/abs/2509.25023 https://

Generalization of Variadic Structures with Binders: A Tool for Structural Code Comparison
This paper introduces a novel anti-unification algorithm for the generalization of variadic structures with binders, designed as a flexible tool for structural code comparison. By combining nominal techniques for handling variable binding with support for variadic expressions (common in abstract syntax trees and programming languages), the approach addresses key challenges such as overemphasis on bound variable names and difficulty handling insertions or deletions in code fragments. The algorit…

@… In your note on algebraic type theory you mention the "Lindenbaum-Tarski model generated by the raw syntax of pure MLTT without connectives". Just to be sure, this model is trivial, right? There are no types, so the only context is the terminal one.

ViScratch: Using Large Language Models and Gameplay Videos for Automated Feedback in Scratch
Yuan Si, Daming Li, Hanyuan Shi, Jialu Zhang
https://arxiv.org/abs/2509.11065 https:…

ViScratch: Using Large Language Models and Gameplay Videos for Automated Feedback in Scratch
Block-based programming environments such as Scratch are increasingly popular in programming education, in particular for young learners. While the use of blocks helps prevent syntax errors, semantic bugs remain common and difficult to debug. Existing tools for Scratch debugging rely heavily on predefined rules or user manual inputs, and crucially, they ignore the platform's inherently visual nature. We introduce ViScratch, the first multimodal feedback generation system for Scratch that leve…

Automating Code Generation for Semiconductor Equipment Control from Developer Utterances with LLMs
Youngkyoung Kim, Sanghyeok Park, Misoo Kim, Gangho Yoon, Eunseok Lee, Simon S. Woo
https://arxiv.org/abs/2509.13055

Automating Code Generation for Semiconductor Equipment Control from Developer Utterances with LLMs
Semiconductors form the backbone of modern electronics, with their manufacturing and testing relying on highly specialized equipment and domain-specific programming languages. Equipment languages such as the Algorithmic Pattern Generator (ALPG) are critical for precise hardware control but are challenging to program due to their low-level syntax and steep learning curve. While large language models (LLMs) have shown promise in generating high-level code from natural language, their effectivenes…