pldb/PLDB huggingface dataset:
Red (pl, appeared 2011)
Creators: Nenad Rakocevic
Origin: https://github.com/red
Country: China
Website: http://www.red-lang.org/
File extensions: red
reds


Red is a computer programming language. Red was made to overcome the limitations of the programming language Rebol. Introduced in 2011 by Nenad Rakocevic, Red is both an imperative and functional programming language. Its syntax and general usage overlaps that of the interpreted Rebol language (which was introduced in 1997). The implementation choices of Red intend to create a full stack programming language: Red can be used for extremely high-level programming (DSLs and GUIs) as well as low-level programming (operating systems and device drivers). Key to the approach is that the language has two parts: Red/System and Red. Red/System is similar to C, but packaged into a Rebol lexical structure –  for example, one would write if x > y [print "Hello"] instead of if (x > y) {printf("Hello\n");}. Red is a homoiconic language capable of meta-programming, with semantics similar to Rebol's. Red's runtime library is written in Red/System, and uses a hybrid approach: it compiles what it can deduce statically and uses an embedded interpreter otherwise. The project roadmap includes a just-in-time compiler for cases in between, but this has not yet been implemented. Red seeks to remain independent of any other toolchain; it does its own code generation. It is therefore possible to cross-compile Red programs from any platform it supports to any other, via a command-line switch. Both Red and Red/System are distributed as open-source software under the modified BSD license. The runtime library is distributed under the more permissive Boost Software License.

GitHub description: Red is a next-generation programming language strongly inspired by Rebol, but with a broader field of usage thanks to its native-code compiler, from system programming to high-level scripting and cross-platform reactive GUI, while providing modern support for concurrency, all in a zero-install, zero-config, single 1MB file!
Redis (application, appeared 2009)
Origin: Redis Ltd
Country: United States
Website: https://redis.io/
Keywords: APPEND
AUTH
BGREWRITEAOF
BGSAVE
BITCOUNT
BITFIELD
BITOP
BITPOS
BLPOP
BRPOP
BRPOPLPUSH
CLIENT
KILL
LIST
GETNAME
PAUSE
REPLY
SETNAME
CLUSTER
ADDSLOTS
COUNT-FAILURE-REPORTS
COUNTKEYSINSLOT
DELSLOTS
FAILOVER
FORGET
GETKEYSINSLOT
INFO
KEYSLOT
MEET
NODES
REPLICATE
RESET
SAVECONFIG
SET-CONFIG-EPOCH
SETSLOT
SLAVES
SLOTS
COMMAND
COUNT
GETKEYS
CONFIG
GET
REWRITE
SET
RESETSTAT
DBSIZE
DEBUG
OBJECT
SEGFAULT
DECR
DECRBY
DEL
DISCARD
DUMP
ECHO
EVAL
EVALSHA
EXEC
EXISTS
EXPIRE
EXPIREAT
FLUSHALL
FLUSHDB
GEOADD
GEOHASH
GEOPOS
GEODIST
GEORADIUS
GEORADIUSBYMEMBER
GETBIT
GETRANGE
GETSET
HDEL
HEXISTS
HGET
HGETALL
HINCRBY
HINCRBYFLOAT
HKEYS
HLEN
HMGET
HMSET
HSET
HSETNX
HSTRLEN
HVALS
INCR
INCRBY
INCRBYFLOAT
KEYS
LASTSAVE
LINDEX
LINSERT
LLEN
LPOP
LPUSH
LPUSHX
LRANGE
LREM
LSET
LTRIM
MGET
MIGRATE
MONITOR
MOVE
MSET
MSETNX
MULTI
PERSIST
PEXPIRE
PEXPIREAT
PFADD
PFCOUNT
PFMERGE
PING
PSETEX
PSUBSCRIBE
PUBSUB
PTTL
PUBLISH
PUNSUBSCRIBE
QUIT
RANDOMKEY
READONLY
READWRITE
RENAME
RENAMENX
RESTORE
ROLE
RPOP
RPOPLPUSH
RPUSH
RPUSHX
SADD
SAVE
SCARD
SCRIPT
FLUSH
LOAD
SDIFF
SDIFFSTORE
SELECT
SETBIT
SETEX
SETNX
SETRANGE
SHUTDOWN
SINTER
SINTERSTORE
SISMEMBER
SLAVEOF
SLOWLOG
SMEMBERS
SMOVE
SORT
SPOP
SRANDMEMBER
SREM
STRLEN
SUBSCRIBE
SUNION
SUNIONSTORE
SWAPDB
SYNC
TIME
TOUCH
TTL
TYPE
UNSUBSCRIBE
UNLINK
UNWATCH
WAIT
WATCH
ZADD
ZCARD
ZCOUNT
ZINCRBY
ZINTERSTORE
ZLEXCOUNT
ZRANGE
ZRANGEBYLEX
ZREVRANGEBYLEX
ZRANGEBYSCORE
ZRANK
ZREM
ZREMRANGEBYLEX
ZREMRANGEBYRANK
ZREMRANGEBYSCORE
ZREVRANGE
ZREVRANGEBYSCORE
ZREVRANK
ZSCORE
ZUNIONSTORE
SCAN
SSCAN
HSCAN
ZSCAN


