pldb/PLDB huggingface dataset:
Ch computer programming (pl, appeared 2001)
Origin: SoftIntegration, Inc
Country: United States
Website: http://www.softintegration.com


Ch  is a proprietary cross-platform C and C++ interpreter and scripting language environment, originally designed by Harry H. Cheng as a scripting language for beginners to learn mathematics, computing, numerical analysis (numeric methods), and programming in C/C++. Ch is now developed and marketed by SoftIntegration, Inc. A student edition is freely available. Ch Professional Edition for Raspberry Pi is free for non-commercial use. Ch can be embedded in C/C++ application programs. It has numerical computing and graphical plotting features. Ch is a combined shell and IDE. Ch shell combines the features of common shell and C language. ChIDE provides quick code navigation and symbolic debugging.  It is based on embedded Ch, Scite and Scintilla.Ch is written in C and runs on Windows, Linux, macOS, FreeBSD, AIX, Solaris, QNX, and HP-UX. It supports C90 and major C99 features, but it does not support the full set of C++ features. C99 complex number, IEEE-754 floating-point arithmetic, and variable-length array features were supported in Ch before they became part of the C99 standard. An article published by Computer Reseller News (CRN) named Ch as notable among C-based virtual machines for its functionality and the availability of third-party libraries.Ch has many toolkits that extend its functions. For example, Ch Mechanism Toolkit is used for design and analysis of commonly used mechanisms such as fourbar linkage, five-bar linkage, six-bar linkage, crank-slider mechanism, and cam-follower system. Ch Control System Toolkit is used for modeling, design, and analysis of continuous-time or discrete-time linear time invariant (LTI) control systems. Both toolkits includes the source code. Ch is now used and integrated into curriculum by many high schools and universities to teach computing and programming in C/C++. Ch has been integrated into free C-STEM Studio, a platform for learning  computing, science, technology, engineering, and mathematics (C-STEM) with robotics. C-STEM Studio is developed by UC Davis Center for Integrated Computing and STEM Education (C-STEM). It offers the curriculum for K-12 students. Ch supports LEGO Mindstorms NXT and EV3, Arduino, Linkbot, Finch Robot, RoboTalk and Rasperry PI, Pi Zero, and ARM for robot programming and learning.It can also be embedded into the LabVIEW system-design platform and development environment.
chain-format (textDataFormat, appeared 2013)
Origin: University of California, Santa Cruz
Country: United States

The chain format describes a pairwise alignment that allow gaps in both sequences simultaneously. Each set of chain alignments starts with a header line, contains one or more alignment data lines, and terminates with a blank line. The format is deliberately quite dense.



chain 4900 chrY 58368225 + 25985403 25985638 chr5 151006098 - 43257292 43257528 1
9       1       0
10      0       5
61      4       0
16      0       4
42      3       0
16      0       8
14      1       0
3       7       0
48
chain 4900 chrY 58368225 + 25985406 25985566 chr5 151006098 - 43549808 43549970 2
16      0       2
60      4       0
10      0       4
70
Conway chained arrow notation (notation, appeared 1996)
Creators: John Conway
Origin: University of Cambridge
Country: United Kingdom


Conway chained arrow notation, created by mathematician John Horton Conway, is a means of expressing certain extremely large numbers. It is simply a finite sequence of positive integers separated by rightward arrows, e.g.                         2         →         3         →         4         →         5         →         6                 {\displaystyle 2\to 3\to 4\to 5\to 6}   . As with most combinatorial notations, the definition is recursive. In this case the notation eventually resolves to being the leftmost number raised to some (usually enormous) integer power.


3->3->2 = 7,625,597,484,987
chaiscript (pl, appeared 2009)
Origin: https://github.com/ChaiScript
Country: United States and New Zealand
Website: http://chaiscript.com/



GitHub description: Embedded Scripting Language Designed for C++

#include <chaiscript/chaiscript.hpp>
std::string helloWorld(const std::string &t_name) {
  return "Hello " + t_name + "!";
}
int main() {
  chaiscript::ChaiScript chai;
  chai.add(chaiscript::fun(&helloWorld), "helloWorld");
  chai.eval(R"(
    puts(helloWorld("Bob"));
  )");
}
Chapel (pl, appeared 2004)
Creators: David Callahan
Hans Zima
Brad Chamberlain
John Plevyak
Origin: Cray
Country: United States
Website: https://chapel-lang.org/
File extensions: chpl
Keywords: _
align
atomic
begin
break
by
class
cobegin
coforall
config
const
continue
delete
dmapped
do
domain
else
enum
export
extern
for
forall
if
in
index
inline
inout
iter
label
let
local
module
new
nil
on
otherwise
out
param
proc
record
reduce
ref
return
scan
select
serial
single
sparse
subdomain
sync
then
type
union
use
var
when
where
while
yield
zip


