A-M baby

Task/Function-definition/0DESCRIPTION

@@ -0,0 +1,6 @@
+A function is a body of code that returns a value. The value returned may depend on arguments provided to the function.
+
+Write a definition of a function called "multiply" that takes two arguments and returns their product.
+(Argument types should be chosen so as not to distract from showing how functions are created and values returned).
+
+See also:[[Function prototype]]

Task/Function-definition/1META.yaml

@@ -0,0 +1,4 @@
+---
+category:
+- Functions and subroutines
+note: Basic language learning

Task/Function-definition/ACL2/function-definition.acl2

@@ -0,0 +1 @@
+(defun multiply (a b) (* a b))

Task/Function-definition/ALGOL-68/function-definition.alg

@@ -0,0 +1,4 @@
+PROC multiply = ( LONG REAL a, b ) LONG REAL:
+(
+  a * b
+)

Task/Function-definition/APL/function-definition.apl

@@ -0,0 +1 @@
+       multiply  ←  ×

Task/Function-definition/AWK/function-definition.awk

@@ -0,0 +1,7 @@
+function multiply(a, b)
+{
+  return a*b
+}
+BEGIN {
+  print multiply(5, 6)
+}

Task/Function-definition/ActionScript/function-definition.as

@@ -0,0 +1,3 @@
+function multiply(a:Number, b:Number):Number {
+    return a * b;
+}

Task/Function-definition/Ada/function-definition-1.ada

@@ -0,0 +1 @@
+function Multiply (A, B : Float) return Float;

Task/Function-definition/Ada/function-definition-2.ada

@@ -0,0 +1,4 @@
+function Multiply (A, B : Float) return Float is
+begin
+   return A * B;
+end Multiply;

Task/Function-definition/Ada/function-definition-3.ada

@@ -0,0 +1 @@
+function Multiply(A, B: Float) return Float is (A * B);

Task/Function-definition/Ada/function-definition-4.ada

@@ -0,0 +1,3 @@
+generic
+   type Number is digits <>;
+function Multiply (A, B : Number) return Number;

Task/Function-definition/Ada/function-definition-5.ada

@@ -0,0 +1,4 @@
+function Multiply (A, B : Number) return Number is
+begin
+   return A * B;
+end Multiply;

Task/Function-definition/Ada/function-definition-6.ada

@@ -0,0 +1,7 @@
+with Multiply;
+...
+function Multiply_Integer is new Multiply(Number => Integer);
+use Multiply_Integer; -- If you must
+
+type My_Integer is Range -100..100;
+function Multiply_My_Integer is new Multiply(My_Integer);

Task/Function-definition/AmigaE/function-definition.amiga

@@ -0,0 +1,11 @@
+PROC my_molt(a,b)
+-> other statements if needed... here they are not
+ENDPROC a*b    -> return value
+
+-> or simplier
+
+PROC molt(a,b) IS a*b
+
+PROC main()
+  WriteF('\d\n', my_molt(10,20))
+ENDPROC

Task/Function-definition/AppleScript/function-definition.applescript

@@ -0,0 +1,3 @@
+on multiply(a, b)
+    return a * b
+end

Task/Function-definition/Applesoft-BASIC/function-definition-1.bas

@@ -0,0 +1,2 @@
+10  DEF  FN MULTIPLY(P) =  P(P) * P(P+1)
+20  P(1) = 611 : P(2) = 78 : PRINT  FN MULTIPLY(1)

Task/Function-definition/Applesoft-BASIC/function-definition-2.bas

@@ -0,0 +1 @@
+47658

Task/Function-definition/Argile/function-definition-1.argile

@@ -0,0 +1,2 @@
+use std
+.: multiply <real a, real b> :. -> real {a * b}

Task/Function-definition/Argile/function-definition-2.argile

@@ -0,0 +1,2 @@
+use std
+=: multiply <real a> [<real b>...] := -> real {Cgen a (@@1 (Cgen " * " b))}

Task/Function-definition/AutoHotkey/function-definition.ahk

@@ -0,0 +1,5 @@
+MsgBox % multiply(10,2)
+
+multiply(multiplicand, multiplier) {
+  Return (multiplicand * multiplier)
+}

Task/Function-definition/AutoIt/function-definition.autoit