Redis is an open-source in-memory database project implementing a distributed, in-memory key-value store with optional durability. Redis supports different kinds of abstract data structures, such as strings, lists, maps, sets, sorted sets, hyperloglogs, bitmaps and spatial indexes. The project is mainly developed by Salvatore Sanfilippo and is currently sponsored by Redis Labs. Redis Labs creates and maintains the official Redis Enterprise Pack.

GitHub description: Redis is an in-memory database that persists on disk. The data model is key-value, but many different kind of values are supported: Strings, Lists, Sets, Sorted Sets, Hashes, Streams, HyperLogLogs, Bitmaps.
Amazon Redshift (queryLanguage, appeared 2012)
Origin: Amazon
Keywords: AES128
AES256
ALL
ALLOWOVERWRITE
ANALYSE
ANALYZE
AND
ANY
ARRAY
AS
ASC
AUTHORIZATION
AZ64
BACKUP
BETWEEN
BINARY
BLANKSASNULL
BOTH
BYTEDICT
BZIP2
CASE
CAST
CHECK
COLLATE
COLUMN
CONSTRAINT
CREATE
CREDENTIALS
CROSS
CURRENT_DATE
CURRENT_TIME
CURRENT_TIMESTAMP
CURRENT_USER
CURRENT_USER_ID
DEFAULT
DEFERRABLE
DEFLATE
DEFRAG
DELTA
DELTA32K
DESC
DISABLE
DISTINCT
DO
ELSE
EMPTYASNULL
ENABLE
ENCODE
ENCRYPT
ENCRYPTION
END
EXCEPT
EXPLICIT
FALSE
FOR
FOREIGN
FREEZE
FROM
FULL
GLOBALDICT256
GLOBALDICT64K
GRANT
GROUP
GZIP
HAVING
IDENTITY
IGNORE
ILIKE
IN
INITIALLY
INNER
INTERSECT
INTO
IS
ISNULL
JOIN
LANGUAGE
LEADING
LEFT
LIKE
LIMIT
LOCALTIME
LOCALTIMESTAMP
LUN
LUNS
LZO
LZOP
MINUS
MOSTLY16
MOSTLY32
MOSTLY8
NATURAL
NEW
NOT
NOTNULL
NULL
NULLS
OFF
OFFLINE
OFFSET
OID
OLD
ON
ONLY
OPEN
OR
ORDER
OUTER
OVERLAPS
PARALLEL
PARTITION
PERCENT
PERMISSIONS
PLACING
PRIMARY
RAW
READRATIO
RECOVER
REFERENCES
RESPECT
REJECTLOG
RESORT
RESTORE
RIGHT
SELECT
SESSION_USER
SIMILAR
SNAPSHOT
SOME
SYSDATE
SYSTEM
TABLE
TAG
TDES
TEXT255
TEXT32K
THEN
TIMESTAMP
TO
TOP
TRAILING
TRUE
TRUNCATECOLUMNS
UNION
UNIQUE
USER
USING
VERBOSE
WALLET
WHEN
WHERE
WITH
WITHOUT
REDUCE (pl, appeared 2011)
Origin: https://sourceforge.net/p/reduce-algebra/_members
Country: United States
Website: http://www.reduce-algebra.com


