Category:REXX: Difference between revisions
m →External Links: added an URL to the English Wikipedia for REXX. |
m Extra comment |
||
(20 intermediate revisions by 2 users not shown) | |||
Line 1: | Line 1: | ||
{{language |
{{language |
||
| LCT=yes |
|||
|strength=strong |
|||
| exec=interpreted |
|||
|LCT=yes |
|||
| express=inferred |
|||
|gc=allowed |
|||
| gc=allowed (and in most versions of REXX, it is automatic, but garbage collection isn't mandated). |
|||
|safety=safe |
|||
| safety=safe |
|||
|express=implicit |
|||
| strength=strong |
|||
|compat=nominative |
|||
| standardized=yes |
|||
|checking=dynamic |
|||
| compat=nominative |
|||
|parampass=value}} |
|||
| checking=dynamic |
|||
| parampass=value |
|||
| untyped=yes |
|||
| intended=intended for general, application, algorithms, scripting, host/sub─system scripting/interfacing, data/text processing, programming as a human activity. |
|||
| goal=the REXX language is designed to make programming easier; to foster high quality programs by making writing them as simple and enjoyable as possible; designing each part of the language for people to use is more important than providing easy implementation; follows the principle of least astonishment [https://en.wikipedia.org/wiki/Principle_of_least_astonishment (POLA)]. }} |
|||
{{Wikipedia|REXX}}<br> |
|||
<cite>REXX (REstructured eXtended eXecutor) is an interpreted programming language which was developed at IBM. It is a structured high-level programming language which was designed to be both easy to learn and easy to read. Both proprietary and open source interpreters for REXX are available on a wide range of computing platforms, and compilers are available for IBM mainframes.</cite> |
|||
{{Wikipedia|REXX}} |
|||
'''REXX''' is also spelled: |
|||
<cite>REXX (REstructured eXtended eXecutor) is an interpreted programming language which was developed at IBM. It is a structured high-level programming language which was designed to be both easy to learn and easy to read. Both proprietary and open source interpreters for REXX are available on a wide range of computing platforms, and compilers are available for IBM mainframes.</cite> |
|||
::* <big> <big>R</big>exx </big> |
|||
::* <big> <big>R</big><small>EXX </small> </big> |
|||
::::::: but the primary official spelling is '''REXX''' and is the spelling used here on Rosetta Code. |
|||
* '''[[wp:ARexx|ARexx]]''' is a classic REXX implementation (with extensions) for the AmigaOS, given in bundle since AmigaOS 2. (Regina REXX has specific support for the extended functions that were introduced in ARexx.) ARexx was written in 1987 by William S. Hawes. |
|||
The '''REXX''' language was influenced by the computer programming languages: '''ALGOL, PL/I, EXEC,''' and '''EXEC 2.''' |
|||
* '''[[Brexx]]''' a classic REXX written by Vassilis N. Vlachoudis, it is free and it's open source and available under the GNU General Public License. |
|||
Using Classic REXX closely resembles pseudo code and many languages like Basic or Julia. Experienced programmers should have no problem reading REXX code and translating it to other languages.<br> |
|||
* '''[[CRX REXX]]''' (Compact REXX) is a classic REXX first written by Dr. Brian Marks. |
|||
Some items that might differ from what you are familiar with.<br> |
|||
* No data types, no declarations, everything is string. |
|||
* Exponentiation is designated by '**' thus x^2 = x**2. |
|||
* Integer division is designated by '%' thus 13%3 = 4. |
|||
* Modulo division (remainder) is designated by '//' thus 13//3 = 1 ('13 mod 3'). |
|||
* Arrays (here called 'stems') are designated by something like 'stem.a.b. etc' (stem = name array; a, b etc any value; 'associative arrays'). |
|||
* Precision is unlimited (default 9 digits), but you have to specify it yourself ('numeric digits nn'). |
|||
<big><big>Versions of REXX:</big></big> |
|||
* '''[[CTC REXX]]''' is a classic REXX that is bundled with PC/SPF and written by Command Technology Corporation, a license is required to use this product. This version of REXX can only be used under PC/SPF and it's panels. PC/SPF resembles the IBM program product SPF (which has other names and versions). |
|||
* '''[[wp:ARexx|ARexx]]''' is a classic REXX implementation (with extensions) for the AmigaOS, given in bundle since AmigaOS 2. (Regina REXX has specific support for the extended functions that were introduced in ARexx.) ARexx was written in 1987 by William S. Hawes. |
|||
* '''[[Brexx]]''' a classic REXX written by Vassilis N. Vlachoudis, it is free and it's open source and available under the GNU General Public License. |
|||
* '''[[CRX REXX]]''' (Compact REXX) is a classic REXX first written by Dr. Brian Marks. |
|||
* '''[[CTC REXX]]''' is a classic REXX that is bundled with PC/SPF and written by Command Technology Corporation, a license is required to use this product. This version of REXX can only be used under PC/SPF and it's panels. PC/SPF resembles the IBM program product SPF (which has other names and versions). The last version was published in 1996. CTC doesn't exist anymore. |
|||
* '''[[KEXX]]''' is a subset of REXX that is bundled with KEDIT and written by Mansfield Software Group, Inc., a license is required to use this product. KEXX only executes under the KEDIT licensed product. KEDIT is an XEDIT clone (an editor from IBM for VM/CMS program products). |
|||
* '''[[ |
* '''[[KEXX]]''' is a subset of REXX that is bundled with KEDIT and written by Keven J. Kearney of Mansfield Software Group, Inc., a license is required to use this product. KEXX only executes under the KEDIT licensed product. KEDIT is an XEDIT clone (an editor from IBM for VM/CMS program products). |
||
* '''[[MVS/TSO REXX compiler]]''' is an IBM implementation of classic REXX, a license is required to use this product as well as the operating system it runs under. |
|||
* '''[[MVS/TSO REXX]]''' is IBM's implementation of classic REXX, a license is required to use the product as well as the operating system it runs under; '''MVS''' and '''TSO''' are used here as generic references. |
|||
* '''[[NetRexx|NetRexx]]''' is IBM's variant of the REXX programming language to run on the Java virtual machine. It supports a classic REXX syntax, with no reserved keywords, along with considerable additions to support Object-oriented programming in a manner compatible with Java's object model, yet can be used as both a compiled and an interpreted language, with an option of using only data types native to the JVM or the NetRexx run-time package. The syntax and object model of NetRexx differ from Object REXX. |
|||
* '''[https://en.wikipedia.org/wiki/Object_REXX Object REXX]''' is/was an object-oriented scripting language initially produced by IBM for OS/2. It is a follow-on to and a significant extension of the "Classic Rexx" language originally created for the CMS component of VM/SP and later ported to MVS, OS/2 and PC DOS. OS/2 version of IBM Object REXX is deeply integrated with SOM. On October 12, 2004, IBM released Object REXX as open source software, giving rise to Open Object Rexx (ooREXX). |
|||
* '''[[ |
* '''[[MVS/TSO REXX compiler]]''' is an IBM implementation of classic REXX, a license is required to use this product as well as the operating system it runs under. |
||
* '''[[OS/2 REXX]]''' is a classic REXX that is an IBM implementation of classic REXX, a license is required to use this product as well as the operating system it runs under. |
|||
* '''[[NetRexx|NetRexx]]''' is IBM's variant of the REXX programming language to run on the Java virtual machine. It supports a classic REXX syntax, with no reserved keywords, along with considerable additions to support Object-oriented programming in a manner compatible with Java's object model, yet can be used as both a compiled and an interpreted language, with an option of using only data types native to the JVM or the NetRexx run-time package. The syntax and object model of NetRexx differ from Object REXX and Open Object Rexx. |
|||
* '''[[OS/400 REXX]]''' is an IBM implementation of classic REXX, a license is required to use this product as well as the operating system it runs under. |
|||
* '''[[PC/REXX]]''' is the first classic REXX implemented outside of IBM mainframes, intended for IBM DOS and MS DOS. Written by Mansfield Software Group, Inc., REXX was bundled with KEDIT, a license is required to use this product. |
|||
* '''[https://en.wikipedia.org/wiki/Object_REXX Object REXX]''' is/was an object-oriented scripting language initially produced by IBM for OS/2. It is a follow-on to and a significant extension of the "Classic Rexx" language originally created for the CMS component of VM/SP and later ported to MVS, OS/2 and PC DOS. OS/2 version of IBM Object REXX is deeply integrated with SOM. On October 12, 2004, IBM released Object REXX as open source software, giving rise to <u>O</u>pen <u>O</u>bject <u>Rexx</u> (ooRexx). |
|||
* '''[[Personal REXX]]''' is a classic REXX that is intended for IBM DOS and MS DOS, written by a Quercus Systems, a license is required to use this product. |
|||
* '''[[ooRexx|ooRexx]]''' (Open Object Rexx) is an implementation of [[wp:Object REXX|Object REXX]], which is REXX with OO features (some REXX programs are compatible). |
|||
* '''[[OS/2 REXX]]''' is a classic REXX that is an IBM implementation of classic REXX, a license is required to use this product as well as the operating system it runs under. |
|||
* '''[[OS/400 REXX]]''' is an IBM implementation of classic REXX, a license is required to use this product as well as the operating system it runs under. |
|||
* '''[[PC/REXX]]''' is the first classic REXX implemented outside of IBM mainframes, intended for IBM DOS and MS DOS. Written by Mansfield Software Group, Inc., REXX was bundled with KEDIT, a license is required to use this product. |
|||
* '''[[Personal REXX]]''' is a classic REXX that is intended for IBM DOS and MS DOS, written by Charles Daney of Quercus Systems, a license is required to use this product. It is also known as REXX/Personal. |
|||
* '''Portable REXX''' (see the '''R4 REXX''' entry, below). |
* '''Portable REXX''' (see the '''R4 REXX''' entry, below). |
||
* '''[[Regina REXX]]''' is an implementation first created by Anders Christensen (in 1992) and now maintained by others, notably Mark Hessling. Regina REXX runs on more different platforms than any other REXX, too many to name here. It can be downloaded freely. |
|||
* '''[[ |
* '''[[Regina REXX]]''' is an implementation first created by Anders Christensen (in 1992) and is now maintained by others, notably Mark Hessling. Regina REXX runs on more different platforms than any other REXX, too many to name here. It can be downloaded freely. |
||
* '''[[REXX/imc]]''' a classic REXX developed by Ian M. Collier (imc) for Linux/Unix. |
|||
* '''[[ |
* '''[[Reginald REXX]]''' is a REXX developed by Jeff Glatt. It can be downloaded freely. According to Rexxinfo.org, Reginald is out of maintenance. |
||
* '''[[R4 REXX]]''' a classic REXX developed by Keith Watts of Kilowatt Software, Inc. It was also known as '''Portable REXX'''. It can be downloaded freely. |
|||
* '''[[ |
* '''[[REXX/imc]]''' a classic REXX developed by Ian M. Collier (imc) for Linux/Unix. |
||
* '''[[VM/CMS REXX]]''' is an IBM implementation of classic REXX that was first implemented in the early 1980s. A license is required to use this product as well as the operating system that it runs under. This was the original implementation of REXX written (circa 1979) by Mike Cowlishaw of IBM. |
|||
* '''REXX/Personal''' is another name for '''Personal REXX''' (see above). |
|||
* '''[[VM/CMS REXX compiler]]''' is an IBM implementation of classic REXX, a license is required to use this product as well as the operating system it runs under. |
|||
* '''[[ROO oo-REXX]]''' an object-oriented REXX developed by Keith Watts of Kilowatt Software, Inc. It can be downloaded freely. '''ROO''' is also known as '''ROO!'''. According to Rexxinfo.org, Roo! is out of maintenance. |
|||
* '''[[R4 REXX]]''' a classic REXX developed by Keith Watts of Kilowatt Software, Inc. It was also known as '''Portable REXX'''. It can be downloaded freely. According to Rexxinfo.org, R4 is out of maintenance. |
|||
* '''[[T/REXX, a REXX compiler for CMS]]''' is an implementation of classic REXX written by Leigh Lundin and Mark Woodruff (according to Wikipedia). |
|||
* '''[[VM/CMS REXX]]''' is an IBM implementation of classic REXX that was first implemented (for general use) in the early 1980s. A license is required to use this product as well as the operating system that it runs under. This was the original implementation of REXX written (circa 1979) by Mike Cowlishaw of IBM. |
|||
* '''[[VM/CMS REXX compiler]]''' is an IBM implementation of classic REXX, a license is required to use this product as well as the operating system it runs under. |
|||
<br>[Most of the entries were entered mostly from memory and apologies are offered for not knowing more about what wording should be used; the IBM operating systems or Program Products that run REXX are numerous and varied. Their complete (official) names would fill a pageful or two. Some of the REXXes are no longer sold nor available for downloading or purchase, others are no longer maintained. Naming of names is being avoided (especially those licensed products for sale), and it is hoped that this is seen that no products nor vendors are being endorsed, appraised, or critiqued.] -- [[User:Gerard Schildberger|Gerard Schildberger]] 09:28, 1 July 2012 (UTC) |
|||
<br>[Most of the entries were entered mostly from memory and apologies are offered for not knowing more about what wording should be used; the IBM operating systems or Program Products that run REXX are numerous and varied. Their complete (official) names would fill a pageful. Some of the REXXes are no longer sold nor available for downloading or purchase, others are no longer maintained. Naming of names is being avoided (especially those licensed products for sale), and it is hoped that this is seen that no products nor vendors are being endorsed, appraised, or critiqued.] -- [[User:Gerard Schildberger|Gerard Schildberger]] 09:28, 1 July 2012 (UTC) |
|||
===External Links=== |
===External Links=== |
||
* [https://en.wikipedia.org/wiki/ |
* [https://en.wikipedia.org/wiki/Rexx English Wikipedia <big> REXX </big>] |
||
* [https://github.com/vlachoudis/brexx Brexx interpreter] |
* [https://github.com/vlachoudis/brexx Brexx interpreter] |
||
* [http://www.oorexx.org/ Open Object Rexx - www.oorexx.org] |
* [http://www.oorexx.org/ Open Object Rexx - www.oorexx.org] |
||
Line 80: | Line 131: | ||
* [http://www.rexxinfo.org/html/rexxinfo1.html#Rexx-Manuals {many references to REXX manuals}] |
* [http://www.rexxinfo.org/html/rexxinfo1.html#Rexx-Manuals {many references to REXX manuals}] |
||
==Todo== |
|||
== Rosetta Code tasks not implemented in REXX == |
|||
[[Reports:Tasks_not_implemented_in_REXX]] |
[[Reports:Tasks_not_implemented_in_REXX]] |
Latest revision as of 09:33, 19 August 2024
![Language](http://static.miraheze.org/rosettacodewiki/thumb/2/27/Rcode-button-language-crushed.png/64px-Rcode-button-language-crushed.png)
This programming language may be used to instruct a computer to perform a task.
Execution method: | Interpreted |
---|---|
Garbage collected: | Allowed (and in most versions of REXX, it is automatic, but garbage collection isn't mandated). |
Parameter passing methods: | By value |
Type safety: | Safe |
Type strength: | Strong |
Type compatibility: | Nominative |
Type expression: | Inferred |
Type checking: | Dynamic |
Typing: | Untyped |
See Also: |
This page uses content from Wikipedia. The original article was at REXX. The list of authors can be seen in the page history. As with Rosetta Code, the text of Wikipedia is available under the GNU FDL. (See links for details on variance) |
REXX (REstructured eXtended eXecutor) is an interpreted programming language which was developed at IBM. It is a structured high-level programming language which was designed to be both easy to learn and easy to read. Both proprietary and open source interpreters for REXX are available on a wide range of computing platforms, and compilers are available for IBM mainframes.
REXX is also spelled:
- Rexx
- REXX
- but the primary official spelling is REXX and is the spelling used here on Rosetta Code.
The REXX language was influenced by the computer programming languages: ALGOL, PL/I, EXEC, and EXEC 2.
Using Classic REXX closely resembles pseudo code and many languages like Basic or Julia. Experienced programmers should have no problem reading REXX code and translating it to other languages.
Some items that might differ from what you are familiar with.
- No data types, no declarations, everything is string.
- Exponentiation is designated by '**' thus x^2 = x**2.
- Integer division is designated by '%' thus 13%3 = 4.
- Modulo division (remainder) is designated by '//' thus 13//3 = 1 ('13 mod 3').
- Arrays (here called 'stems') are designated by something like 'stem.a.b. etc' (stem = name array; a, b etc any value; 'associative arrays').
- Precision is unlimited (default 9 digits), but you have to specify it yourself ('numeric digits nn').
Versions of REXX:
- ARexx is a classic REXX implementation (with extensions) for the AmigaOS, given in bundle since AmigaOS 2. (Regina REXX has specific support for the extended functions that were introduced in ARexx.) ARexx was written in 1987 by William S. Hawes.
- Brexx a classic REXX written by Vassilis N. Vlachoudis, it is free and it's open source and available under the GNU General Public License.
- CRX REXX (Compact REXX) is a classic REXX first written by Dr. Brian Marks.
- CTC REXX is a classic REXX that is bundled with PC/SPF and written by Command Technology Corporation, a license is required to use this product. This version of REXX can only be used under PC/SPF and it's panels. PC/SPF resembles the IBM program product SPF (which has other names and versions). The last version was published in 1996. CTC doesn't exist anymore.
- KEXX is a subset of REXX that is bundled with KEDIT and written by Keven J. Kearney of Mansfield Software Group, Inc., a license is required to use this product. KEXX only executes under the KEDIT licensed product. KEDIT is an XEDIT clone (an editor from IBM for VM/CMS program products).
- MVS/TSO REXX is IBM's implementation of classic REXX, a license is required to use the product as well as the operating system it runs under; MVS and TSO are used here as generic references.
- MVS/TSO REXX compiler is an IBM implementation of classic REXX, a license is required to use this product as well as the operating system it runs under.
- NetRexx is IBM's variant of the REXX programming language to run on the Java virtual machine. It supports a classic REXX syntax, with no reserved keywords, along with considerable additions to support Object-oriented programming in a manner compatible with Java's object model, yet can be used as both a compiled and an interpreted language, with an option of using only data types native to the JVM or the NetRexx run-time package. The syntax and object model of NetRexx differ from Object REXX and Open Object Rexx.
- Object REXX is/was an object-oriented scripting language initially produced by IBM for OS/2. It is a follow-on to and a significant extension of the "Classic Rexx" language originally created for the CMS component of VM/SP and later ported to MVS, OS/2 and PC DOS. OS/2 version of IBM Object REXX is deeply integrated with SOM. On October 12, 2004, IBM released Object REXX as open source software, giving rise to Open Object Rexx (ooRexx).
- ooRexx (Open Object Rexx) is an implementation of Object REXX, which is REXX with OO features (some REXX programs are compatible).
- OS/2 REXX is a classic REXX that is an IBM implementation of classic REXX, a license is required to use this product as well as the operating system it runs under.
- OS/400 REXX is an IBM implementation of classic REXX, a license is required to use this product as well as the operating system it runs under.
- PC/REXX is the first classic REXX implemented outside of IBM mainframes, intended for IBM DOS and MS DOS. Written by Mansfield Software Group, Inc., REXX was bundled with KEDIT, a license is required to use this product.
- Personal REXX is a classic REXX that is intended for IBM DOS and MS DOS, written by Charles Daney of Quercus Systems, a license is required to use this product. It is also known as REXX/Personal.
- Portable REXX (see the R4 REXX entry, below).
- Regina REXX is an implementation first created by Anders Christensen (in 1992) and is now maintained by others, notably Mark Hessling. Regina REXX runs on more different platforms than any other REXX, too many to name here. It can be downloaded freely.
- Reginald REXX is a REXX developed by Jeff Glatt. It can be downloaded freely. According to Rexxinfo.org, Reginald is out of maintenance.
- REXX/imc a classic REXX developed by Ian M. Collier (imc) for Linux/Unix.
- REXX/Personal is another name for Personal REXX (see above).
- ROO oo-REXX an object-oriented REXX developed by Keith Watts of Kilowatt Software, Inc. It can be downloaded freely. ROO is also known as ROO!. According to Rexxinfo.org, Roo! is out of maintenance.
- R4 REXX a classic REXX developed by Keith Watts of Kilowatt Software, Inc. It was also known as Portable REXX. It can be downloaded freely. According to Rexxinfo.org, R4 is out of maintenance.
- T/REXX, a REXX compiler for CMS is an implementation of classic REXX written by Leigh Lundin and Mark Woodruff (according to Wikipedia).
- VM/CMS REXX is an IBM implementation of classic REXX that was first implemented (for general use) in the early 1980s. A license is required to use this product as well as the operating system that it runs under. This was the original implementation of REXX written (circa 1979) by Mike Cowlishaw of IBM.
- VM/CMS REXX compiler is an IBM implementation of classic REXX, a license is required to use this product as well as the operating system it runs under.
[Most of the entries were entered mostly from memory and apologies are offered for not knowing more about what wording should be used; the IBM operating systems or Program Products that run REXX are numerous and varied. Their complete (official) names would fill a pageful or two. Some of the REXXes are no longer sold nor available for downloading or purchase, others are no longer maintained. Naming of names is being avoided (especially those licensed products for sale), and it is hoped that this is seen that no products nor vendors are being endorsed, appraised, or critiqued.] -- Gerard Schildberger 09:28, 1 July 2012 (UTC)
External Links
- English Wikipedia REXX
- Brexx interpreter
- Open Object Rexx - www.oorexx.org
- The NetRexx Programming Language - www.netrexx.org
- The Rexx Language Association - www.rexxla.org
- Regina Rexx Interpreter
- Mansfield Software Group, Inc. (KEDIT)
- Personal REXX, Quercus Systems
- CTC Command Technology
- CRX Open Source (right column side)
- R4, Kilowatt Software
- ROO, Kilowatt Software
- z/VM V6R1 REXX/VM Reference
- z/VM V6R1 REXX/VM User's Guide
- {many references to REXX manuals}
Rosetta Code tasks not implemented in REXX
Subcategories
This category has the following 4 subcategories, out of 4 total.
@
- REXX examples needing attention (empty)
- REXX User (31 P)
R
- REXX library routines (20 P)
Pages in category "REXX"
The following 200 pages are in this category, out of 1,159 total.
(previous page) (next page)A
- A* search algorithm
- A+B
- Abbreviations, automatic
- Abbreviations, easy
- Abbreviations, simple
- ABC problem
- ABC words
- Abelian sandpile model/Identity
- Abstract type
- Abundant odd numbers
- Abundant, deficient and perfect number classifications
- Accumulator factory
- Ackermann function
- Active Directory/Search for a user
- Additive primes
- Address of a variable
- ADFGVX cipher
- Air mass
- AKS test for primes
- Algebraic data types
- Align columns
- Aliquot sequence classifications
- Almkvist-Giullera formula for pi
- Almost prime
- Alternade words
- Amb
- Amicable pairs
- Anagrams
- Anagrams/Deranged anagrams
- Angle difference between two bearings
- Angles (geometric), normalization and conversion
- Animate a pendulum
- Animation
- Anonymous recursion
- Anti-primes
- Append a record to the end of a text file
- Apply a callback to an array
- Apply a digital filter (direct form II transposed)
- Approximate equality
- Apéry's constant
- Arbitrary-precision integers (included)
- Archimedean spiral
- Arena storage pool
- Arithmetic evaluation
- Arithmetic numbers
- Arithmetic-geometric mean
- Arithmetic-geometric mean/Calculate Pi
- Arithmetic/Complex
- Arithmetic/Integer
- Arithmetic/Rational
- Array concatenation
- Array length
- Arrays
- ASCII art diagram converter
- Assertions
- Assertions in design by contract
- Associative array/Creation
- Associative array/Iteration
- Associative array/Merging
- Attractive numbers
- Audio alarm
- Average loop length
- Averages/Arithmetic mean
- Averages/Mean angle
- Averages/Mean time of day
- Averages/Median
- Averages/Mode
- Averages/Pythagorean means
- Averages/Root mean square
- Averages/Simple moving average
B
- Babbage problem
- Bacon cipher
- Balanced brackets
- Balanced ternary
- Barnsley fern
- Base 16 numbers needing a to f
- Base58Check encoding
- Base64 encode data
- Bell numbers
- Benford's law
- Bernoulli numbers
- Best shuffle
- Bin given limits
- Binary digits
- Binary search
- Binary strings
- Bioinformatics/base count
- Bioinformatics/Subsequence
- Biorhythms
- Birthday problem
- Bitmap
- Bitmap/Bresenham's line algorithm
- Bitmap/Flood fill
- Bitmap/Midpoint circle algorithm
- Bitmap/Read a PPM file
- Bitmap/Write a PPM file
- Bitwise IO
- Bitwise operations
- Boolean values
- Box the compass
- Brace expansion
- Brazilian numbers
- Brownian tree
- Bulls and cows
- Bulls and cows/Player
- Burrows–Wheeler transform
C
- Caesar cipher
- Calculating the value of e
- Calendar
- Calendar - for "REAL" programmers
- Calkin-Wilf sequence
- Call a foreign-language function
- Call a function
- Call a function in a shared library
- Canonicalize CIDR
- Cantor set
- Card shuffles
- Carmichael 3 strong pseudoprimes
- Carmichael lambda function
- Cartesian product of two or more lists
- Case-sensitivity of identifiers
- Casting out nines
- Catalan numbers
- Catalan numbers/Pascal's triangle
- Catamorphism
- Change e letters to i in words
- Changeable words
- Chaos game
- Character codes
- Chebyshev coefficients
- Check input device is a terminal
- Check Machin-like formulas
- Check output device is a terminal
- Check that file exists
- Chemical calculator
- Chernick's Carmichael numbers
- Cheryl's birthday
- Chinese remainder theorem
- Cholesky decomposition
- Chowla numbers
- Circles of given radius through two points
- Circular primes
- Cistercian numerals
- Closest-pair problem
- Closures/Value capture
- Code segment unload
- Collect and sort square numbers in ascending order from three lists
- Collections
- Color of a screen pixel
- Colour bars/Display
- Combinations
- Combinations and permutations
- Combinations with repetitions
- Comma quibbling
- Command-line arguments
- Commatizing numbers
- Comments
- Common list elements
- Common sorted list
- Compare a list of strings
- Compare length of two strings
- Compare sorting algorithms' performance
- Compile-time calculation
- Compiler/Simple file inclusion pre processor
- Compound data type
- Concatenate two primes is also prime
- Conditional structures
- Conjugate a Latin verb
- Conjugate transpose
- Consecutive primes with ascending or descending differences
- Constrained random points on a circle
- Continued fraction
- Continued fraction/Arithmetic/Construct from rational number
- Convert decimal number to rational
- Convert seconds to compound duration
- Convex hull
- Conway's Game of Life
- Coprime triplets
- Coprimes
- Copy a string
- Copy stdin to stdout
- Count how many vowels and consonants occur in a string
- Count in factors
- Count in octal
- Count occurrences of a substring
- Count the coins
- Cousin primes
- Cramer's rule
- CRC-32
- Execution method/Interpreted
- Garbage collection/Allowed (and in most versions of REXX, it is automatic, but garbage collection isn't mandated).
- Parameter passing/By value
- Typing/Safe
- Typing/Strong
- Typing/Compatibility/Nominative
- Typing/Expression/Inferred
- Typing/Checking/Dynamic
- Typing/Untyped
- Programming Languages
- WikipediaSourced