@@ -0,0 +1,7 @@
+#AutoIt Version: 3.2.10.0
+$I=11
+$J=12
+MsgBox(0,"Multiply", $I &" * "& $J &" = " & product($I,$J))
+Func product($a,$b)
+   Return $a * $b
+EndFunc

Task/Function-definition/BASIC/function-definition.bas

@@ -0,0 +1,5 @@
+DECLARE FUNCTION multiply% (a AS INTEGER, b AS INTEGER)
+
+FUNCTION multiply% (a AS INTEGER, b AS INTEGER)
+    multiply = a * b
+END FUNCTION

Task/Function-definition/BBC-BASIC/function-definition-1.bbc

@@ -0,0 +1,4 @@
+PRINT FNmultiply(6,7)
+END
+
+DEF FNmultiply(a,b) = a * b

Task/Function-definition/BBC-BASIC/function-definition-2.bbc

@@ -0,0 +1,4 @@
+DEF FNmultiply(a,b)
+LOCAL c
+c = a * b
+= c

Task/Function-definition/Batch-File/function-definition.bat

@@ -0,0 +1,11 @@
+@ECHO OFF
+SET /A result = 0
+CALL :multiply 2 3
+ECHO %result%
+GOTO :eof
+
+:multiply
+    SET /A result = %1 * %2
+    GOTO :eof
+
+:eof

Task/Function-definition/Boo/function-definition.boo

@@ -0,0 +1,4 @@
+def multiply(x as int, y as int):
+    return x * y
+
+print multiply(3, 2)

Task/Function-definition/Bracmat/function-definition.bracmat

@@ -0,0 +1,2 @@
+multiply=a b.!arg:(?a.?b)&!a*!b;
+out$multiply$(123456789.987654321); { writes 121932631112635269 to standard output }

Task/Function-definition/Brat/function-definition.brat

@@ -0,0 +1,3 @@
+multiply = { x, y | x * y }
+
+p multiply 3 14  #Prints 42

Task/Function-definition/C++/function-definition-1.cpp

@@ -0,0 +1,4 @@
+inline double multiply(double a, double b)
+{
+   return a*b;
+}

Task/Function-definition/C++/function-definition-2.cpp

@@ -0,0 +1,5 @@
+template<typename Number>
+  Number multiply(Number a, Number b)
+{
+   return a*b;
+}

Task/Function-definition/C/function-definition-1.c

@@ -0,0 +1,4 @@
+double multiply(double a, double b)
+{
+   return a * b;
+}

Task/Function-definition/C/function-definition-2.c

@@ -0,0 +1 @@
+#define MULTIPLY(X, Y) ((X) * (Y))

Task/Function-definition/C/function-definition-3.c

@@ -0,0 +1 @@
+x = MULTIPLY(x + z, y);

Task/Function-definition/C/function-definition-4.c

@@ -0,0 +1 @@
+x = ((x + z) * (y));

Task/Function-definition/COBOL/function-definition.cobol

@@ -0,0 +1,29 @@
+       * Multiply in COBOL
+
+       IDENTIFICATION DIVISION.
+       PROGRAM-ID. myTest.
+       DATA DIVISION.
+       WORKING-STORAGE SECTION.
+       01  x   PIC 9(3) VALUE 3.
+       01  y   PIC 9(3) VALUE 2.
+       01  z   PIC 9(9).
+       PROCEDURE DIVISION.
+           CALL "myMultiply" USING
+               BY CONTENT x, BY CONTENT y,
+               BY REFERENCE z.
+           DISPLAY z.
+           STOP RUN.
+       END PROGRAM myTest.
+
+       IDENTIFICATION DIVISION.
+       PROGRAM-ID. myMultiply.
+       DATA DIVISION.
+       WORKING-STORAGE SECTION.
+       LINKAGE SECTION.
+       01  x   PIC 9(3).
+       01  y   PIC 9(3).
+       01  z   PIC 9(9).
+       PROCEDURE DIVISION USING x, y, z.
+           MULTIPLY x BY y GIVING z.
+           EXIT PROGRAM.
+       END PROGRAM myMultiply.

Task/Function-definition/Clay/function-definition.clay

@@ -0,0 +1 @@
+multiply(x,y) = x * y;

Task/Function-definition/Clojure/function-definition-1.clj

