pldb/PLDB huggingface dataset:
Touch (textMarkup, appeared 2020)
Website: http://touchlabs.io/play



GitHub description: 📜 Touch Lightweight Markup Language; Familiar, Extendable, Auto-Formattable

/ this is a block comment

= Title
_ Subtitle

== h2
=== h3

/ numbered headings (prefixed with 1 and 1.1)
## h2
### h3

> blockquote
* note
- list
1. numbered list

/ code block
`js
function num() {
    return 1
}
`

/ preformatted block
'
      ___________________________
    < I'm an expert in my field. >
      ---------------------------
          \   ^__^
           \  (oo)\_______
              (__)\       )\/\
                  ||----w |
                  ||     ||
'
/ art from https://developer.mozilla.org/en-US/docs/Web/HTML/Element/pre#example
// an inline comment //
__emphasis__ // italics //
**strong**   // bold //
``code``
((link))
[[link text]]((link URL))

a \ // line break //
b

/ autolinks
www.example.test
http://example.test
https://example.test
TQL (queryLanguage, appeared 2023)
Stands for: TrueBase Query Language
Creators: Breck Yunits
Website: https://truebase.pub/tql/

A language for querying TrueBases.


GitHub description: TrueBase - information you can trust. A novel plain text database for collaborative narrative-free knowledge graphs.

where appeared > 2009
where appeared < 2020
notMissing githubRepo_stars
where type = pl
sortBy githubRepo_stars
select githubRepo_stars
reverse
Transaction Language 1 (pl, appeared 1984)


Transaction Language 1 (TL1) is a widely used management protocol in telecommunications. It is a cross-vendor, cross-technology man-machine language, and is widely used to manage optical (SONET) and broadband access infrastructure in North America. TL1 is used in the input and output messages that pass between Operations Support Systems (OSSs) and Network Elements (NEs). Operations domains such as surveillance, memory administration, and access and testing define and use TL1 messages to accomplish specific functions between the OS and the NE. TL1 is defined in Telcordia Technologies (formerly Bellcore) Generic Requirements document GR-831-CORE.
Treelang (pl, appeared 1988)


Treelang is a "toy" programming language distributed with the GNU Compiler Collection (GCC) to demonstrate the features of its code-generation backend. It was developed by Tim Josling, based on a language called Toy created by Richard Kenner.  During the GCC 4.3 release cycle, a patch was committed to remove the language, because of high maintenance costs outweighing its benefits and also because it was no longer considered a good front-end example by GCC developers.
tremor-query (queryLanguage, appeared 2019)

The tremor query language, tremor-query or trickle is an interpreted statement-oriented language designed for continuous online structured queries with support filtering, extraction, transformation and streaming of structured data in a stream or event-based processing system.



define grouper::bucket operator kfc;

define script categorize
script
  let $rate = 1;
  let $class = event.`group`;
  { "event": event, "rate": $rate, "class": $class };
end;


create script categorize;
# Stream ingested data into categorize script
select event from in into categorize;

create operator kfc;
# Stream scripted events into kfc bucket operator
select event from categorize into kfc;

# Stream bucketed events into out stream
select event from kfc into out;
Trex (grammarLanguage, appeared 2001)
Stands for: Tree Regular Expressions for XML
Creators: James Clark
Website: http://www.thaiopensource.com/trex/

TREX is a new language for validating XML documents. A TREX pattern specifies a pattern for the structure and content of an XML document. A TREX pattern thus identifies a class of XML documents consisting of those documents that match the pattern. A TREX pattern is itself an XML document.



<element name="addressBook">
  <zeroOrMore>
    <element name="card">
      <element name="name">
        <anyString/>
      </element>
      <element name="email">
        <anyString/>
      </element>
    </element>
  </zeroOrMore>
</element>
TriG syntax (dataNotation, appeared 2007)


TriG is a serialization format for RDF (Resource Description Framework) graphs. It is a plain text format for serializing named graphs and RDF Datasets which offers a compact and readable alternative to the XML-based TriX syntax.


