5! = 5 * 4 * 3 * 2 * 1 = 120

{,1{)*}/}:f

# pseudocode: f(n){c=1;while(n>1){c*=n;n--};return c}
{:n;1:c;{n 1>}{n c*:c;n 1-:n;}while c}:f

# pseudocode: f(n){return n==0?n*f(n-1):1}
{:n{n.(f*}1if}:f # taking advantage of the tokeniser

{,{*}*}:f

{,{)}%{*}*}:f

{).,{)}%{*}*/}:f

{.{1{.@*(.}do;}{)}if}:f

{1.!!{{.@*(.}do}*+}:f
{.!{1{.@*(.}do}or+}:f
{.{1{.@*(.}do}1if+}:f

{.!{.)f*0}or+}:f
{.{.)f*0}1if+}:f
{.{.(f*}{)}if}:f

f n=product[1..n]

f=lambda x:0**x or x*f(x-1)

×/∘⍳

×/∘⍳ 5
120

f←×/∘⍳

f=:*/@:>:@i.

f 0
 1
 f 5
 120
  f 125x
 1882677176888926099743767702491600857595403
 6487149242588759823150835315633161359886688
 2932889495923133646405445930057740630161919
 3413805978188834575585470555243263755650071
 31770880000000000000000000000000000000

{),(){*}/}:!             # happy robot version {*}/

{),()+{*}*}:!

~),()+{*}*

0!

1

125!

188267717688892609974376770249160085759540364871492425887598231508353156331613598866882932889495923133646405445930057740630161919341380597818883457558547055524326375565007131770880000000000000000000000000000000

$f={[*]1..$_}

f=@(x)prod(1:x)

>> f(0)
ans =
     1
>> f(4)
ans =
    24
>> tic,f(125),toc
ans =
  1.8827e+209
Elapsed time is 0.000380 seconds.

f=lambda x:x/~x+1or x*f(x-1)

/f{1 exch -1 1{mul}for}def

GS> 0 f =
1
GS> 1 f =
1
GS> 8 f =
40320

GS> 0{1 exch -1 1{mul}for}def
GS> 8 0 load exec =
40320

function f(n)!n||n*f(n-1)

f=(n)->!n||n*f(n-1)

def f(n)(1..n).inject 1,:*end

f(0) -> 1
f(5) -> 120

f=->n{n>1?n*f[n-1]:1}

irb(main):009:0> f=->n{n>1?n*f[n-1]:1}
=> #<Proc:0x25a6d48@(irb):9 (lambda)>
irb(main):010:0> f[125]
=> 18826771768889260997437677024916008575954036487149242588759823150835315633161
35988668829328894959231336464054459300577406301619193413805978188834575585470555
24326375565007131770880000000000000000000000000000000

:p

:    % generate list 1,2,3,...,i, where i is an implicit input
p    % calculate the product of of all the list entries (works on an empty list too)

BigInteger f(int n){return n<2?BigInteger.ONE:new BigInteger(""+n).multiply(f(n-1));}

let f n=Seq.fold(*)1{1..n}

double f(int n){return n<2?1:n*f(n-1);}

filter f{if($_){$_*(--$_|f}else{1}}

> 0,5,125|f
1
120
1,88267717688893E+209

def f(x:BigInt)=(BigInt(1)to x).product

filter f($x){if(!$x){1}else{$x*(f($x-1))}}

PS C:> f 0
1
PS C:> f 5
120
PS C:> f 1
1
PS C:> f 125
1.88267717688893E+209

0:#v_# 1#<$v *<
    >:1-:#^_$>:#^_$

555**   0:#v_# 1#<$v *<
            >:1-:#^_$>:#^_$    .@

0   0:#v_# 1#<$v *<
        >:1-:#^_$>:#^_$    .@

T f(T)(T n){return n < 2 ? 1 : n * f(n - 1);}

T f(T)(T n)
{
    return n < 2 ? 1 : n * f(n - 1);
}

template F(int n){static if(n<2)enum F=1;else enum F=n*F!(n-1);}

template F(int n)
{
    static if(n < 2)
        enum F = 1;
    else
        enum F = n * F!(n - 1);
}

*/>:i.

f(a){a=a>0?f(a-1)*a:1;}

f(a){return a>0?f(a-1)*a:1;}

*/1.+!

*/1.+!125.
1.882677e+209

,[>+>+>>>+<<<<<-]>>-<[[>[->+>+<<]>>[-<<+>>]<<<-]>>>>[<<<<+>>>>-]<<<<->[-]>[<+>-]<<[>>>>+>+<<<<<-]>>>>>[<<<<<+>>>>>-]<<<<<-]>.

def f(n):return n and n*f(n-1) or 1

def f(n):return n*f(n-1) if n else 1

{($p=1)..$_-ge1|%{$p*=$_};$p}

> &{($p=1).."$args"-ge1|%{$p*=$_};$p} 125
1,88267717688893E+209