@@ -0,0 +1,4 @@
+(defn multiply [x y]
+  (* x y))
+
+(multiply 4 5)

Task/Function-definition/Clojure/function-definition-2.clj

@@ -0,0 +1,8 @@
+(defn multiply
+  ([] 1)
+  ([x] x)
+  ([x y] (* x y))
+  ([x y & more]
+    (reduce * (* x y) more)))
+
+(multiply 2 3 4 5)  ; 120

Task/Function-definition/CoffeeScript/function-definition.coffee

@@ -0,0 +1 @@
+multiply = (a, b) -> a * b

Task/Function-definition/ColdFusion/function-definition.cfm

@@ -0,0 +1,5 @@
+<cffunction name="multiply" returntype="numeric">
+	<cfargument name="a" type="numeric">
+	<cfargument name="b" type="numeric">
+	<cfreturn a * b>
+</cffunction>

Task/Function-definition/Common-Lisp/function-definition-1.lisp

@@ -0,0 +1,4 @@
+(defun multiply (a b)
+  (* a b))
+
+(multiply 2 3)

Task/Function-definition/Common-Lisp/function-definition-2.lisp

@@ -0,0 +1,4 @@
+(define-compiler-macro multiply (&whole expr a b)
+  (if (and (constantp a) (constantp b))
+    (* (eval a) (eval b))
+    expr)) ;; no macro recursion if we just return expr; the job is done!

Task/Function-definition/Common-Lisp/function-definition-3.lisp

@@ -0,0 +1 @@
+;;; terrific example coming

Task/Function-definition/D/function-definition.d

@@ -0,0 +1,26 @@
+// A function:
+int multiply1(int a, int b) {
+    return a * b;
+}
+
+// Functions like "multiply1" can be evaluated at compile time if
+// they are called where a compile-time constant result is asked for:
+enum result = multiply1(2, 3); // Evaluated at compile time.
+int[multiply1(2, 4)] array;    // Evaluated at compile time.
+
+// A templated function:
+T multiply2(T)(T a, T b) {
+    return a * b;
+}
+
+// Compile-time multiplication can also be done using templates:
+template multiply3(int a, int b) {
+    enum multiply3 = a * b;
+}
+
+pragma(msg, multiply3!(2, 3)); // Prints "6" during compilation.
+
+void main() {
+    import std.stdio;
+    writeln("2 * 3 = ", result);
+}

Task/Function-definition/DWScript/function-definition.dwscript

@@ -0,0 +1,4 @@
+function Multiply(a, b : Integer) : Integer;
+begin
+   Result := a * b;
+end;

Task/Function-definition/Delphi/function-definition.delphi

@@ -0,0 +1,4 @@
+function Multiply(a, b: Integer): Integer;
+begin
+  Result := a * b;
+end;

Task/Function-definition/E/function-definition-1.e

@@ -0,0 +1,3 @@
+def multiply(a, b) {
+    return a * b
+}

Task/Function-definition/E/function-definition-2.e

@@ -0,0 +1 @@
+def multiply := fn a, b { a * b }

Task/Function-definition/Efene/function-definition.efene

@@ -0,0 +1,8 @@
+multiply = fn (A, B) {
+    A * B
+}
+
+@public
+run = fn () {
+    io.format("~p~n", [multiply(2, 5)])
+}

Task/Function-definition/Ela/function-definition-1.ela

@@ -0,0 +1 @@
+multiply x y = x * y

Task/Function-definition/Ela/function-definition-2.ela

@@ -0,0 +1 @@
+\x y -> x * y

Task/Function-definition/Erlang/function-definition.erl

@@ -0,0 +1 @@
+multiply(A,B) -> A*B.

Task/Function-definition/Euphoria/function-definition-1.euphoria

@@ -0,0 +1,3 @@
+function multiply( atom a, atom b )
+    return a * b
+end function

Task/Function-definition/Euphoria/function-definition-2.euphoria

@@ -0,0 +1,12 @@
+function multiply( object a, object b )
+    return a * b
+end function
+
+sequence a = {1,2,3,4}
+sequence b = {5,6,7,8}
+
+? multiply( 9, 9 )
+? multiply( 3.14159, 3.14159 )
+? multiply( a, b )
+? multiply( a, 7 )
+? multiply( 10.39564, b )

