aparler/RosettaCodeData
1
0
Fork 0
Code Issues 12 Pull requests 3 Projects Releases Packages Wiki Activity Actions

Data commit

Browse source
This commit is contained in:
Ingy döt Net 2023-07-01 11:58:00 -04:00
parent 7387c8f97b
commit cb5bb5e222
199093 changed files with 3378972 additions and 0 deletions
Download patch file Download diff file Expand all files Collapse all files

19
Task/Call-a-function/REXX/call-a-function-1.rexx Normal file
View file

@ -0,0 +1,19 @@
/*REXX pgms demonstrates various methods/approaches of invoking/calling a REXX function.*/
/*╔════════════════════════════════════════════════════════════════════╗
║ Calling a function that REQUIRES no arguments. ║
║ ║
║ In the REXX language, there is no way to require the caller to not ║
║ pass arguments, but the programmer can check if any arguments were ║
║ (or weren't) passed. ║
╚════════════════════════════════════════════════════════════════════╝*/
yr= yearFunc() /*the function name is caseless if it isn't */
/*enclosed in quotes (') or apostrophes (").*/
say 'year=' yr
exit /*stick a fork in it, we're all done. */
yearFunc: procedure /*function ARG returns the # of args.*/
errmsg= '***error***' /*an error message eyecatcher string. */
if arg() \== 0 then say errmsg "the YEARFUNC function won't accept arguments."
return left( date('Sorted'), 3)

25
Task/Call-a-function/REXX/call-a-function-2.rexx Normal file
View file

@ -0,0 +1,25 @@
/*╔════════════════════════════════════════════════════════════════════╗
║ Calling a function with a fixed number of arguments. ║
║ ║
║ I take this to mean that the function requires a fixed number of ║
║ arguments. As above, REXX doesn't enforce calling (or invoking) ║
║ a (any) function with a certain number of arguments, but the ║
║ programmer can check if the correct number of arguments have been ║
║ specified (or not). ║
║ In some languages, these are known as "generic" functions. ║
╚════════════════════════════════════════════════════════════════════╝*/
ggg= FourFunc(12, abc, 6+q, zz%2, 'da 5th disagreement')
say 'ggg squared=' ggg**2
exit /*stick a fork in it, we're all done. */
FourFunc: procedure; parse arg a1,a2,a3 /*obtain the first three arguments. */
a4= arg(4) /*another way to obtain the 4th arg. */
errmsg= '***error***' /*an error message eyecatcher string. */
if arg() \== 4 then do
say err "FourFunc function requires 4 arguments,"
say err "but instead it found" arg() 'arguments.'
exit 13 /*exit function with a RC of 13*/
end
return a1 + a2 + a3 + a4

18
Task/Call-a-function/REXX/call-a-function-3.rexx Normal file
View file

@ -0,0 +1,18 @@
/*╔════════════════════════════════════════════════════════════════════╗
║ Calling a function with optional arguments. ║
║ ║
║ Note that not passing an argument isn't the same as passing a null ║
║ argument (a REXX variable whose value is length zero). ║
╚════════════════════════════════════════════════════════════════════╝*/
x= 12; w= x/2; y= x**2; z= x//7 /* z is x modulo seven. */
say 'sum of w, x, y, & z=' SumIt(w,x,y,,z) /*pass five args, the 4th arg is "null"*/
exit /*stick a fork in it, we're all done. */
SumIt: procedure
$= 0 /*initialize the sum to zero. */
do j=1 for arg() /*obtain the sum of a number of args. */
if arg(j,'E') then $= $ + arg(j) /*the Jth arg may have been omitted. */
end /*j*/
return $

27
Task/Call-a-function/REXX/call-a-function-4.rexx Normal file
View file

@ -0,0 +1,27 @@
/*╔════════════════════════════════════════════════════════════════════╗
║ Calling a function with a variable number of arguments. ║
║ ║
║ This situation isn't any different then the previous example. ║
║ It's up to the programmer to code how to utilize the arguments. ║
╚════════════════════════════════════════════════════════════════════╝*/
/*╔════════════════════════════════════════════════════════════════════╗
║ Calling a function with named arguments. ║
║ ║
║ REXX allows almost anything to be passed, so the following is one ║
║ way this can be accomplished. ║
╚════════════════════════════════════════════════════════════════════╝*/
what= parserFunc('name=Luna', "gravity=.1654", 'moon=yes')
say 'name=' common.name
gr= common.gr
say 'gravity=' gr
exit /*stick a fork in it, we're all done. */
parseFunc: procedure expose common.
do j=1 for arg()
parse var arg(j) name '=' val
upper name /*uppercase it.*/
call value 'COMMON.'name,val
end
return arg()

16
Task/Call-a-function/REXX/call-a-function-5.rexx Normal file
View file

@ -0,0 +1,16 @@
/*╔════════════════════════════════════════════════════════════════════╗
║ Calling a function in statement context. ║
║ ║
║ REXX allows functions to be called (invoked) two ways, the first ║
║ example (above) is calling a function in statement context. ║
╚════════════════════════════════════════════════════════════════════╝*/
/*╔════════════════════════════════════════════════════════════════════╗
║ Calling a function in within an expression. ║
║ ║
║ This is a variant of the first example. ║
╚════════════════════════════════════════════════════════════════════╝*/
yr= yearFunc() + 20
say 'two decades from now, the year will be:' yr
exit /*stick a fork in it, we're all done. */

11
Task/Call-a-function/REXX/call-a-function-6.rexx Normal file
View file

