[Question]
  [
## Task
Create a program that calculates the factorial of a number using no built-in factorial functions. Easy? The catch is that you must write your entire program (including testing it) in [haiku](http://en.wikipedia.org/wiki/Haiku) form.
[![Not enough work](https://i.stack.imgur.com/x8DgR.png "It's even harder if you're an asshole who pronounces <> brackets.")](https://xkcd.com/554/)  
You can use as many haikus as you need, but when pronounced, they must follow the 5-7-5 syllable format.
### Scoring
This is a [popularity-contest](/questions/tagged/popularity-contest "show questions tagged 'popularity-contest'"), so you must get the most upvotes to win. Your program must consist of at least one full haiku, and all haikus must be complete.
When reading code, the first line of each haiku will have 5 syllables, the second will have 7, and the third will have 5.
  
[Answer]
# Smalltalk
(evaluate in a workspace; opens a dialog, asks for a number and prints the result on stdout):
```
"in" "this" 'poem,' "you" "must"
"pronounce" "characters" "like" "these:"
"return(^)," "and" "times(*);" "please".
"but" 'never' "in" "here"
"tell" "anyone" "about" "those"
"few" "parentheses".
"otherwise" "these" "words" 
"are" "stupid" "and" "this" "coded" 
"rhyme" "is" "wasted" Time.
"let" "us" "now" "begin" 
"by" "defining," "in" Object
"and" compile: "the" "rhyme:"
'fac: "with" arg"ument"
"to" "compare" arg <"against" 2 ">"
"and" ifTrue: [ ^"return"
"["1] "or" ifFalse: "then"
["return"^ arg *"times" "the" "result"
"of" ("my"self ")getting"
"the" fac:"torial"
"of" "the" "number" arg "minus"-
1 "[(yes," "its" "easy")]'.
("Let" "me" "my"self "ask"
"for" "a" "number," "to" "compute"
"the" fac:"torial"
("by" "opening" "a" 
"nice" Dialog "which" "sends" "a"
request: "asking" "for"
'the Number to use' 
"(which" "is" "(" "treated" ) asNumber)
"then" print "the" "result".
```
I tried to bring in some reflection ("in this poem") and kigo as well.
Also, some western style rhyme elements are included (please->these, time->rhyme); however, being neither native speaker of Japanese, nor of English, forgive any stylistic details ;-)
[Answer]
## Haskell
```
fact :: Int -> Int          -- fact is Int to Int
fact x = product (range x)  -- fact x is product range x
range x = [1..x]            -- range x is 1 [pause] x
```
Haskell education time:
* The `range x` function creates a list of integers from 1 up to the value of `x`.
* The `fact x` function multiplies all the values of the list `range x` together to compute the result.
* The first line says that the `fact` function takes an integer and returns an integer.
[Answer]
# Java - 2 haikus
```
protected static
        int factorial(int n) {
    if (n == 0) {
        return n + 1;
    } return factorial(n
            - 1) * n;}
```
Even when the question isn't [code-golf](/questions/tagged/code-golf "show questions tagged 'code-golf'"), I often catch myself golfing the answer. In this case, I golfed the number of haikus.
I pronounce it so:
> 
> protected static  
> 
> int factorial int n  
> 
> if n is zero
> 
> 
> return n plus one  
> 
> return factorial n  
> 
> minus one times n
> 
> 
> 
---
Test program:
```
class Factorial {                                    // class Factorial
    public static void main(String[]                 // public static void main string
            command_line_run_args) {                 // command line run args
        
        int i = 0;                                   // int i is zero
        while (7 != 0)                               // while seven is not zero
            System.out.                              // System dot out dot
                    println(i + "!"                  // print line i plus not
                            + " = " + factorial(     // plus is plus factorial
                            i += 1));}               // i plus equals 1
    protected static
            int factorial(int n) {
        if (n == 0) {
            return n + 1;
        } return factorial(n
                - 1) * n;}}
```
Note that this program starts outputting `0`s fast; that is a result of overflow. You could easily get larger correct numbers by changing each `int` to `long`.
Standard pronunciations for `System.out.println` and `public static void main(String[] args)` are reflected in the program.
[Answer]
# APL
```
factorial‚Üê{√ó/‚ç≥‚çµ}
```
> 
> Factorial is‚Äî  
> 
>  the product of naturals  
> 
>  up to omega
> 
> 
> 
[Answer]
#  Shakespeare
```
The Products of Love:
A haiku tragedy with
mathy undertones.
Romeo, a man.
Juliet, a maiden fair.
Friar John, a monk.
Act I: A Cycle.
Scene I: Pertinent Values.
[Enter Romeo]
[Enter Friar John]
Romeo: Listen to thy
heart. Thou art thyself.
Friar John: Thou art
as forthright as a songbird.
[Exit Friar John]
[Enter Juliet]
Romeo: Thou art as fair
as a violet.
Scene II: Questioning
Themselves. [Exit Juliet]
[Enter Friar John]
Friar John: Art thou
as just as the sum of me
and a nobleman?
Romeo: If so,
let us proceed to scene III.
[Exit Friar John]
[Enter Juliet]
Romeo: Thou art as good
as the product of
thyself and myself.
Juliet: Thou art as fierce
as the sum of an
eagle and thyself.
We must return to scene II.
Scene III: A Lengthy
Title for a Brief
D√©nouement; Or, The Last Word.
[Exit Friar John]
[Enter Juliet]
Romeo: Open your heart.
[Exit Romeo]
```
An (imagined) test case:
Despite its length, this program just takes a single integer as input and provides a single integer as output. So:
```
6 ‚Üµ 720
7 ‚Üµ 5040
0 ‚Üµ 1    1 ‚Üµ 1
```
("Six, seven-twenty. / Seven, five thousand forty. / Zero, one. One, one.")
[Answer]
# Python 2, 4 Haikus
A complete Python 2 program `haifac.py`. Run as `python haifac.py <n>`
```
#run this full program
import operator as\
op; import sys#tem
#please provide an arg
n = sys.argv[1]
def haifac (n):
    if n < 1:
        return 1#to me at once
    else:#do something else
        return op.mul(
            n, haifac(n - 1))
print haifac(int(n))
```
Pronounciation:
> 
> run this full program   
> 
> import operator as   
> 
> op import system   
>   
> 
> 
> 
> please provide an arg   
> 
> n equals sys arg v 1   
> 
> define hai fac n   
>   
> 
> 
> 
> if n less than 1   
> 
> return 1 to me at once   
> 
> else do something else   
>   
> 
> 
> 
> return op dot mul   
> 
> n hai fac n minus 1   
> 
> print hai fac int n  
>   
> 
> 
> 
> 
[Answer]
## GolfScript, 2 Haikus
```
),{0>},{,,*}*
```
Read as haiku, enumerating each keystroke:
```
#close parenthesis
#comma open-brace zero
#greater-than close-brace
#comma open-brace
#comma comma asterisk
#close-brace asterisk
```
With test case (5 haikus):
```
[1 2 3]4+          #generate the array [1 2 3 4]
{                  #start creating block
),{0>},{,,*}*      #actual factorial code
}%                 #close block and map across array (so that we should have [1! 2! 3! 4!])
[1 2 6]2.3**12++=  #generate the array [1 2 6 24] and check for equality
```
Read as haiku:
```
#open-bracket one
#space two space three close-bracket
#four plus open-brace
#close parenthesis
#comma open-brace zero
#greater-than close-brace
#comma open-brace
#comma comma asterisk
#close-brace asterisk
#close-brace percent-sign
#open-bracket one space two
#space six close-bracket
#two period three
#asterisk asterisk one
#two plus plus equals
```
[Answer]
# [Whitespace](http://compsoc.dur.ac.uk/whitespace/download.php)
This makes uses of one of the [most famous](https://whrarchives.wordpress.com/2011/09/01/a-contrarian-view-of-bashos-frog/) *haiku*s, and [a great deal](http://www.ahapoetry.com/AHI%20frog%20art.html) has been written about it.
No idea why nobody has done this before, [it doesn't even take any effort!](http://compsoc.dur.ac.uk/whitespace/examples.php)
First of all, before reading the poem, I want you to lean back, relax, and enjoy the tranquility created by the great void surrounding the poem. It emphasizes the pond, surrounded by a vast landscape.
```
Âè§Ê±†„ÇÑ    
ËõôÈ£õ„Å≥„Åì„ÇÄ               
Ê∞¥„ÅÆÈü≥             
```
[source code on filebin](http://filebin.ca/1tdvROHWP8cN)
In case you do not speak Japanese, this [is pronounced](http://en.wikipedia.org/wiki/Hepburn_romanization) as follows:
> 
> fu ru i ke ya
> 
> 
> ka wa zu to bi ko mu
> 
> 
> mi zu no o to
> 
> 
> 
Naturally, it is counted by morae. The [*kireji* is „ÇÑ (*ya*)](http://kogumaza.jp/1410haikujihyuu.html), the [*kigo* (seasonal reference) is Ëõô (*kawazu*, frog, -> spring)](http://kobun.weblio.jp/content/%E3%81%B5%E3%82%8B%E3%81%84%E3%81%91%E3%82%84).
Using the linux interpreter from the official page, you can use it like this:
> 
> $ echo 5 | ./wspace .ws
> 
> 
> 
[Answer]
# PHP, 4 haikus
*All-in-rhyme* haikus!
```
function haiku($can) { // function haiku can (5)
    if ($can == 1) // if can is equal to one (7)
        return ++$stun; // return increase stun (5)
    if ($can == 0) { // if can equals ou (5)
        echo "It is one, you know! "; //echo "It is one, you know! " (7)
        return 1+$blow; } //return one plus blow (5)
    if ($can > $fun) { //if can exceeds fun (5)
        return haiku($can-1) //return haiku can less one (7)
            *$can; }} //multiplied by can (5)
if (null == $knee) { // if null equals knee (5)
    $free=0+3; // free equals zero plus three (7)
    echo haiku($free); } // echo haiku free (5)
```
[Answer]
# Forth
```
: fugu 1              \ colon fugu one                = 5
swap 1 + 1 ?do        \ swap one plus one question do = 7
i * loop ;            \ eye star loop semi            = 5
```
*Fugu* is the function and my attempt at *kigo*: blowfish is a winter reference. I intend `?do` to be *kireji*, the turning point, before the counted loop.
[Answer]
# Mathematica
```
f[x_]:=     (* f of x defined *)
 x f[x-1]   (* x times f of x less 1 *)
f[1]=1      (* Mogami River *) 
```
Pedants may read the last line as "f of 1 is 1", but I couldn't resist the shout-out to Basho.
### Testing:
```
Table[f[n],     (* Table f of n *)
 {n, 1, 10, 1}] (* n from 1 to 10 by 1 *)
ListLogPlot[%]  (* ListLogPlot output *)
```
### Returning:
```
(1, 2, 6, 24, 120, 720, 5040, 40320, 362880, 3628800)
```
![log plot of values](https://i.stack.imgur.com/erXAA.jpg)
### Linguistic Distinctiveness Bonus Haiku (inspired by @cormullion)
```
Rewrite any term
High-level functions abound ‚Äî
Mathematica
```
[Answer]
## Batch
```
@set /a t=1 &^
for /L %%a in (2, 1, %1) ^
do @set /a t*=%%a
```
**Pronunciation**; ignores mathematical expressions as well as these symbols `@ / % ^ , ( )`:
> 
> set a t 1 and  
>  for L a in 2 1 1  
>  do set a t a
> 
> 
> 
Note; this calculates the factorial, it doesn't output it - the variable `t` contains the factorial.
The following Haiku / code can be appended to the same batch file to output the factorial (the `|`'s are pronounced as pipe):
```
@echo %t% ||^
When will you learn, unclemeat ^
Why must you use Batch?
```
[Answer]
# Clojure
```
(->> *command-line-args*                ; thrush com-mand line args
  seq last read-string range (map inc)  ; seq last read string range map inc
  (reduce *) println)                   ; re-duce times print-lin
```
[Answer]
# F#
```
let fact n =
    [1..n] |>
    Seq.fold (*) 1
```
> 
> let fact of n be  
> 
>  from one up to n, apply  
> 
>  Seq dot fold star one
> 
> 
> 
[Answer]
### newLISP
The parentheses are not pronounced: 
```
(define (fac n (so))            ; define fac n so 
(if (= n 0) 1                   ; if equals n zero 1
(* n (fac (dec n)))))           ; times n fac dec n
(for (n 0 10)                   ; for n zero ten
; let's test from zero to ten
(println (fac n thus)))         ; printline fac n thus
```
> 
> Lisp code consists of
> 
> 
> numerous parentheses
> 
> 
> and a few functions
> 
> 
> 
[Answer]
# [LiveScript](http://livescript.net/)
This one's medieval:
```
prelude = ^^ do                       # prelude is clone do
  require \prelude-ls                 # require prelude dash ls
{ product } = prelude                 # product is prelude
story = (ah) ->                       # story is ah such:
  ones-misery = (one) ->              # one's misery is one such
    let death = product               # let death be product
      fight = [1 to one]              # fight is one to one
      why = (one) -> death <| fight   # why is one such death take fight
  ones-misery ah                      # one's misery ah
room = console.log                    # room is console log
room <| (story 10)!                   # room take story three bang
[null of { use : this }]              # no of use is this
```
Prints `3628800`, which is `10!`. It's a little roundabout: The function `story` returns a function `ones-misery`, which always returns the answer. It's artsier that way.
No filler comments or unnecessary strings!
---
Bonus debugging story:
> 
> I burst out laughing
>    
> when informed that a bug was
>    
> "`death` is `undefined`"
> 
> 
> 
[Answer]
## Haskell
This one will be a **rhyming** haiku!
```
fact 0=1                     --fact zero is one
fact ton=ton * (fact stun)   --fact ton is ton times fact stun
        where stun=pred ton  --where stun is pred ton
```
Yeah!
Note: Pred means the previous number. Also in haskell, you can have multiple definitions of a function, and the first one that makes sense is used.
[Answer]
**Ruby - One Haiku**
```
ARGV.first.to_i.
 tap do |please| puts 1.upto(
 please ).inject( :*) end
```
Read (ignoring punctuation, but including one emoticon) like this:
```
 arg vee first to i
   tap do please puts one up to
 please inject smile end
```
[Answer]
# Perl
```
$r = 1; for(1           # r gets one for one
.. pop @ARGV) { $r *=   # to pop arg v r splat gets
$_; } print $r;         # the default print r
```
Toss this into a file named `f.pl`
And the output:
```
$ perl f.pl 3
6$ perl f.pl 1-1
1$ perl f.pl 10
3628800$ 
```
Which is read as:
```
perl f p l three
perl f p l one less one
perl f p l ten
```
[Answer]
In SML:
```
fun fact 0 = 1
  | fact n = n*fact(n-1)
  ;
```
read as:
```
"fun fact 0 is one,
bar that, fact n is n times
fact of n less one"
```
[Answer]
## Perl
I know it's against the rules to use ready-made functions, but here's what I get.
Imagine your task is to instruct an over-sized rodent:
```
use Math::BigRat; use
feature 'say'; use warnings; say
new Math::BigRat($_)->bfac
```
I can only guess what the last word means and how it's pronounced, but I assure you it is one syllable. Apparently he doesn't understand what you want from him, so you have to elaborate (easing on quality standards as you loose patience):
```
use Math::BaseConvert
':all'; no strict subs; no warnings;
reset and say fact($_)
```
still to no avail. Then you have to explain it in plain English:
```
no strict; no warnings;
use Math::Combinatorics;
say factorial($_)
```
What happened next I don't know, but code is valid:
```
perl -nE 'use Math::BigRat; use feature "say"; use warnings; say new Math::BigRat($_)->bfac'
42
1405006117752879898543142606244511569936384000000000
```
and
```
perl -nE 'use Math::BaseConvert ":all"; no strict subs; no warnings; reset and say fact($_)'
33
8683317618811886495518194401280000000
```
and 
```
perl -nE 'no strict; no warnings; use Math::Combinatorics; say factorial($_)'
16
20922789888000
```
[Answer]
### Python
```
lambda n: reduce(
    lambda a, b: a * b,
    range(1, n), n)
```
The way I read it:
> 
> 
> ```
> lambda n: reduce
> lambda a b: a times b
> range 1 to n, n
> 
> ```
> 
> 
`
[Answer]
**C**
```
#include <std\
io.h> 
#include \
<stdlib.h>
int main(int argc
 , char** argv)
{   // iteratively
    // compute factorial here
long int n = \
0, i \
= 0, r = \
1 /*
product starts at one*/;
if (argc 
> 1) { n = 
strtol(argv[\
1], NULL, 10)
; if (n 
< 0) {
       printf("Arg must\
       be >= 0\n");
       exit(-
    1);}
} i = 
n;
while (i) { r 
= r * i;
    i
--;
} /* print
the result*/ printf(
"%d factorial\
equals %d\
\n", n
, r);
/*done*/}
```
**Pronounciation:**
pound include standard  
I/O dot h pound include  
standard lib dot h  
int main int arg c  
comma char star star arg v  
open brace comment  
iteratively  
compute factorial here  
long int n equals  
 
zero comma i  
equals zero comma r  
equals one comment  
product starts at one  
semicolon if arg c  
is greater than one  
open brace n is  
str-to-l of arg v sub  
one comma NULL comma ten  
semicolon if  
 
n less than zero begin  
printf arg must  
 
be greater than or  
 
equal to zero backslash  
n semicolon  
 
exit negative  
 
one semicolon end brace  
end brace i equals  
 
n semicolon  
while i open brace r  
equals r times i  
semicolon i  
decrement semicolon  
close brace comment print  
the result printf  
percent d factorial  
 
equals percent d  
 
whack n comma n  
 
comma r semicolon  
comment done end brace  
[Answer]
# Python
Uses a single haiku to do the job!
```
f = lambda x:   \ #  f is lambda x:
    0**x or x * \ #    zero pow x, or x times
    f(x-1)        #    f(x minus 1)
```
This defines a recursive lambda which calculates the factorial - `0**x` handles the case of 0 as it evaluates to `1`.
[Answer]
## C# - 3 haikus
I removed the usual C# using, namespace and class definition clutter, which would be a 4th haiku.
```
public static void
Main(){int num = Convert.
ToInt32
(Console.ReadLine());
 Console.WriteLine(num ==
 0 ? 1 :
Enumerable.
Range(1, num).Aggregate
((i, j) => i * j));}
```
which I read as
```
public static void 
Main int num equals Convert
To int thirty-two
Console dot Read line
Console Write line num equals
zero? then one, else
Enumerable
Range 1 to num aggregate
i j i times j
```
[Answer]
## Haskell
```
module Haiku where          -- read literally.
fac x = let in do           -- = is read as 'equals'
product [1..x]              -- product one to x
```
note that the module .. where is added automatically to any Haskell code without it at compilation, so not writing it is practically cheating.
[Answer]
**JAVA:**
In response to the question and to the Dwaiku (Double-Haiku or whatever you wanna call it) posted by Quincunx in Java, here's the correct Haiku:
```
public static int factorial(int n) {
   return (n==0) ? (n+1) : (factorial(n-1) * n);
}
```
[Answer]
### Javascript - Two Haikus
```
function factor (a) {          // function factor a
  if(!a){ return 1 ||          // if not a return 1 or
    a & 17}                    // a and seventeen
  else if (a + 1){             // else if a plus one 
    return a * factor          // return a into factor
    (a + ( - 1) )  }}          // a plus minus one 
```
I am not a native speaker. So, I used a dictionary to count the syllables. Hopefully, it's good enough. Any feedback is welcome :)
[Answer]
**Powershell, 2 Haikus**
```
function facto ($num){    # function facto num
$i = 1; 1..$num|          # i equals one; i to num
foreach { $i =            # for each i equals
$i * $_}; write $i}       # i times this write i
$answer = facto $args[    # answer equals facto args
0]; write $answer         # zero write answer
```
[Answer]
Are we allowed to use filler?
Python 2 haikus: 
```
number = num + 1
a = 13 + 4
b = 14
nuum = len([1])
for i in range(1, number):
    nuum *= i
```
]