Reduce is a general-purpose computer algebra system geared towards applications in physics. The development of the Reduce computer algebra system was started in the 1960s by Anthony C. Hearn. Since then, many scientists from all over the world have contributed to its development under his direction. Reduce is written entirely in its own LISP dialect called Portable Standard Lisp, expressed in an ALGOL-like syntax called RLISP. The latter is used as a basis for Reduce's user-level language. Implementations of Reduce are available on most variants of Unix, Linux, Microsoft Windows, or Apple Macintosh systems by using an underlying Portable Standard Lisp or Codemist Standard LISP implementation. Reduce was open sourced in December 2008 and is available for free under a modified BSD license on SourceForge. Previously it had cost $695.
Refal (pl, appeared 1968)
Creators: Valentin Turchin
Origin: http://pespmc1.vub.ac.be/TURCHIN.html
Country: United States
Website: http://www.refal.net


Refal (Recursive functions algorithmic language) "is functional programming language oriented toward symbol manipulation", including "string processing, translation, [and] artificial intelligence". It is one of the oldest members of this family, first conceived in 1966 as a theoretical tool with the first implementation appearing in 1968. Refal was intended to combine mathematical simplicity with practicality for writing large and sophisticated programs. Unlike other functional programming languages, Refal is based on pattern matching. Its pattern matching works in the forward direction rather than backwards (starting from the goal) as in Prolog. The basic data structure of Lisp and Prolog is a linear list consed up from the beginning. Refal lists are built and scanned from both ends, and pattern matching allows to match against nested lists as well as the top-level one. (In effect, the basic data structure of Refal is a tree rather than a list). According to the authors, this gives freedom and convenience in creating data structures while using only mathematically simple control mechanisms of pattern matching and substitution. Refal also includes a feature called the freezer to support efficient partial evaluation. Refal can be applied to the processing and transformation of tree structures, similarly to XSLT.
Refer (textMarkup, appeared 1978)
Origin: Bell Laboratories
Country: United States


refer is a program for managing bibliographic references, and citing them in troff documents.  It is implemented as a troff preprocessor. refer was written by Mike Lesk at Bell Laboratories in or before 1978, and is now available as part of most Unix-like operating systems.  A free reimplementation exists as part of the groff package. As of 2015, refer sees little use, primarily because troff itself is not used much for longer technical writing that might need software support for reference and citation management.  As of 2016, some reference management software (for instance, RefWorks) will import refer data.


%A Brian W. Kernighan
%A Lorinda L. Cherry
%T A System for Typesetting Mathematics
%J J. Comm. ACM
%V 18
%N 3
%D March 1978
%P 151-157
%K eqn
.[
kernighan cherry eqn
.]
reflex-framework (framework, appeared 2015)
Origin: https://github.com/reflex-frp
Country: United States
Website: https://reflex-frp.org/



GitHub description: Interactive programs without callbacks or side-effects. Functional Reactive Programming (FRP) uses composable events and time-varying values to describe interactive systems as pure functions. Just like other pure functional code, functional reactive code is easier to get right on the first try, maintain, and reuse.
reforth (pl, appeared 2013)
Origin: https://github.com/seanpringle/reforth/issues
Country: Unknown

Reforth tries to solve my gripes without fundamentally changing Forth's elegance and simplicity.


GitHub description: Rethinking Forth

begin
    condition
    if    operation
        next
    end
    condition1
    if    operation1
        leave
    end
end
10 for
    condition
    if    operation
        leave
    end
end
Regular Expressions (queryLanguage, appeared 1951)
Origin: University of Wisconsin-Madison
Country: United States


A regular expression, regex or regexp (sometimes called a rational expression) is, in theoretical computer science and formal language theory, a sequence of characters that define a search pattern. Usually this pattern is then used by string searching algorithms for "find" or "find and replace" operations on strings. The concept arose in the 1950s when the American mathematician Stephen Cole Kleene formalized the description of a regular language. The concept came into common use with Unix text-processing utilities. Since the 1980s, different syntaxes for writing regular expressions exist, one being the POSIX standard and another, widely used, being the Perl syntax. Regular expressions are used in search engines, search and replace dialogs of word processors and text editors, in text processing utilities such as sed and AWK and in lexical analysis. Many programming languages provide regex capabilities, built-in, or via libraries.
Reia (pl, appeared 2008)
Origin: https://github.com/tarcieri/reia/issues
Country: United States
Website: http://reia-lang.org



