pldb/PLDB huggingface dataset:
Caml (pl, appeared 1985)
Stands for: Categorical abstract machine language
Creators: Gérard Huet
Guy Cousineau
Ascánder Suárez
Pierre Weis
Michel Mauny
Origin: INRIA
Country: France
Website: https://caml.inria.fr


Caml (originally an acronym for Categorical abstract machine language) is a multi-paradigm, general-purpose programming language which is a dialect of the ML programming language family. Caml was developed in France at INRIA and ENS. Like many descendants of ML, Caml is statically typed, strictly evaluated, and uses automatic memory management. OCaml, as of 2017 the main implementation of Caml, adds many features to the language, including an object layer.
Candy (pl, appeared 2020)
Creators: Jonas Wanke
Marcel Garus
Origin: https://github.com/candy-lang/
Country: Germany
Website: https://github.com/candy-lang/Candy
File extensions: candy



GitHub description: A sweet programming language that is robust, minimalistic, and expressive.

type = use "..Type"
is value := type.is value Struct
hasKey struct key :=
  needs (is struct)
  ✨.structHasKey struct key
getUnwrap struct key :=
  needs (is struct)
  needs (hasKey struct key)
  ✨.structGet struct key
getKeys struct :=
  needs (is struct)
  ✨.structGetKeys struct
CaPSL (pl, appeared 1989)
Origin: Canon Inc
Country: Japan


CaPSL is a printer command language/page description language used by early Canon printers including the LBP-8III series and supported on (at least) LBP-8IV printers. This language was discontinued, with later Canon printers implementing PCL. It was also called LIPS or LIPS4. A Windows Spool File could contain RAW CaPSL data.
Common Authentication Protocol Specification Language (pl, appeared 1996)
Origin: SRI International
Country: United States

a high-level language to support security analysis of cryptographic authentication and key distribution protocols. It is translated to CIL, an intermediate language expressing state transitions with term-rewriting rules. Connectors are being written to adapt CIL to supply input to different security analysis tools, including PVS for inductive verification and Maude for model-checking.
Carbon (pl, appeared 2020)
Origin: https://github.com/carbon-language
Country: United States



GitHub description: Carbon language specification and documentation.

package Sorting api;

fn Partition[T:! Comparable & Movable](s: Slice(T))
     -> i64 {
  var i: i64 = -1;

  for (e: T in s) {
    if (e <= s.Last()) {
      ++i;
      Swap(&s[i], &e);
    }
  }
  return i;
}

fn QuickSort[T:! Comparable & Movable](s: Slice(T)) {
  if (s.Size() <= 1) {
    return;
  }
  let p: i64 = Partition(s);
  QuickSort(s[:p - 1]));
  QuickSort(s[p + 1:]));
}
Carpet (pl, appeared 1997)
Creators: Giandomenico Spezzano
Domenico Talia
Origin: University of Calabria
Country: Italy

This paper describes CARPET, a high-level programming language based on the cellular automata model. CARPET is a programming language designed to support the development of parallel high performance software. It exploits the computing power of a highly parallel computer releasing a user from using explicit parallel constructs. A CARPET implementation has been used for programming cellular algorithms in the CAMEL parallel environment. By CARPET a user might write programs to describe the actions of thousands of simple active agents interacting locally, then the CAMEL environment allows a user to observe the global complex evolution that arises from their parallel execution and their local interactions.