Task/Function-definition/FALSE/function-definition.false

@@ -0,0 +1,3 @@
+[*]     {anonymous function to multiply the top two items on the stack}
+m:      {binding the function to one of the 26 available symbol names}
+2 3m;!  {executing the function, yielding 6}

Task/Function-definition/Factor/function-definition.factor

@@ -0,0 +1 @@
+: multiply ( a b -- a*b ) * ;

Task/Function-definition/Falcon/function-definition.falcon

@@ -0,0 +1,3 @@
+function sayHiTo( name )
+ > "Hi ", name
+end

Task/Function-definition/Fantom/function-definition.fantom

@@ -0,0 +1,8 @@
+class FunctionDefinition
+{
+  public static Void main ()
+  {
+    multiply := |Int a, Int b -> Int| { a * b }
+    echo ("Multiply 2 and 4: ${multiply(2, 4)}")
+  }
+}

Task/Function-definition/Fexl/function-definition-1.fexl

@@ -0,0 +1 @@
+\multiply=(\x\y * x y)

Task/Function-definition/Fexl/function-definition-2.fexl

@@ -0,0 +1 @@
+\multiply=*

Task/Function-definition/Forth/function-definition.fth

@@ -0,0 +1,2 @@
+: fmultiply ( F: a b -- F: c )  F* ;
+: multiply ( a b -- c )  * ;

Task/Function-definition/Fortran/function-definition-1.f

@@ -0,0 +1,4 @@
+FUNCTION MULTIPLY(X,Y)
+REAL MULTIPLY, X, Y
+MULTIPLY = X * Y
+END

Task/Function-definition/Fortran/function-definition-2.f

@@ -0,0 +1,8 @@
+module elemFunc
+contains
+    elemental function multiply(x, y)
+        real, intent(in) :: x, y
+        real :: multiply
+        multiply = x * y
+    end function multiply
+end module elemFunc

Task/Function-definition/Fortran/function-definition-3.f

@@ -0,0 +1,10 @@
+program funcDemo
+    use elemFunc
+
+    real :: a = 20.0, b = 30.0, c
+    real, dimension(5) :: x = (/ 1.0, 2.0, 3.0, 4.0, 5.0 /), y = (/ 32.0, 16.0, 8.0, 4.0, 2.0 /), z
+
+    c = multiply(a,b)     ! works with either function definition above
+
+    z = multiply(x,y)     ! element-wise invocation only works with elemental function
+end program funcDemo

Task/Function-definition/Fortran/function-definition-4.f

@@ -0,0 +1,2 @@
+c = multiply(y=b, x=a)   ! the same as multiply(a, b)
+z = multiply(y=x, x=y)   ! the same as multiply(y, x)

Task/Function-definition/Fortran/function-definition-5.f

@@ -0,0 +1,8 @@
+module elemFunc
+contains
+    elemental function multiply(x, y) result(z)
+        real, intent(in) :: x, y
+        real :: z
+        z = x * y
+    end function multiply
+end module elemFunc

Task/Function-definition/Frink/function-definition.frink

@@ -0,0 +1 @@
+multiply[x,y] := x*y

Task/Function-definition/GML/function-definition.gml

@@ -0,0 +1,4 @@
+#define multiply
+a = argument0
+b = argument1
+return(a * b)

Task/Function-definition/Go/function-definition-1.go

@@ -0,0 +1,3 @@
+func multiply(a, b float64) float64 {
+   return a * b
+}

Task/Function-definition/Go/function-definition-2.go

@@ -0,0 +1,4 @@
+func multiply(a, b float64) (z float64) {
+   z = a * b
+   return
+}

Task/Function-definition/Golfscript/function-definition.golf

@@ -0,0 +1 @@
+{*}:multiply;

Task/Function-definition/Groovy/function-definition-1.groovy

@@ -0,0 +1 @@
+def multiply = { x, y -> x * y }

Task/Function-definition/Groovy/function-definition-2.groovy

@@ -0,0 +1 @@
+println "x * y = 20 * 50 = ${multiply 20, 50}"

Task/Function-definition/Haskell/function-definition-1.hs

@@ -0,0 +1 @@
+multiply = (*)

Task/Function-definition/Haskell/function-definition-2.hs