Chapel, the Cascade High Productivity Language, is a parallel programming language developed by Cray. It is being developed as part of the Cray Cascade project, a participant in DARPA's High Productivity Computing Systems (HPCS) program, which had the goal of increasing supercomputer productivity by the year 2010. It is being developed as an open source project, under version 2 of the Apache license.

GitHub description: a Productive Parallel Programming Language
Charity (pl, appeared 1992)
Origin: University of Calgary
Country: Canada
Website: http://pll.cpsc.ucalgary.ca/charity1/www/home.html


Charity is an experimental purely functional programming language, developed at the University of Calgary under the supervision of Robin Cockett. Based on ideas by Hagino Tatsuya, it is completely grounded in category theory. Disregarding interactions with the outside world, all Charity programs are guaranteed to terminate or stay productive. The language allows ordinary recursive data types, such as might be found in ML, which are required to be finite, and corecursive data types, which are allowed to be potentially infinite. The control structure for operating on recursive data types is primitive recursion or paramorphism, and the control structure for corecursive data types is primitive co-recursion or apomorphism. Neither control structure can operate over the other kind of data, so all paramorphisms terminate and all apomorphisms are productive.


%
%   Some very badly written Charity
%

data LA(A) -> D = ss: A -> D
                | ff: -> D.
checked-c (pl, appeared 2015)
Creators: David Tarditi
Origin: Microsoft Research
Country: United States
Website: https://www.microsoft.com/en-us/research/project/checked-c/



GitHub description: Checked C is an extension to C that lets programmers write C code that is guaranteed by the compiler to be type-safe.  The goal is to let people easily make their existing C code type-safe and eliminate entire classes of errors. Checked C does not address use-after-free errors. This repo has a wiki for Checked C, sample code, the specification, and test code.
checkout (assembly, appeared 2011)
Origin: esolangs.org
Country: Unknown

It is designed to be lower-level than assembler or even machine code, by matching the way modern processors work more closely than machine language does (machine code matches the way processors used to work decades ago, rather than the way they work nowadays). Thus, it makes operations like memory transfers (which take up the most time on a modern processor) explicit; this leads to the language's name, as memory needs to be "checked out" via copy or move instructions in order to be able to use it. The secondary effect of this is that efficient code tends to be shorter and simpler than inefficient code, although it can sometimes be harder to see how it works.
CheetahTemplate (template, appeared 2001)
Origin: cheetahtemplate.org
Country: Various


Cheetah (or CheetahTemplate) is a template engine that uses the Python programming language.  It can be used standalone or combined with other tools and frameworks.  It is often used for server-side scripting and dynamic web content by generating HTML, but can also be used to generate source code.  Cheetah is free/open-source software licensed under the MIT License. Templating engines encourage clean separation of content, graphic design, and program code. This leads to more modular, flexible, and reusable site architectures, shorter development time, and code that is easier to understand and maintain.  Cheetah compiles templates into optimized, yet readable, Python code.  It gives template authors full access to any Python data and functionality, while providing a way for administrators to selectively restrict access to Python when needed. Cheetah is included in the FreeBSD Ports collection and several Linux distributions: Gentoo, Fedora, Debian, and Ubuntu among others.
chef (esolang, appeared 2002)
Origin: www.dangermouse.net
Country: Australia
Website: http://www.dangermouse.net/esoteric/chef.html

Chef is a programming language in which programs look like recipes.



Hello World Souffle.

This recipe prints the immortal words "Hello world!", in a basically brute force way. It also makes a lot of food for one person.

Ingredients.
72 g haricot beans
101 eggs
108 g lard
111 cups oil
32 zucchinis
119 ml water
114 g red salmon
100 g dijon mustard
33 potatoes

Method.
Put potatoes into the mixing bowl. Put dijon mustard into the mixing bowl. Put lard into the mixing bowl. Put red salmon into the mixing bowl. Put oil into the mixing bowl. Put water into the mixing bowl. Put zucchinis into the mixing bowl. Put oil into the mixing bowl. Put lard into the mixing bowl. Put lard into the mixing bowl. Put eggs into the mixing bowl. Put haricot beans into the mixing bowl. Liquefy contents of the mixing bowl. Pour contents of the mixing bowl into the baking dish.