@prefix rdf: <http://www.w3.org/1999/02/22-rdf-syntax-ns#> .
 @prefix xsd: <http://www.w3.org/2001/XMLSchema#> .
 @prefix swp: <http://www.w3.org/2004/03/trix/swp-1/> .
 @prefix dc: <http://purl.org/dc/elements/1.1/> .
 @prefix ex: <http://www.example.org/vocabulary#> .
 @prefix : <http://www.example.org/exampleDocument#> .
 
 :G1 { :Monica ex:name "Monica Murphy" .      
       :Monica ex:homepage <http://www.monicamurphy.org> .
       :Monica ex:email <mailto:monica@monicamurphy.org> .
       :Monica ex:hasSkill ex:Management }
 
 :G2 { :Monica rdf:type ex:Person .
       :Monica ex:hasSkill ex:Programming }
 
 :G3 { :G1 swp:assertedBy _:w1 .
       _:w1 swp:authority :Chris .
       _:w1 dc:date "2003-10-02"^^xsd:date .   
       :G2 swp:quotedBy _:w2 .
       :G3 swp:assertedBy _:w2 .
       _:w2 dc:date "2003-09-03"^^xsd:date .
       _:w2 swp:authority :Chris .
       :Chris rdf:type ex:Person .
       :Chris ex:email <mailto:chris@bizer.de> }
Triton (pl, appeared 2021)
Creators: Philippe Tillet
Origin: OpenAI

This is the development repository of Triton, a language and compiler for writing highly efficient custom Deep-Learning primitives. The aim of Triton is to provide an open-source environment to write fast code at higher productivity than CUDA, but also with higher flexibility than other existing DSLs.


GitHub description: Development repository for the Triton language and compiler

# This is a GPU kernel in Triton.
# Different instances of this
# function may run in parallel.
@jit
def add(X, Y, Z, N):
   # In Triton, each kernel instance
   # executes block operations on a
   # single thread: there is no construct
   # analogous to threadIdx
   pid = program_id(0)
   # block of indices
   idx = pid * BLOCK + arange(BLOCK)
   mask = idx < N
   # Triton uses pointer arithmetics  
   # rather than indexing operators
   x = load(X + idx, mask=mask)
   y = load(Y + idx, mask=mask)
   store(Z + idx, x + y, mask=mask)
Troff (textMarkup, appeared 1973)
Country: United States
Website: https://www.troff.org/

The Text Processor for Typesetters

troff  is the major component of a document processing system developed by AT&T Corporation for the Unix operating system. troff features commands to designate fonts, spacing, paragraphs, margins, footnotes and more. Unlike many other text formatters, troff can position characters arbitrarily on a page, even overlapping them, and has a fully programmable input language. Separate preprocessors are used for more convenient production of tables, diagrams, and mathematics. Inputs to troff are plain text files that can be created by any text editor. Extensive macro packages have been created for various document styles. A typical distribution of troff includes the me macros for formatting research papers, man and mdoc macros for creating Unix man pages, mv macros for creating mountable transparencies, and the ms and mm macros for letters, books, technical memoranda, and reports.
Lambda Diagrams (notation, appeared 2014)
Creators: John Tromp
Website: https://tromp.github.io/cl/diagrams.html

Lambda Diagrams are a graphical notation for closed lambda terms, in which abstractions (lambdas) are represented by horizontal lines, variables by vertical lines emanating down from their binding lambda, and applications by horizontal links connecting the leftmost variables. In the alternative style, applications link the nearest deepest variables, for a more stylistic, if less uniform, look.
TRS-80 Color Computer (computingMachine, appeared 1980)


The RadioShack TRS-80 Color Computer (later marketed as the Tandy Color Computer and sometimes nicknamed the CoCo) is a line of home computers based on the Motorola 6809 processor. The Tandy Color Computer line started in 1980 with what is now called the CoCo 1 and ended in 1991 with the more powerful CoCo 3. All three CoCo models maintained a high level of software and hardware compatibility, with few programs written for the older model not running on the newer ones. Despite bearing the TRS-80 name, the Color Computer is a radical departure from the earlier TRS-80; in particular it has a Motorola 6809E processor, rather than the TRS-80's Zilog Z80. The machines in the Color Computer line are not compatible with software made for the earlier TRS-80.
TSV (dataNotation, appeared 1993)
Stands for: tab-separated values


A tab-separated values (TSV) file is a simple text format for storing data in a tabular structure, e.g., database table or spreadsheet data, and a way of exchanging information between databases. Each record in the table is one line of the text file. Each field value of a record is separated from the next by a tab character. The TSV format is thus a type of the more general delimiter-separated values format. TSV is a simple file format that is widely supported, so it is often used in data exchange to move tabular data between different computer programs that support the format. For example, a TSV file might be used to transfer information from a database program to a spreadsheet. TSV is an alternative to the common comma-separated values (CSV) format, which often causes difficulties because of the need to escape commas – literal commas are very common in text data, but literal tab stops are infrequent in running text. The IANA standard for TSV achieves simplicity by simply disallowing tabs within fields.
Tree and Tabular Combined Notation (pl, appeared 1992)
Stands for: Tree and Tabular Combined Notation