@@ -0,0 +1 @@
+multiply = \ x y -> x*y

Task/Function-definition/Haxe/function-definition.haxe

@@ -0,0 +1,3 @@
+function multiply(x:Float, y:Float):Float{
+   return x * y;
+}

Task/Function-definition/HicEst/function-definition.hicest

@@ -0,0 +1,3 @@
+FUNCTION multiply(a, b)
+   multiply = a * b
+END

Task/Function-definition/IDL/function-definition-1.idl

@@ -0,0 +1,3 @@
+function multiply ,a,b
+  return, a* b
+end

Task/Function-definition/IDL/function-definition-2.idl

@@ -0,0 +1,3 @@
+function multiply ,a,b
+  return, product([a, b])
+end

Task/Function-definition/IDL/function-definition-3.idl

@@ -0,0 +1,3 @@
+function multiply ,a,b
+  return, a # b
+end

Task/Function-definition/Icon/function-definition.icon

@@ -0,0 +1,3 @@
+procedure multiply(a,b)
+return a * b
+end

Task/Function-definition/Inform-6/function-definition.inf

@@ -0,0 +1,3 @@
+[ multiply a b;
+  return a * b;
+];

Task/Function-definition/Inform-7/function-definition.inf

@@ -0,0 +1,2 @@
+To decide which number is (A - number) multiplied by (B - number):
+	decide on A * B.

Task/Function-definition/Io/function-definition.io

@@ -0,0 +1 @@
+multiply := method(a,b,a*b)

Task/Function-definition/J/function-definition-1.j

@@ -0,0 +1 @@
+multiply=: *

Task/Function-definition/J/function-definition-2.j

@@ -0,0 +1,3 @@
+multiply=: dyad define
+  x * y
+)

Task/Function-definition/Java/function-definition.java

@@ -0,0 +1,5 @@
+public class Math
+{
+     public static    int multiply(   int a,    int b) { return a*b; }
+     public static double multiply(double a, double b) { return a*b; }
+}

Task/Function-definition/JavaScript/function-definition-1.js

@@ -0,0 +1 @@
+function multiply(a,b) { return a*b }

Task/Function-definition/JavaScript/function-definition-2.js

@@ -0,0 +1,3 @@
+var multiply = function (a, b) {
+    return a * b;
+};

Task/Function-definition/Joy/function-definition.joy

@@ -0,0 +1 @@
+DEFINE multiply == * .

Task/Function-definition/Julia/function-definition.julia

@@ -0,0 +1,3 @@
+function multiply(a::Number,b::Number)
+  return a*b
+end

Task/Function-definition/Kaya/function-definition.kaya

@@ -0,0 +1,11 @@
+program test;
+
+// A function definition in Kaya:
+Int multiply(Int a, Int b) {
+    return a * b;
+}
+
+// And calling a function:
+Void main() {
+    putStrLn(string( multiply(2, 3) ));
+}

Task/Function-definition/LSE64/function-definition.lse64

@@ -0,0 +1,2 @@
+multiply  : *
+multiply. : *.  # floating point

Task/Function-definition/Liberty-BASIC/function-definition.liberty

@@ -0,0 +1,11 @@
+'     define & call a function
+
+print multiply( 3, 1.23456)
+
+wait
+
+function multiply( m1, m2)
+    multiply =m1 *m2
+end function
+
+end

Task/Function-definition/Locomotive-Basic/function-definition.bas

@@ -0,0 +1,2 @@
+10 DEF FNmultiply(x,y)=x*y
+20 PRINT FNmultiply(2,PI)

Task/Function-definition/Logo/function-definition.logo

@@ -0,0 +1,3 @@
+to multiply :x :y
+  output :x * :y
+end

Task/Function-definition/Lua/function-definition.lua

@@ -0,0 +1,3 @@
+function multiply( a, b )
+    return a * b
+end

Task/Function-definition/Lucid/function-definition.lucid

@@ -0,0 +1 @@
+multiply(x,y) = x * y

Task/Function-definition/M4/function-definition.m4

@@ -0,0 +1,3 @@
+define(`multiply',`eval($1*$2)')
+
+multiply(2,3)

Task/Function-definition/MATLAB/function-definition.m

@@ -0,0 +1,3 @@
+function C = multiply(A,B)
+    C = A*B;
+end