GitHub description: Ruby-like hybrid OOP/functional programming language for BEAM, the Erlang VM

# Hello, world!
"Hello, world!".puts()

# Assignment
number = 42
opposite = true

# Conditions
number = -42 if opposite

# Lists (stored as immutable singly-linked lists)
list = [1, 2, 3, 4, 5]

# Tuples (think of them as immutable arrays)
tuple = (1, 2, 3, 4, 5)

# Atoms (known as symbols to Ruby people)
# Think of them as an open-ended enumeration
atom = :up_and_atom

# Dicts (also known as hashes to Ruby people)
dict = {:foo => 1, :bar => 2, :baz => 3}

# Strings (unlike Erlang, Reia has a real String type!)
string = "I'm a string! Woohoo I'm a string! #{'And I interpolate too!'}"

# Ranges
range = 0..42

# Funs (anonymous functions, a.k.a. lambdas, procs, closures, etc.)
# Calling me with plustwo(40) would return 42
plustwo = fun(n) { n + 2 }

# Modules (collections of functions)
# Calling Plusser.addtwo(40) would return 42
module Plusser
  def addtwo(n)
    n + 2
  end
end

# Classes (of immutable objects. Once created objects can't be changed!)
class Adder
  # Reia supports binding instance variables directly when they're passed
  # as arguments to initialize
  def initialize(@n); end

  def plus(n)
    @n + n
  end
end

# Instantiate classes by calling Classname(arg1, arg2, ...)
# For you Ruby people who want Classname.new(...) this is coming soon!
fortytwo = Adder(40).plus(2)

# Function references can be obtained by omitting parens from a function call,
# like JavaScript or Python
numbers = [1,2,3]
reverser = [1,2,3].reverse

# Function references can be invoked just like lambdas
reversed = reverser() # reversed is now [3,2,1]

# You can add a ! to the end of any method to rebind the method receiver to 
# the return value of the given method minus the bang.
numbers.reverse!() # numbers is now [3,2,1]

# List comprehensions
doubled = [n * 2 for n in numbers] # doubled is [6,4,2]
RPL (queryLanguage, appeared 1988)
Also known as: rpl
Origin: University Of Southwestern Louisiana
Country: United States

The Relational Production Language (RPL) solves the paradigm mismatch between expert systems and database systems by relying on the relational data model as the underlying formalism for an expert system. The result is a formally-defined production system language with immediate access to conventional databases. Working memory is modeled as a relational database and rules consist of a relational query on the left hand side (LHS) and database updates on the right hand side (RHS).
relax (grammarLanguage, appeared 2000)
Creators: Makoto Murata
Origin: https://www.gr.jp
Country: Japan
Website: http://www.xml.gr.jp/relax/

RELAX (REgular LAnguage description for XML) is a specification for describing XML-based languages. XHTML 1.0, for example, can be described in RELAX. A description written in RELAX is called a RELAX grammar. An XML document can be verified against a RELAX grammar. Compared with DTD(Document Type Definition), RELAX has new features: RELAX grammars are represented in the XML instance syntax. RELAX borrows rich datatypes of XML Schema Part 2. RELAX is namespace-aware



<module
      moduleVersion="1.2"
      relaxCoreVersion="1.0"
      targetNamespace=""
      xmlns="http://www.xml.gr.jp/xmlns/relaxCore">

  <interface>
    <export label="doc"/>
  </interface>

  <elementRule role="doc">
    <sequence>
      <ref label="title"/>
      <ref label="para" occurs="*"/>
    </sequence>
  </elementRule>
 
  <elementRule role="para">
    <mixed>
      <ref label="em" occurs="*"/>
    </mixed>
  </elementRule>
  
  <elementRule role="title">
    <mixed>
      <ref label="em" occurs="*"/>
    </mixed>
  </elementRule>

  <elementRule role="em" type="string"/>
  
  <tag name="doc"/>

  <tag name="para">
    <attribute name="class" type="NMTOKEN"/>
  </tag>
  
  <tag name="title">
    <attribute name="class" type="NMTOKEN"/>
    <attribute name="number" required="true" type="integer"/>
  </tag>

  <tag name="em"/>