TTCN is a programming language used for testing of communication protocols and web services. A TTCN test suite consists of many test cases written in the TTCN programming language. Until version 2 the language was written in tables and called Tree and Tabular Combined Notation. Reading and editing this language required special TTCN editors. Beginning with version 3 TTCN was renamed to Testing and Test Control Notation. It is now closer to current programming languages and can be edited with traditional editors. TTCN-3 is more flexible than TTCN-2 in that it can be used for protocol testing as well as testing traditional software. All versions of TTCN need dedicated compilers or interpreters for execution. TTCN is widely used, for example; ETSI, ITU for the testing of telecommunication protocols. Conformance test cases of ETSI standards like ISDN, DECT, GSM, EDGE, 3G, DSRC have also been written in TTCN. Recently it has also been used for testing various protocol standards e.g. Bluetooth, IP. Execution of those test cases against products (e.g. phones, mobile phones, service enablers or network elements) is used to verify that the protocol implementation in those products meet the requirements defined by telecommunication standards. TTCN is often combined with ASN.1.
Tuple space (pl, appeared 1988)


A tuple space is an implementation of the  associative memory paradigm for parallel/distributed computing. It provides a repository of tuples that can be accessed concurrently. As an illustrative example, consider that there are a group of processors that produce pieces of data and a group of processors that use the data. Producers post their data as tuples in the space, and the consumers then retrieve data from the space that match a certain pattern. This is also known as the blackboard metaphor. Tuple space may be thought as a form of distributed shared memory. Tuple spaces were the theoretical underpinning of the Linda language developed by David Gelernter and Nicholas Carriero at Yale University in 1986. Implementations of tuple spaces have also been developed for Java (JavaSpaces), Lisp, Lua, Prolog, Python, Ruby, Smalltalk, Tcl, and the .NET framework.
tuplemarkup (textMarkup, appeared 2012)
Creators: John Judnich



GitHub description: A minimalist all-purpose markup language: nested lists with bracket-minimizing syntax. It enables XML-like and YAML-like semantics within the same clean and consistent language.

[html |
    Hello. This is an example [b|language] test.
 [ div [class testc] | And this text is enclosed in a div. ]
 [ a [href google.com] | Click this link [i|now] ]
]
Turbo Assembler (pl, appeared 1989)


Turbo Assembler (TASM)  is a computer assembler (software for program development) developed by Borland which runs on and produces code for 16- or 32-bit x86 DOS or Microsoft Windows. It can be used with Borland's high-level language compilers, such as Turbo Pascal, Turbo Basic, Turbo C and Turbo C++. The Turbo Assembler package is bundled with the Turbo Linker, and is interoperable with the Turbo Debugger. TASM can assemble Microsoft Macro Assembler (MASM) source using its MASM mode and has an ideal mode with a few enhancements. Object-Oriented programming has been supported since version 3.0. The last version of Turbo Assembler is 5.4, with files dated 1996 and patches up to 2010; it is still supplied with Delphi and C++Builder. TASM itself is a 16-bit program; it will run on 16- and 32-bit versions of Windows, and produce code for the same versions. There are ways to run 16-bit programs such as TASM on 64-bit Windows (e.g., on a virtual machine), but it will not generate 64-bit Windows code. The Borland Turbo Assembler 5.0 package is supplied on three 3.5-inch diskettes and with three small books.
Turbo-Basic XL (pl, appeared 1985)


This article is about the language for Atari 8-bit computers. Not to be confused with Borland's unrelated Turbo Basic.Turbo-Basic XL is an advanced version of BASIC for the Atari 8-bit family of home computers. It is a compatible superset of the Atari BASIC that was built-in to most Atari machines of the era. Turbo-Basic XL's most notable feature was vastly improved execution speed. An Atari BASIC program loaded into Turbo-BASIC, with no changes made, would generally run about three times as fast. A Turbo-Basic XL compiler was also available that created binary executables, further speeding up program performance to about ten times faster than Atari BASIC. Turbo-Basic XL was developed by Frank Ostrowski and published in the December 1985 issue of German computer magazine Happy Computer. A version for the 400/800 models was released shortly after, known as Frost Basic 1.4.
Turbo Basic (pl, appeared 1987)