@ -0,0 +1,11 @@
/*╔════════════════════════════════════════════════════════════════════╗
║ Obtaining the return value of a function. ║
║ ║
║ There are 2 ways to get the (return) value (RESULT) of a function. ║
╚════════════════════════════════════════════════════════════════════╝*/
currYear= yearFunc()
say 'the current year is' currYear
call yearFunc
say 'the current year is' result /*result can be RESULT, it is caseless.*/

18
Task/Call-a-function/REXX/call-a-function-7.rexx Normal file
View file

@ -0,0 +1,18 @@
/*╔════════════════════════════════════════════════════════════════════╗
║ Distinguishing built-in functions and user-defined functions. ║
║ ║
║ One objective of the REXX language is to allow the user to use any ║
║ function (or subroutine) name whether or not there is a built-in ║
║ function with the same name (there isn't a penality for this). ║
╚════════════════════════════════════════════════════════════════════╝*/
/*date: as in going out with someone. */
qqq= date() /*number of real dates that Bob was on.*/
/*hopefully, it accurately counts dates*/
say "Bob's been out" qqq 'times.'
www= 'DATE'("USA") /*returns date in format mm/dd/yyyy */
/*any function in quotes is external. */
exit /*stick a fork in it, we're all done. */
date: return 4 /*Bob only "went out" 4 times, no need */
/* to actually count, he quit after 4. */

24
Task/Call-a-function/REXX/call-a-function-8.rexx Normal file
View file

@ -0,0 +1,24 @@
/*╔════════════════════════════════════════════════════════════════════╗
║ Distinguishing subroutines and functions. ║
║ ║
║ There is no programmatic difference between subroutines and ║
║ functions if the subroutine returns a value (which effectively ║
║ makes it a function). REXX allows you to call a function as if ║
║ it were a subroutine. ║
╚════════════════════════════════════════════════════════════════════╝*/
/*╔════════════════════════════════════════════════════════════════════╗
║ In REXX, all arguments are passed by value, never by name, but it ║
║ is possible to accomplish this if the variable's name is passed ║
║ and the subroutine/function could use the built-in-function VALUE ║
║ to retrieve the variable's value. ║
╚════════════════════════════════════════════════════════════════════╝*/
/*╔════════════════════════════════════════════════════════════════════╗
║ In the REXX language, partial application is possible, depending ║
║ how partial application is defined; I prefer the 1st definition ║
║ (as per the "discussion" for "Partial Function Application" task: ║
║ 1. The "syntactic sugar" that allows one to write some examples ║
║ are: map (f 1 9) [1..9] ║
║ or: map (f(1,_,9)) [1, ..., 9] ║
╚════════════════════════════════════════════════════════════════════╝*/

77
Task/Call-a-function/REXX/call-a-function-9.rexx Normal file
View file

@ -0,0 +1,77 @@
/* REXX ***************************************************************
* 29.07.2013 Walter Pachl trying to address the task concisely
***********************************************************************
* f1 Calling a function that requires no arguments
* f2 Calling a function with a fixed number of arguments
* f3 Calling a function with optional arguments
* f4 Calling a function with a variable number of arguments
* f5 Calling a function with named arguments
* f6 Using a function in statement context
* f7 Using a function within an expression
* f8 Obtaining the return value of a function
* f8(...) is replaced by the returned value
* call f8 ... returned value is in special vatiable RESULT
* f9 Distinguishing built-in functions and user-defined functions
* bif is enforced by using its name quoted in uppercase
* fa,fb Distinguishing subroutines and functions
* Stating whether arguments are passed by value or by reference
* Arguments are passed by value
* ooRexx supports passing by reference (Use Arg instruction)
* Is partial application possible and how
* no ideas
**********************************************************************/
say f1()
Say f2(1,2,3)
say f2(1,2,3,4)
say f3(1,,,4)
Say f4(1,2)
Say f4(1,2,3)
a=4700; b=11;
Say f5('A','B')
f6() /* returned value is used as command */
x=f7()**2
call f8 1,2; Say result '=' f8(1,2)
f9: Say 'DATE'('S') date()
call fa 11,22; Say result '=' fa(1,,
2) /* the second comma above is for line continuation */
Signal On Syntax
Call fb 1,2
x=fb(1,2)
Exit
f1: Return 'f1 doesn''t need an argument'
f2: If arg()=3 Then
Return 'f2: Sum of 3 arguments:' arg(1)+arg(2)+arg(3)
Else
Return 'f2: Invalid invocation:' arg() 'arguments. Needed: 3'
f3: sum=0
do i=1 To arg()
If arg(i,'E')=0 Then Say 'f3: Argument' i 'omitted'
Else sum=sum+arg(i)
End
Return 'f3 sum=' sum
f4: sum=0; Do i=1 To arg(); sum=sum+arg(i); End
Return 'f4: Sum of' arg() 'arguments is' sum
f5: Parse Arg p1,p2
Say 'f5: Argument 1 ('p1') contains' value(p1)
Say 'f5: Argument 2 ('p2') contains' value(p2)
Return 'f5: sum='value(p1)+value(p2)
f6: Say 'f6: dir ft.rex'
Return 'dir ft.rex'
f7: Say 'f7 returns 7'
Return 7
f8: Say 'f8 returns arg(1)+arg(2)'
Return arg(1)+arg(2)
date: Say 'date is my date function'
Return translate('ef/gh/abcd','DATE'('S'),'abcdefgh')
fa: Say 'fa returns arg(1)+arg(2)'
Return arg(1)+arg(2)
fb: Say 'fb:' arg(1)','arg(2)
Return
Syntax:
Say 'Syntax raised in line' sigl
Say sourceline(sigl)
Say 'rc='rc '('errortext(rc)')'
If sigl=39 Then
Say 'fb cannot be invoked as function (it does not return a value'
Exit