</module>
RELAX NG (grammarLanguage, appeared 2001)
Origin: https://relaxng.org
Country: Japan
Website: https://relaxng.org/


In computing, RELAX NG (REgular LAnguage for XML Next Generation) is a schema language for XML - a RELAX NG schema specifies a pattern for the structure and content of an XML document. A RELAX NG schema is itself an XML document but RELAX NG also offers a popular compact, non-XML syntax. Compared to other XML schema languages  RELAX NG is considered relatively simple. It was defined by a committee specification of the OASIS RELAX NG technical committee in 2001 and 2002, based on Murata Makoto's RELAX and James Clark's TREX, and also by part two of the international standard ISO/IEC 19757: Document Schema Definition Languages (DSDL). ISO/IEC 19757-2 was developed by ISO/IEC JTC1/SC34 and published in its first version in 2003.


# A RELAX NG compact syntax pattern
# for an address book.
element addressBook {
  # an entry in the address book
  element card {
    element name { text },
    element email { text }  # an email address
  }*
}
Ren-C (pl, appeared 2012)
Origin: https://github.com/metaeducation
Country: Unknown

Ren-C is a deeply redesigned LGPL 3.0-licensed derivative of the Rebol 3 codebase. It explores solutions to some of the Rebol language's longstanding open questions, adding fundamental new evaluation abilities and API embeddings.


GitHub description: Library for embedding a Rebol interpreter into C codebases
Ren (dataNotation, appeared 2013)
Origin: Pointillistic Software
Country: United States
Website: http://www.ren-data.org/
File extensions: ren

Ren is a lightweight data-exchange text format. It is programming language independent with familiar conventions. Whitespace separates values, but is not significant beyond that. Ren has two main data structures: An ordered group of values, called a list; A collection of name/value pairs, called a map



[]			; empty list
#()			; empty map
[a 1 true #three]	; non-empty list
#(a: 1 b: "two")	; non-empty map
"Ren Example 1"	; string
-42			; number
98.6			; another number
true			; literal true
false		; literal false
none			; literal nil/null/nada
#(			; a bigger map
    quote:	 "禅 saying: ^"仁 rocks!^""
    utf-8:    "^(CE91) to ^(cf89)"
    sci-phi:  0.1618e1
    tax-rate: 3.9%
    price:    $79.99
    url:      http://www.ren-data.org/
    email:    info@ren-data.org
    hashtag:  #ren
    date:     2013-04-17/18:37:39-06:00
    warning:  00:02     ; = 00:00:120.0
    ip-addr:  127.0.0.1
    geo-pos:  43.6x116.7x817
    hex:      16#{DECAFBAD CAFE 00FF}
    base-64:  64#{UmVuIGlzIGRhdGE=}  
)
RenderMan Shading Language (pl, appeared 1989)
Origin: Pixar Animation Studios
Country: United States


Renderman Shading Language (abbreviated RSL) is a component of the RenderMan Interface Specification, and is used to define shaders. The language syntax is C-like. A shader written in RSL can be used without changes on any RenderMan-compliant renderer, such as Pixar's PhotoRealistic RenderMan, DNA Research's 3Delight, Sitexgraphics' Air or an open source solution such as Pixie or Aqsis. RenderMan Shading Language defines standalone functions and five types of shaders: surface, light, volume, imager and displacement shaders. An example of a surface shader that defines a metal surface is:  Shaders do the work by reading and writing special variables such as Cs (surface color), N (normal at given point), and Ci (final surface color). The arguments to the shaders are global parameters that are attached to objects of the model (so one metal shader can be used for different metals and so on). Shaders have no return values, but functions can be defined which take arguments and return a value. For example, the following function computes vector length using the dot product operator ".":
RenderScript (pl, appeared 2011)
Website: http://developer.android.com/guide/topics/renderscript/index.html