cadef
{
dimension 2;
radius 1;
state (short which, rand, gas);
neighbor Margolus[9]([1,0]East,[1,1]SE,[0,1]South,[-1,1]SO,
 [-1,0]West,[-1,-1]NW,[0,-1]North,[1,-1] NE,[1,0] East);
}
 int i; short temp, temprand;
{
if((cell_which == 0 && step %2 == 1)||(cell_which == 3 && step % 2 == 0))
 { temprand = 0;
 for(i=0; i < 3; i++)
 temprand = temprand + Margolus_rand[i];
 temprand = temprand + cell_rand;
 if (temprand % 2 == 1)
 update(cell_gas, South_gas);
 else
 update(cell_gas, East_gas);
 } else
 if((cell_which == 1 && step % 2 == 1)||(cell_which == 2 && step % 2 == 0))
 { temprand = 0;
 for(i=2; i < 5; i++)
 temprand = temprand + Margolus_rand[i];
 temprand = temprand + cell_rand;
 if (temprand % 2 == 1)
 update(cell_gas, West_gas);
 else
 update(cell_gas, South_gas);
 } else
 if((cell_which == 3 && step %2 == 1)||(cell_which == 0 && step % 2 == 0))
{ temprand = 0;
 for(i=4; i < 7; i++)
 temprand = temprand + Margolus_rand[i];
 temprand = temprand + cell_rand;
 if (temprand % 2 == 1)
 update(cell_gas, North_gas);
 else
 update(cell_gas, West_gas);
 } else
 { temprand = 0;
 for (i=6; i < 9; i++)
 temprand= temprand + Margolus_rand[i];
 temprand = temprand + cell_rand;
 if (temprand % 2 == 1)
 update(cell_gas, East_gas);
 else
 update(cell_gas, North_gas);
 }
 temp = (cell_rand + East_rand + North_rand + West_rand + South_rand ) % 2
 up
carth (pl, appeared 2018)
Creators: Johan Johansson
Country: Sweden
Website: https://carth.jo.zone/

Purely functional programming with lisp-syntax. Less infix, more parens!


GitHub description: The Carth programming language. Mirror of https://sr.ht/~jojo/Carth/

;; Note that many of these functions are/will be in the standard
;; library in some shape or form. We just include them all in the same
;; file here to show off more of the syntax and features.

;; ~start~ is the programs entrypoint
(define (start _) (fizzbuzz unit))

(define (fizzbuzz _)
  (for (range 1 100)
       (comp display fizzbuzz')))

(define (fizzbuzz' n)
  (match (Pair (divisible? n 3) (divisible? n 5))
    (case (Pair false false) (my-show-int n))
    (case (Pair true false) "Fizz")
    (case (Pair false true) "Buzz")
    (case (Pair true true) "Fizzbuzz")))

(define my-show-int
  (fun-match
    (case 1 "one")
    (case 2 "two")
    (case n (show-int n))))

;; Apply an action to each element in an iterator
(define (for xs f)
  (match (next xs)
    (case None unit)
    (case (Some (Pair x xs'))
          (seq (f x) (for xs' f)))))

;; Iterator over the closed range $[a, b]$
(define (range a b)
  (Iter (Lazy (if (> a b)
                  (fun _ None)
                (fun _ (Some (Pair a (range (+ a 1) b))))))))

;; Advances an iterator, returning the next value and the rest of the
;; iterator
(define (next (Iter it)) (lively it))

;; An iterator / non-strict list
(type (Iter a)
  (Iter (Lazy (Maybe (Pair a (Iter a))))))

(define (lively (Lazy f))
  (f unit))

;; A lazy, or rather a non-strict value
(type (Lazy a)
  (Lazy (Fun Unit a)))

(type (Maybe a)
  None
  (Some a))

(define (seq a b)
  b)

;; Function composition
(define (comp f g a)
  (f (g a)))

(define (divisible? n m)
  (= (rem n m) 0))

(define (display s)
  (display-inline (str-append s "\n")))

;;; Currying wrappers

(define (rem a b)          (rem-int     (Pair a b)))
(define (= a b)            (eq-int      (Pair a b)))
(define (> a b)            (gt-int      (Pair a b)))
(define (+ a b)            (add-int     (Pair a b)))
(define (str-append s1 s2) (-str-append (Pair s1 s2)))

;;; External functions defined in the foreign-core library

(extern show-int (Fun Int Str))
(extern eq-int (Fun (Pair Int Int) Bool))
(extern gt-int (Fun (Pair Int Int) Bool))
(extern rem-int (Fun (Pair Int Int) Int))
(extern add-int (Fun (Pair Int Int) Int))
(extern display-inline (Fun Str Unit))
(extern -str-append (Fun (Pair Str Str) Str))
Casio BASIC (pl, appeared 2006)
Origin: Casio Computer Co., Ltd
Country: Japan


Casio BASIC is a programming language used in the Casio calculators such as the Classpad, fx-9860G Series, and CFX graphing calculators. The language is a linear structured, BASIC-based programming language. It was devised to allow users to program in commonly performed calculations, such as the Pythagorean theorem and complex trigonometric calculations. Output from the program can be in the form of scrolling or located text, graphs, or by writing data to lists in the calculator memory. Casio also makes label printers which can be used with rolls of paper for the Casio BASIC calculators, and programmes, variables, data, and other items can be exchanged from one calculator to another and to and from a computer via the same kind of cable and audio-type plug used by the TI graphing calculators and/or the same type of cable and mini-USB plug used on HP calculators from the HP48 and many cellular telephones; several models of Casio graphing calculators have both portsThe Casio calculators, as with those of many of the other big three manufacturers' machines, can acquire data from instruments via a data logger to which probes for temperature, light intensity, pH, sound intensity (dBA), voltage and other electrical parameters, as well as other readings, and custom probes to attach to the data logger  can be built and configured for use with the data logger and calculator. Existing instruments can also be modified to interface with the calculator-data logger, in order to collect such data including such things as weather instruments and means of collecting data such as pulse, blood pressure, galvanic skin resistance, EKG and so on. Numerical data can be stored in the lists and matrices available on Casio calculators. This data can be used to create sprites for non-text programs. In this way, the language can also be used to create games, such as Pong, Monopoly and role-playing games.
Catala (pl, appeared 2019)
Creators: Denis Merigoux
Origin: https://github.com/CatalaLang
Country: Various
Website: https://catala-lang.org/



GitHub description: Programming language for literate programming law specification

scope QualifiedEmployeeDiscount :
 definition qualified_employee_discount
   under condition is_property consequence
 equals
   if employee_discount >$
     customer_price ×$ gross_profit_percentage
   then customer_price ×$ gross_profit_percentage
   else employee_discount
Cayenne (pl, appeared 1998)
Origin: Chalmers University of Technology
Country: Sweden


Cayenne is a dependently typed functional programming language created by Lennart Augustsson in 1998, making it one of the earliest dependently type programming language (as opposed to proof assistant or logical framework). A notable design decision is that the language allows unbounded recursive functions to be used on the type level, making type checking undecidable. Most dependently typed proof assistants and later dependently typed languages such as Agda included a termination checker to prevent the type checker from looping, while the contemporary Dependent ML restricted the expressivity of the type-level language to maintain decidability. There are very few building blocks in the language, but much syntactic sugar to make it more readable. The basic types are functions, products, and sums. Functions and products use dependent types to gain additional power. The syntax is largely borrowed from Haskell. There is no special module system, because with dependent types records (products) are powerful enough to define modules. The Cayenne implementation was written in Haskell, and it also translated to Haskell, but is currently no longer being maintained.
CBOR (binaryDataFormat, appeared 2013)
Origin: Technologie-Zentrum Informatik und Informationstechnik
The Internet Corporation for Assigned Names and Numbers
Country: Germany and United States
Website: https://cbor.io/


CBOR (Concise Binary Object Representation) is a binary data serialization format loosely based on JSON. Like JSON it allows the transmission of data objects that contain name–value pairs, but in a more concise manner. This increases processing and transfer speeds at the cost of human-readability. It is defined in IETF RFC 7049.Amongst other uses, it is the recommended data serialization layer for the CoAP Internet of Things protocol suite and the data format on which COSE messages are based. It is also used in the Client-to-Authenticator Protocol (CTAP) within the scope of the FIDO2 project.
Continuity of Care Record (xmlFormat, appeared 2007)
Origin: ASTM International
Massachusetts Medical Society
Healthcare Information
Management Systems Society
American Academy of Family Physicians
American Academy of Pediatrics
Country: United States


Continuity of Care Record (CCR) is a health record standard specification developed jointly by ASTM International, the Massachusetts Medical Society (MMS), the Healthcare Information and Management Systems Society (HIMSS), the American Academy of Family Physicians (AAFP), the American Academy of Pediatrics (AAP), and other health informatics vendors.
CCS (pl, appeared 1999)
Origin: Infoblox Inc
Country: United States

CCS is a proprietary scripting language for executing sequences of command-line interface (CLI) commands on NetMRI-supported network devices, to perform job automation tasks. If you know Cisco IOS, writing CCS scripts is relatively straightforward.



Script-Filter:
$Vendor eq "Cisco" and
$sysDescr like /IOS/ and
$Version like /^1[2-9]/ and
$Type in ['Router', 'Switch-Router']]
CBOR data definition language (idl, appeared 2017)
Stands for: CBOR data definition language
Origin: Fraunhofer-Institut für Sichere Informationstechnologie SIT
Technologie-Zentrum Informatik und Informationstechnik
Country: Germany

Concise Data Definition Language (CDDL): A Notational Convention to Express Concise Binary Object Representation (CBOR) and JSON Data Structures



pii = (
  age: int,
  name: tstr,
  employer: tstr,
)
CECIL (pl, appeared 1992)
Creators: Craig Chambers
Origin: University of Washington
Country: United States


Cecil is a pure object-oriented programming language that was developed by Craig Chambers at the University of Washington in 1992 to be part of the Vortex project there. Cecil has many similarities to other object-oriented languages, most notably Objective-C, Modula-3, and Self. The main goals of the project were extensibility, orthogonality, efficiency, and ease-of-use. The language supports multiple dispatch and multimethods, dynamic inheritance, and optional static type checking. Unlike most other OOP systems, Cecil allows subtyping and code inheritance to be used separately, allowing run-time or external extension of object classes or instances. Like Objective-C, all object services in Cecil are invoked by message passing, and the language supports run-time class identification. These features allow Cecil to support dynamic, exploratory programming styles. Parameterized types and methods (generics, polymorphism), garbage collection, and delegation are also supported. Cecil also supports a module mechanism for isolating independent libraries or packages. Cecil does not presently support threads or any other form of concurrency. A standard library for Cecil is also available and includes various collection, utility, system, I/O, and GUI classes. The Diesel language was the successor of Cecil.There was also an assembler type language known as Cesil (Computer Education in Schools Instructional Language) used in the late-1970s developed by ICL. It was quite similar to the later language MASM.
Cedar (pl, appeared 1983)
Origin: Xerox PARC

The Cedar language is a programming language derived from Mesa, which in turn is derived from Pascal. It is meant to be used for a wide variety of programming tasks, ranging from low level systems software to large applications. In addition to the sequential control constructs, static type checking and structured types of Pascal, and the modules, exception handling, and concurrency control constructs of Mesa, Cedar also has garbage collection, dynamic types, and a limited form of type parameterization.
CEEMAC (pl, appeared 1980)
Creators: Brooke Boering
Origin: Vagabondo Enterprises
Country: United States


CEEMAC is a programming language developed in the 1980s for the Apple II family of computers.  It was authored by Brooke Boering and published by Vagabondo Enterprises,CEEMAC was designed to be a visual composition language in which the programmer designed dynamic "scores" by programatically controlling color, shape, sound and movement. Additionally, a programmer could then "perform" their score through use of the Apple II keyboard or paddle input devices to introduce additional variation.CEEMAC syntax loosely resembled a combination of BASIC and Pascal and include control commands such as GOTO, GOSUB, DO, AGAIN, FOR, SKIP, EXIT and loop control structures such as IF/WHILE and TIL/UNLESS. Additionally, 30 predefined macros were included in CEEMAC to aid in score composition.The following is a small CEEMAC sample score: 		    SCORE: KT       			:FIRE ORGAN  KEY T       			SPEED [0,0]       			: - BUT 0       			0       			CLEAR [0,0]       			XY1 = $80;$80      			: MAIN LOOP       			F      			:FORGND SYMMETRY 0-3       			VC = RND3 ORA 3       			: SAVE FORGND ROTATION       			VD = ROTEZ       			:FORGND COLOR       			COLOR = NXTCOL CEEMAC was originally marketed through distribution of a free demonstration program entitled Fire Organ.  This program contained several scores create by Boering and other programmers to demonstrate some of the capabilities of the language.
Cell (pl, appeared 2017)
Origin: https://github.com/cell-lang
Country: Various
Website: http://cell-lang.net/

Cell is a very high-level embeddable language. Cell's data model combines a staple of functional programming, algebraic data types, with relations and other ideas from relational databases.


GitHub description: Cell compiler

type AddUser = add_user(
 id:            UserId,
 username:      String,
 signup_date:   Date,
 first_name:    String,
 last_name:     String,
 date_of_birth: Date?
);

OnlineForum.AddUser {
  id = self.id;
  // Inserting the new user id and setting all the mandatory attributes
  insert user(id),
         username(id, self.username),
         first_name(id, self.first_name),
         last_name(id, self.last_name),
         signup_date(id, self.signup_date);
  // Setting the date_of_birth attribute, if available
  insert date_of_birth(id, self.date_of_birth) if self.date_of_birth?;
}
reactive Thermostat {
  input:
    temperature: Float;

  output:
    on: Bool;

  state:
    // When the system is initialized, on is true if
    // and only if the current temperature exceeds 28°C
    on: Bool = temperature > 28.0;

  rules:
    // Switching on the air conditioner when
    // the temperature exceeds 28°C
    on = true when temperature > 28.0;

    // Switching it off when it falls below 24°C
    on = false when temperature < 24.0;
}
Cesil (pl, appeared 1974)
Origin: International Computers Limited
Country: United Kingdom


Cesil, or Computer Education in Schools Instruction Language, was a programming language designed to introduce pupils in British schools to Assembly language.  It is a low level language containing a total of fourteen instructions:  Load value - place the immediate value or the contents of the variable named in the accumulator. Store variable - place the contents of the accumulator in the variable. Jump label - transfer control to location labelled. Jineg label - transfer control to location labelled if the accumulator contains a negative value. Jizero label - transfer control to location labelled if the accumulator contains zero. Print literal - output the following string, delimited by single quotes. Line - output a carriage return In - allow user to input a numerical value from the console. Out - Output the contents of the accumulator as a decimal integer, signed if negative. Add value - add the variable or immediate integer value to the accumulator. Subtract value - subtract the variable or immediate integer from the accumulator. Multiply value - place the product of the accumulator and the variable or immediate integer in the accumulator. Divide value - place the contents of the accumulator divided by the value in the accumulator. Halt - return control to console.
Ceylon (pl, appeared 2011)
Creators: Gavin King
Origin: Red Hat
Website: http://ceylon-lang.org


Ceylon is an object-oriented, strongly statically typed programming language with an emphasis on immutability, created by Red Hat. Ceylon programs run on the Java virtual machine (JVM), and can be compiled to JavaScript. The language design focuses on source code readability, predictability, toolability, modularity, and metaprogrammability. Important features of Ceylon include: A type system enforcing null safety and list element existence at compile time Regular syntax and semantics, avoiding special cases and primitively-defined constructs in favor of syntactic sugar Support for generic programming and metaprogramming, with reified generics Modularity built into the language, based on JBoss modules, interoperable with OSGi and Maven powerful tools, including an Eclipse-based IDE The name "Ceylon" is an oblique reference to Java, in that Java and Sri Lanka, formerly known as Ceylon, are islands known for growth and export of coffee and tea. In August 2017, Ceylon was donated to the Eclipse Foundation.

GitHub description: The Ceylon compiler, language module, and command line tools
CFEngine (application, appeared 1993)
Origin: Oslo University
Country: Norway
Website: https://cfengine.com


CFEngine is an open source configuration management system, written by Mark Burgess. Its primary function is to provide automated configuration and maintenance of large-scale computer systems, including the unified management of servers, desktops, consumer and industrial devices, embedded networked devices, mobile smartphones, and tablet computers.


#!/var/cfengine/bin/cf-agent --no-lock
body common control
{
  bundlesequence => { "hello_world" };
}

bundle agent hello_world
{
  reports:

    any::

      "Hello World!";

}
CFML (pl, appeared 1995)
Stands for: ColdFusion Markup Language
Creators: Jeremy Allaire
Origin: Adobe Systems
Lucee Association
New Atlanta
openBD
The Railo Company
Country: United States and Switzerland
United States
Website: http://www.adobe.com/products/coldfusion


ColdFusion Markup Language, more commonly known as CFML, is a scripting language for web development that runs on the JVM, the .NET framework, and Google App Engine. Multiple commercial and open source implementations of CFML engines are available, including Adobe ColdFusion, Lucee, New Atlanta BlueDragon (who makes both a Java-based and a .NET-based version), Railo, and Open BlueDragon as well as other CFML server engines.
Cg (pl, appeared 2003)
Stands for: C for Graphics
Origin: Nvidia
Country: United States


Cg (short for C for Graphics) is a high-level shading language developed by Nvidia in close collaboration with Microsoft for programming vertex and pixel shaders. Cg is based on the C programming language and although they share the same syntax, some features of C were modified and new data types were added to make Cg more suitable for programming graphics processing units. This language is only suitable for GPU programming and is not a general programming language. The Cg compiler outputs DirectX or OpenGL shader programs. Since 2012, Cg was deprecated, with no additional development or support available.
CGOL (pl, appeared 1973)
Creators: Vaughan Ronald Pratt
Origin: University of California, Berkeley
Country: United States


CGOL (pronounced "see goll") is an alternative syntax featuring an extensible algebraic notation for the Lisp programming language. It was designed for MACLISP by Vaughan Pratt and subsequently ported to Common Lisp.The notation of CGOL is a traditional infix notation, in the style of ALGOL, rather than Lisp's traditional, uniformly-parenthesized prefix notation syntax. The CGOL parser is based on Pratt's design for top-down operator precedence parsing, sometimes informally referred to as a "Pratt parser". Semantically, CGOL is essentially just Common Lisp, with some additional reader and printer support.


for i in 1 to n do
  for k in 1 to n do
    (ac := 0;
     for j in 1 to n do
        ac := ac + a(i,j)*b(j,k);
     c(i,k) := ac)