PowerBASIC, formerly Turbo Basic, is the brand of several commercial compilers by PowerBASIC Inc. that compile a dialect of the BASIC programming language. There are both MS-DOS and Windows versions, and two kinds of the latter:  Console and Windows.  The MS-DOS version has a syntax similar to that of QBasic and QuickBASIC.  The Windows versions use a BASIC syntax expanded to include many Windows functions, and the statements can be combined with calls to the Windows API.
Turbo Pascal (compiler, appeared 1983)
Country: United States


Turbo Pascal is a software development system that includes a compiler and an integrated development environment (IDE) for the Pascal programming language running on CP/M, CP/M-86, and MS-DOS, developed by Borland under Philippe Kahn's leadership. For versions 6 and 7 (last), both a lower-priced Turbo Pascal and more expensive Borland Pascal were produced; Borland Pascal was more oriented towards professional software development, with more libraries and standard library source code. The name Borland Pascal is also used more generically for Borland's dialect of the Pascal programming language, significantly different from Standard Pascal. Borland has released three old versions of Turbo Pascal free of charge because of their historical interest: the original Turbo Pascal (now known as 1.0), and versions 3.02 and 5.5 for DOS.
Turing (pl, appeared 1982)
Creators: Ric Holt
Country: Canada


Turing is a Pascal-like programming language developed in 1982 by Ric Holt and James Cordy, then of University of Toronto, Canada. Turing is a descendant of Euclid, Pascal and SP/k that features a clean syntax and precise machine-independent semantics. Turing 4.1.0 is the latest stable version of Turing. Turing 4.1.1 and Turing 4.1.2 do not allow for stand alone .EXE files to be created and versions before Turing 4.1.0 have outdated syntax and outdated functions.


% Accepts a number and calculates its factorial

function factorial (n: int) : real
     if n = 0 then
          result 1
     else
          result n * factorial (n - 1)
     end if
end factorial

var n: int
loop
     put "Please input an integer: " ..
     get n
     exit when n >= 0
     put "Input must be a non-negative integer."
end loop

put "The factorial of ", n, " is ", factorial (n)
turnstile (grammarLanguage, appeared 2017)
Creators: Stephen Chang
Alex Knauth
Ben Greenman
Milo Turner
Michael Ballantyne

Turnstile aims to help Racket programmers create typed languages. It does so with extensions of Racket’s macro-definition forms that facilitate implementation of type rules alongside normal macro code. As a result, the macros implementing a new language directly type check the program during expansion, obviating the need to create and call out to a separate type checker. Thus, a complete typed language implementation remains a series of macro definitions that may be imported and exported in the standard way that Racket programmers are accustomed to.