RenderScript is a component of the Android operating system for mobile devices that offers an API for acceleration that takes advantage of heterogeneous hardware. It allows developers to increase the performance of their applications at the cost of writing more complex (lower-level) code.

RenderScript is a component of the Android operating system for mobile devices that offers an API for acceleration that takes advantage of heterogeneous hardware. It allows developers to increase the performance of their applications at the cost of writing more complex (lower-level) code. It provides the developer three primary tools: A simple 3D rendering API, a compute API similar to CUDA, and a C99-derived language.


/*
 * Copyright (C) 2012 The Android Open Source Project
 *
 * Licensed under the Apache License, Version 2.0 (the "License");
 * you may not use this file except in compliance with the License.
 * You may obtain a copy of the License at
 *
 *      http://www.apache.org/licenses/LICENSE-2.0
 *
 * Unless required by applicable law or agreed to in writing, software
 * distributed under the License is distributed on an "AS IS" BASIS,
 * WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
 * See the License for the specific language governing permissions and
 * limitations under the License.
 */

#pragma version(1)
#pragma rs java_package_name(com.android.gallery3d.filtershow.filters)
#pragma rs_fp_relaxed

int32_t gWidth;
int32_t gHeight;
const uchar4 *gPixels;
rs_allocation gIn;

float gCoeffs[9];

void root(const uchar4 *in, uchar4 *out, const void *usrData, uint32_t x, uint32_t y) {
    uint32_t x1 = min((int32_t)x+1, gWidth-1);
    uint32_t x2 = max((int32_t)x-1, 0);
    uint32_t y1 = min((int32_t)y+1, gHeight-1);
    uint32_t y2 = max((int32_t)y-1, 0);

    float4 p00 = rsUnpackColor8888(gPixels[x1 + gWidth * y1]);
    float4 p01 = rsUnpackColor8888(gPixels[x + gWidth * y1]);
    float4 p02 = rsUnpackColor8888(gPixels[x2 + gWidth * y1]);
    float4 p10 = rsUnpackColor8888(gPixels[x1 + gWidth * y]);
    float4 p11 = rsUnpackColor8888(gPixels[x + gWidth * y]);
    float4 p12 = rsUnpackColor8888(gPixels[x2 + gWidth * y]);
    float4 p20 = rsUnpackColor8888(gPixels[x1 + gWidth * y2]);
    float4 p21 = rsUnpackColor8888(gPixels[x + gWidth * y2]);
    float4 p22 = rsUnpackColor8888(gPixels[x2 + gWidth * y2]);

    p00 *= gCoeffs[0];
    p01 *= gCoeffs[1];
    p02 *= gCoeffs[2];
    p10 *= gCoeffs[3];
    p11 *= gCoeffs[4];
    p12 *= gCoeffs[5];
    p20 *= gCoeffs[6];
    p21 *= gCoeffs[7];
    p22 *= gCoeffs[8];

    p00 += p01;
    p02 += p10;
    p11 += p12;
    p20 += p21;

    p22 += p00;
    p02 += p11;

    p20 += p22;
    p20 += p02;

    p20 = clamp(p20, 0.f, 1.f);
    *out = rsPackColorTo8888(p20.r, p20.g, p20.b);
}
Ren'Py (pl, appeared 2004)
Origin: https://github.com/renpy
Country: England


The Ren'Py Visual Novel Engine is a free software engine which facilitates the creation of visual novels, a form of computer-mediated storytelling. Ren'Py is a portmanteau of ren'ai (恋愛), the Japanese word for 'romantic love', a common element of games made using Ren'Py; and Python, the programming language that Ren'Py runs on. Ren'Py has proved attractive to English-language hobbyists; over 1000 games use the Ren'Py engine, nearly all in English.
Rescript (pl, appeared 2020)
Website: https://rescript-lang.org/

ReScript is a robustly typed language that compiles to efficient and human-readable JavaScript. It comes with a lightning fast compiler toolchain that scales to any codebase size.



module Button = {
  @react.component
  let make = (~count: int) => {
    let times = switch count {
    | 1 => "once"
    | 2 => "twice"
    | n => Belt.Int.toString(n) ++ " times"
    }
    let msg = "Click me " ++ times

    <button> {msg->React.string} </button>
  }
}