Serves 1.
chevrotain (library, appeared 2015)
Origin: SAP
Country: Germany
Website: http://sap.github.io/chevrotain/



GitHub description: Parser Building Toolkit for JavaScript

"use strict"
/**
 * An Example of implementing a CSV Grammar with Chevrotain.
 *
 * Based on: https://github.com/antlr/grammars-v4/blob/master/csv/CSV.g4
 *
 * Note that this is a pure grammar without any actions (either embedded or via a CST Visitor).
 */
const { createToken, Lexer, Parser, EMPTY_ALT } = require("chevrotain")

// ----------------- lexer -----------------
const Text = createToken({ name: "Text", pattern: /[^,\n\r"]+/ })
const Comma = createToken({ name: "Comma", pattern: /,/ })
const NewLine = createToken({
    name: "NewLine",
    pattern: /\r?\n/
})
const String = createToken({ name: "String", pattern: /"(?:""|[^"])*"/ })

const allTokens = [Text, String, Comma, NewLine]
const CsvLexer = new Lexer(allTokens)

// Parser
class CsvParser extends Parser {
    constructor() {
        super(allTokens)

        // not mandatory, using $ (or any other sign) to reduce verbosity
        const $ = this

        $.RULE("csvFile", () => {
            $.SUBRULE($.hdr)
            $.AT_LEAST_ONE(() => {
                $.SUBRULE2($.row)
            })
        })

        $.RULE("hdr", () => {
            $.SUBRULE($.row)
        })

        $.RULE("row", () => {
            $.SUBRULE($.field)
            $.MANY(() => {
                $.CONSUME(Comma)
                $.SUBRULE2($.field)
            })
            $.CONSUME(NewLine)
        })

        $.RULE("field", () => {
            $.OR([
                { ALT: () => $.CONSUME(Text) },
                { ALT: () => $.CONSUME(String) },
                { ALT: EMPTY_ALT("empty field") }
            ])
        })

        // very important to call this after all the rules have been defined.
        // otherwise the parser may not work correctly as it will lack information
        // derived during the self analysis phase.
        this.performSelfAnalysis()
    }
}

// wrapping it all together
// reuse the same parser instance.
const parser = new CsvParser([])

module.exports = function(text) {
    // 1. Tokenize the input.
    const lexResult = CsvLexer.tokenize(text)

    // 2. Set the Parser's input
    parser.input = lexResult.tokens

    // 3. invoke the desired parser rule
    const cst = parser.csvFile()

    return {
        cst: cst,
        lexResult: lexResult,
        parseErrors: parser.errors
    }
}
CHICKEN (pl, appeared 1994)
Creators: Felix Winkelmann
Origin: The Chicken Team
Country: Various


Chicken (stylized as CHICKEN) is a programming language, specifically a compiler and interpreter which implement a dialect of the programming language Scheme, and which compiles Scheme source code to standard C. It is mostly R5RS compliant and offers many extensions to the standard. The newer R7RS standard is supported through an extension library. Chicken is free and open-source software available under a BSD license. It is implemented mostly in Scheme, with some parts in C for performance or to make embedding into C programs easier.
CHILL (pl, appeared 1980)
Origin: ITU Telecommunication Standardization Sector
Country: Switzerland


In computing, CHILL (an acronym for CCITT High Level Language) is a procedural programming language designed for use in telecommunication switches (the hardware used inside telephone exchanges). The language is still used for legacy systems in some telecommunication companies and for signal box programming. The CHILL language is similar in size and complexity to the original Ada language. The first specification of the CHILL language was published in 1980, a few years before Ada. ITU provides a standard CHILL compiler. A free CHILL compiler was bundled with GCC up to version 2.95, however, was removed from later versions. An object-oriented version, called Object CHILL, was developed also. ITU is responsible for the CHILL standard, known as ITU-T Rec. Z.200. The equivalent ISO standard is ISO/IEC 9496:2003. (The text of the two documents is the same). In late 1999 CCITT stopped maintaining the CHILL standard. CHILL was used in systems of Alcatel System 12 and Siemens EWSD, for example.
CHIP-8 (pl, appeared 1970)
Origin: RCA Corporation
Country: United States


CHIP-8 is an interpreted programming language, developed by Joseph Weisbecker. It was initially used on the COSMAC VIP and Telmac 1800 8-bit microcomputers in the mid-1970s. CHIP-8 programs are run on a CHIP-8 virtual machine. It was made to allow video games to be more easily programmed for these computers. Roughly twenty years after CHIP-8 was introduced, derived interpreters appeared for some models of graphing calculators (from the late 1980s onward, these handheld devices in many ways have more computing power than most mid-1970s microcomputers for hobbyists). An active community of users and developers existed in the late 1970s, beginning with ARESCO's "VIPer" newsletter whose first three issues revealed the machine code behind the CHIP-8 interpreter.
CHIP (pl, appeared 1985)
Origin: European Computer-Industry Research Centre
Country: Germany


CHIP (Constraint Handling in Prolog) is a constraint logic programming language developed by M. Dincbas and alias in 1985 at ECRC, initially using a Prolog language interface. CHIP V5 is the version developed and marketed by COSYTEC in Paris since 1993 with Prolog, using C, C++, or Prolog language interfaces. The commercially successful ILOG Solver is also, partly, an offshoot of ECRC version of CHIP.
Chipmunk Basic (pl, appeared 1989)
Country: United States
Website: http://www.nicholson.com/rhn/basic/


Chipmunk Basic is a freeware version of the BASIC programming language maintained by developer Ron Nicholson. Chipmunk basic was originally developed for the Apple Macintosh and has been ported to Linux and Windows. The "windowed" Macintosh version includes a wide variety of graphics drawing commands. It also has object-oriented capabilities. The current version of Chipmunk Basic (and its spinoff products for Palm OS, cBasPad and HotPaw BASIC) was based on a public domain, Pascal implementation by David Gillespie, author of the Pascal translation tool p2c. In January 2015, a Cocoa version was released that may lack features from the older Carbon-based OS X port.
Chomski (pl, appeared 2007)


chomski virtual machine  (named after the noted linguist Noam Chomsky) and pp (the pattern parser) refer to both a command line computer language and utility (interpreter for that language) which can be used to parse and transform text patterns. The utility reads input files character by character (sequentially), applying the operation which has been specified via the command line or a pp script, and then outputs the line. It was developed from 2006 as a Unix and Windows utility, and is available today for Windows and Linux systems. Pp has derived a number of ideas and syntax elements from Sed, a command line text stream editor.
Chrome (pl, appeared 2008)
Origin: RemObjects Software
Country: United States


Oxygene (formerly known as Chrome) is a programming language developed by RemObjects Software for Microsoft's Common Language Infrastructure, the Java Platform and Cocoa. Oxygene is Object Pascal-based, but also has influences from  C#, Eiffel, Java, F# and other languages. Compared to the now deprecated Delphi.NET, Oxygene does not emphasize total backward compatibility, but is designed to be a "reinvention" of the language, be a good citizen on the managed development platforms, and leverage all the features and technologies provided by the .NET and Java runtimes. Oxygene is a commercial product, and offers full integration into Microsoft's Visual Studio IDE on Windows, as well as its own IDE, Fire for use on macOS. The command line compiler is available free. Oxygene is one of four languages supported by the underlying Elements Compiler toolchain, next to C#, Swift and Java). From 2008 to 2012, RemObjects Software has licensed its compiler and IDE technology to Embarcadero to be used in their Embarcadero Prism product. Starting in the Fall of 2011, Oxygene became available in two separate editions, with the second edition adding support for the Java and Android runtimes.  Starting with the release of XE4, Embarcadero Prism is no longer part of the RAD Studio SKU. Numerous support and upgrade paths for Prism customers exist to migrate to Oxygene. As of 2016, there is only one edition of Oxygene, which allows development on Windows or macOS, and which can create executables for Windows .NET, iOS, Android, Java and macOS.
chrysaLisp (pl, appeared 2015)
Creators: Chris Hinsley
Origin: Tao Group
Country: United Kingdom



GitHub description: Parallel OS, with GUI, Terminal, OO Assembler, Class libraries, C-Script compiler, Lisp interpreter and more...

;imports
(import 'sys/lisp.inc)
(import 'class/lisp.inc)
(import 'gui/lisp.inc)

(structure 'event 0
  (byte 'win_close 'win_min 'win_max 'win_button))

(ui-tree window (create-window (+ window_flag_close window_flag_min window_flag_max)) nil
  (ui-element _ (create-flow) ('flow_flags (logior flow_flag_down flow_flag_fillw flow_flag_lasth))
    (ui-element display (create-label) ('text "0" 'color argb_white 'flow_flags flow_flag_align_hright
      'font (create-font "fonts/OpenSans-Regular.ttf" 24)))
    (ui-element _ (create-grid) ('grid_width 4 'grid_height 4 'color toolbar_col
        'font (create-font "fonts/OpenSans-Regular.ttf" 42))
      (each (lambda (text)
        (component-connect
          (ui-element _ (create-button) ('text (if (eql text "C") "AC" text)))
          event_win_button)) "789/456*123-0=C+"))))

(gui-add (apply view-change (cat (list window 920 48)
  (view-pref-size (window-set-title (window-connect-close (window-connect-min
    (window-connect-max window event_win_max) event_win_min) event_win_close) "Calculator")))))

(defun do_lastop ()
  (cond
    ((eql lastop "+")
      (setq accum (+ accum num)))
    ((eql lastop "-")
      (setq accum (- accum num)))
    ((eql lastop "*")
      (setq accum (* accum num)))
    ((eql lastop "/")
      (if (/= num 0) (setq accum (/ accum num)))))
  accum)

(defq id t accum 0 value 0 num 0 lastop nil)
(while id
  (cond
    ((>= (setq id (get-long (defq msg (mail-read (task-mailbox))) ev_msg_target_id)) event_win_button)
      (defq op (get (view-find-id window (get-long msg ev_msg_action_source_id)) 'text))
      (cond
        ((eql op "AC")
          (setq accum 0 value 0 num 0 lastop nil))
        ((find op "=+-/*")
          (if lastop
            (setq value (do_lastop))
            (setq value num accum num))
          (setq lastop op num 0))
        (t
          (cond
            ((= num 0)
              (unless (eql op "0"))
                (setq num (to-num op)))
            (t (setq num (to-num (cat (str num) op)))))
          (setq value num)))
      (set display 'text (str value))
      (view-dirty (view-layout display)))
    ((= id event_win_close)
      ;close button
      (setq id nil))
    ((= id event_win_min)
      ;min button
      (bind '(x y _ _) (view-get-bounds window))
      (bind '(w h) (view-pref-size window))
      (view-change-dirty window x y w h))
    ((= id event_win_max)
      ;max button
      (bind '(x y _ _) (view-get-bounds window))
      (view-change-dirty window x y 512 512))
    (t (view-event window msg))))

(view-hide window)
Ch (pl, appeared 2003)
Creators: Ge Wang
Origin: chuck team
Country: United States
Website: http://chuck.cs.princeton.edu


ChucK is a concurrent, strongly timed audio programming language for real-time synthesis, composition, and performance, which runs on Linux, Mac OS X, Microsoft Windows, and iOS. It is designed to favor readability and flexibility for the programmer over other considerations such as raw performance. It natively supports deterministic concurrency and multiple, simultaneous, dynamic control rates. Another key feature is the ability to live code; adding, removing, and modifying code on the fly, while the program is running, without stopping or restarting. It has a highly precise timing/concurrency model, allowing for arbitrarily fine granularity. It offers composers and researchers a powerful and flexible programming tool for building and experimenting with complex audio synthesis programs, and real-time interactive control. ChucK was created and chiefly designed by Ge Wang as a graduate student working with Perry R. Cook. ChucK is distributed freely under the terms of the GNU General Public License on Mac OS X, Linux and Microsoft Windows. On iPhone and iPad, ChiP (ChucK for iPhone) is distributed under a limited, closed source license, and is not currently licensed to the public. However, the core team has stated that it would like to explore "ways to open ChiP by creating a beneficial environment for everyone".
Ciao (pl, appeared 1984)
Origin: IMDEA Software Institute
Universidad Politécnica de Madrid
University of Texas
Microelectronics and Technology Corporation
Country: Spain and United States
Website: http://ciao-lang.org


Ciao is a general-purpose programming language which supports logic, constraint, functional, higher-order, and object-oriented programming styles. Its main design objectives are high expressive power, extensibility, safety, reliability, and efficient execution.
Ciel (pl, appeared 2010)
Creators: Ron Garret
Origin: https://flownet.com
Country: United States

Ciel is a lisp-like language implemented in C++.  What Clojure is to Java, Ciel is designed to be to C++.


GitHub description: A Lisp-like language implemented in C++

(set lambda fn)
(set def set)
(def vector (lambda x x))
(vector 1 2 3)