Logo

Programming-Idioms

# 4 Create a function
Create a function which returns the square of an integer
New implementation

Be concise.

Be useful.

All contributions dictatorially edited by webmasters to match personal tastes.

Please do not paste any copyright violating material.

Please try to avoid dependencies to third-party libraries and frameworks.

Other implementations 
function Square (X : Integer) return Integer is
begin
   return X * X;
end Square;
int square(int x){
  return x*x;
}
let square x = x*x
(defn square [x]
  (* x x))
auto square = [] (int x) {
    return x * x;
};
int square(int x){
  return x*x;
}
int square(int x) { return x * x; }
template <typename T>
T square(T x) { return x * x; }
void Square(ref int x)
{
    x = x * x;
}
int Square(int x)
{
    return x * x;
}
double Square(int value) => System.Math.Pow(value, 2);
int Square(int x) => (int)Math.Pow(x, 2);
int square(int x) {
   return x*x;
}
alias fun = (in a){return a * a;};
int square(int x) => x * x;
@spec square(integer) :: integer
def square(x) when is_integer(x), do: x*x
-spec square(integer()) -> integer().
square(X) when is_integer(X) -> X * X.
module foo
  implicit none
contains
  function square(i) result(res)
    integer, intent(in) :: i
    integer :: res
    res = i * i
  end function square
end module foo

func square(x int) int {
  return x*x
}
int square(int x){
  return x*x
}
square x = x^2

square x = x**2
square x = x * x
const square = (x) => x * x;
const square = n => n**2
function square(x) { 
	return x * x;
}
const square = (number) => Math.pow(number, 2);
<T extends Number> double square(T x) {
    double y = x.doubleValue();
    return y * y;
}
interface F<T extends Number> {
    double get(T x);
}
F square = x -> {
    double y = x.doubleValue();
    return y * y;
};
int square(int x){
  return x*x;
}
import java.math.BigInteger;
BigInteger square(BigInteger a) {
    return a.multiply(a);
}
import java.util.function.Function;
Function<Double, ?> square = x -> x * x;
Function<Integer,Integer> squareFunction = x -> x * x;
fun square(x: Int) = x * x
(defun square (x)
  (* x x))
function square(x)
	return x*x
end
int square(int x) {
  return x*x;
}
declare(strict_types=1);
function square(int $x): int
{
    return $x * $x;
}

// square(4) -> 16
// square(3.4) -> Uncaught TypeError: Argument 1 passed to square() must be of the type int, float given
Function square(x: Integer): Integer;
Begin
  Result := x*x;
End;
sub square {
    my ($i) = @_;
    return $i ** 2;
}
def square(value: int) -> int:
    return value ** 2
def square(x):
    return x**2
def square(x):
    return x*x
class CallableClass:
    def __call__(self, value):
        return value ** 2
square = CallableClass()
x = square(123)
square = lambda n: n ** 2
def square(x)
  x*x
end
def square(x) = x*x
fn square(x : u32) -> u32 { x * x }
def square(x:Int): Int = x*x
(define (square x)
    (* x x))
(define square
    (lambda (x)
        (* x x)))
[:anInteger | anInteger squared]
Function Square(x As Integer) As Integer
    Return x * x
End Function
Function Square(x As Integer) As Double
    Return x ^ 2
End Function

Preview