#lang turnstile
(provide → Int λ #%app #%datum + ann)
 
(define-base-type Int)
(define-type-constructor → #:arity > 0)
 
(define-primop + : (→ Int Int Int))
 
; [APP]
(define-typed-syntax (#%app e_fn e_arg ...) ≫
  [⊢ e_fn ≫ e_fn- ⇒ (~→ τ_in ... τ_out)]
  #:fail-unless (stx-length=? #'[τ_in ...] #'[e_arg ...])
                (format "arity mismatch, expected ~a args, given ~a"
                        (stx-length #'[τ_in ...]) #'[e_arg ...])
  [⊢ e_arg ≫ e_arg- ⇐ τ_in] ...
  --------
  [⊢ (#%app- e_fn- e_arg- ...) ⇒ τ_out])
 
; [LAM]
(define-typed-syntax λ #:datum-literals (:)
  [(_ ([x:id : τ_in:type] ...) e) ≫
   [[x ≫ x- : τ_in.norm] ... ⊢ e ≫ e- ⇒ τ_out]
   -------
   [⊢ (λ- (x- ...) e-) ⇒ (→ τ_in.norm ... τ_out)]]
  [(_ (x:id ...) e) ⇐ (~→ τ_in ... τ_out) ≫
   [[x ≫ x- : τ_in] ... ⊢ e ≫ e- ⇐ τ_out]
   ---------
   [⊢ (λ- (x- ...) e-)]])
 
; [ANN]
(define-typed-syntax (ann e (~datum :) τ:type) ≫
  [⊢ e ≫ e- ⇐ τ.norm]
  --------
  [⊢ e- ⇒ τ.norm])
 
; [DATUM]
(define-typed-syntax #%datum
  [(_ . n:integer) ≫
   --------
   [⊢ (#%datum- . n) ⇒ Int]]
  [(_ . x) ≫
   --------
   [#:error (type-error #:src #'x
                        #:msg "Unsupported literal: ~v" #'x)]])
Turtle (dataNotation, appeared 2011)


Terse RDF Triple Language (Turtle) is a syntax and file format for expressing data in the Resource Description Framework (RDF) data model. Turtle syntax is similar to that of SPARQL, an RDF query language. RDF represents information using semantic triples, which comprise a subject, predicate, and object. Each item in the triple is expressed as a Web URI. Turtle provides a way to group three URIs to make a triple, and provides ways to abbreviate such information, for example by factoring out common portions of URIs. For example:   <http://example.org/person/Mark_Twain>     <http://example.org/relation/author>     <http://example.org/books/Huckleberry_Finn> .


@prefix rdf: <http://www.w3.org/1999/02/22-rdf-syntax-ns#> .
@prefix dc: <http://purl.org/dc/elements/1.1/> .
@prefix ex: <http://example.org/stuff/1.0/> .

<http://www.w3.org/TR/rdf-syntax-grammar>
  dc:title "RDF/XML Syntax Specification (Revised)" ;
  ex:editor [
    ex:fullname "Dave Beckett";
    ex:homePage <http://purl.org/net/dajobe/>
  ] .
TUTOR (pl, appeared 1969)
Creators: Paul Tenczar
Richard Blomme


TUTOR (also known as PLATO Author Language) is a programming language developed for use on the PLATO system at the University of Illinois at Urbana-Champaign around 1965. TUTOR was initially designed by Paul Tenczar for use in computer assisted instruction (CAI) and computer managed instruction (CMI) (in computer programs called "lessons") and has many features for that purpose. For example, TUTOR has powerful answer-parsing and answer-judging commands, graphics, and features to simplify handling student records and statistics by instructors. TUTOR's flexibility, in combination with PLATO's computational power (running on what was considered a supercomputer in 1972), also made it suitable for the creation of many non-educational lessons—that is, games—including flight simulators, war games, dungeon style multiplayer role-playing games, card games, word games, and medical lesson games such as Bugs and Drugs (BND).
Twig (template, appeared 2009)
Website: https://twig.symfony.com/
Keywords: apply
autoescape
block
deprecated
do
embed
extends
flush
for
from
if
import
include
macro
sandbox
set
use
verbatim
with
endapply
endautoescape
endblock
endembed
endfor
endif
endmacro
endsandbox
endset
endwith
true
false


Twig is a template engine for the PHP programming language. Its syntax originates from Jinja and Django templates. It's an open source product licensed under a BSD License and maintained by Fabien Potencier. The initial version was created by Armin Ronacher. Symfony2 PHP framework comes with a bundled support for Twig as its default template engine.

GitHub description: a template engine for the chyrp blog engine.

{% extends "base.html" %}
{% block navigation %}
    <ul id="navigation">
    {% for item in navigation %}
        <li>
            <a href="{{ item.href }}">
                {% if item.level == 2 %}&nbsp;&nbsp;{% endif %}
                {{ item.caption|upper }}
            </a>
        </li>
    {% endfor %}
    </ul>
{% endblock navigation %}
TXL (pl, appeared 1985)
Creators: James Cordy


TXL is a special-purpose programming language originally designed by Charles Halpern-Hamu and James Cordy at the University of Toronto in 1985.  The acronym "TXL" originally stood for "Turing eXtender Language" after the language's original purpose, the specification and rapid prototyping of variants and extensions of the Turing programming language, but no longer has any meaningful interpretation. Modern TXL is specifically designed for creating, manipulating and rapidly prototyping language-based descriptions, tools and applications using source transformation.   It is a hybrid functional / rule-based language using first order functional programming at the higher level and term rewriting at the lower level.  The formal semantics and implementation of TXL are based on formal term rewriting, but the term structures are largely hidden from the user due to the example-like style of pattern specification. Each TXL program has two components: a description of the source structures to be transformed, specified as a (possibly ambiguous) context-free grammar using an extended Backus–Naur Form; and a set of tree transformation rules, specified using pattern / replacement pairs combined using first order functional programming.  TXL is designed to allow explicit programmer control over the interpretation, application, order and backtracking of both parsing and rewriting rules, allowing for expression of a wide range of grammar-based techniques such as agile parsing. The first component parses the input expression into a tree using pattern-matching. The second component uses Term-rewriting in a manner similar to Yacc to produce the transformed output. TXL is most commonly used in software analysis and reengineering tasks such as design recovery, and in rapid prototyping of new programming languages and dialects.