[Question]
  [
The natural numbers including 0 are formally defined as sets, in the [following way](https://en.wikipedia.org/wiki/Set-theoretic_definition_of_natural_numbers#Contemporary_standard):
* Number 0 is defined as the empty set, {}
* For *n* ≥ 0, number *n*+1 is defined as *n* ∪ {*n*}.
As a consequence, *n* = {0, 1, ..., *n*-1}.
The first numbers, defined by this procedure, are:
* 0 = {}
* 1 = {{}}
* 2 = {{}, {{}}}
* 3 = {{}, {{}}, {{}, {{}}}}
# Challenge
Given `n`, output its representation as a set.
# Rules
The output can consistently use any **bracket** character such as `{}`, `[]`, `()` or `<>`. Arbitrary characters (such as `01`) are not allowed.
Instead of a comma as above, the **separator** can be any punctuation sign; or it may be inexistent.
**Spaces** (not newlines) may be included arbitrarily and inconsistently.
For example, number 2 with square brackets and semicolon as separator is `[[]; [[]]]`, or equivalently `[ [ ]; [ [ ] ] ]`, or even `[ [ ] ;[ []]]`
The **order** in which elements of a set are specified doesn't matter. So you can use any order in the representation. For example, these are some valid outputs for `3`:
```
{{},{{}},{{},{{}}}}
{{{}},{{},{{}}},{}}
{{{}},{{{}},{}},{}}
```
You can write a **program or function**. Output may be a string or, if using a function, you may return a nested list or array whose string representation conforms to the above.
# Test cases
```
0  ->  {}
1  ->  {{}}
2  ->  {{},{{}}}
3  ->  {{},{{}},{{},{{}}}}
4  ->  {{},{{}},{{},{{}}},{{},{{}},{{},{{}}}}}
5  ->  {{},{{}},{{},{{}}},{{},{{}},{{},{{}}}},{{},{{}},{{},{{}}},{{},{{}},{{},{{}}}}}}
6  ->  {{},{{}},{{},{{}}},{{},{{}},{{},{{}}}},{{},{{}},{{},{{}}},{{},{{}},{{},{{}}}}},{{},{{}},{{},{{}}},{{},{{}},{{},{{}}}},{{},{{}},{{},{{}}},{{},{{}},{{},{{}}}}}}}
7  ->  {{},{{}},{{},{{}}},{{},{{}},{{},{{}}}},{{},{{}},{{},{{}}},{{},{{}},{{},{{}}}}},{{},{{}},{{},{{}}},{{},{{}},{{},{{}}}},{{},{{}},{{},{{}}},{{},{{}},{{},{{}}}}}},{{},{{}},{{},{{}}},{{},{{}},{{},{{}}}},{{},{{}},{{},{{}}},{{},{{}},{{},{{}}}}},{{},{{}},{{},{{}}},{{},{{}},{{},{{}}}},{{},{{}},{{},{{}}},{{},{{}},{{},{{}}}}}}}}
```
  
[Answer]
# Python 2, 26 bytes
```
f=lambda n:map(f,range(n))
```
Test it on [Ideone](http://ideone.com/8Gde07).
[Answer]
# [Jelly](https://github.com/DennisMitchell/jelly), 3 [bytes](https://github.com/DennisMitchell/jelly/wiki/Code-page)
```
Ḷß€
```
This is a monadic link. [Try it online!](http://jelly.tryitonline.net/#code=4bi2w5_igqwKMHI3w4figqzFkuG5mOKCrFk&input=)
### How it works
Each natural number is the set of all previous natural numbers, i.e., **n = {0, …, n-1}**. Since there are no natural numbers preceding **0**, we have that **0 = {}**.
```
Ḷß€  Monadic link. Argument: n (natural number)
Ḷ    Unlength; yield [0, ..., n-1].
 ß€  Recursively map this link over the range.
```
[Answer]
# JavaScript (ES6), 32 bytes
```
f=n=>[...Array(n).keys()].map(f)
```
Simple enough.
[Answer]
# [Perl 6](https://perl6.org), 16 bytes
```
{({@_}…*)[$_]}
```
Returns nested data structure.
## Example:
```
say {({@_}…*)[$_]}( 4 );
# [[] [[]] [[] [[]]] [[] [[]] [[] [[]]]]]
```
## Explanation:
```
{   # lambda with implicit parameter ｢$_｣
  (
    # produce a lazy infinite sequence of all results
    {       # lambda with implicit parameter ｢@_｣
      @_    # array containing all previously seen values in the sequence
    }
    …       # keep repeating that block until:
    *       # Whatever ( never stop )
  )[ $_ ]   # use the outer block's argument to index into the sequence
}
```
[Answer]
# Haskell, ~~32~~ 27 bytes
```
p n='{':(p=<<[0..n-1])++"}"
```
[Try it on Ideone.](https://ideone.com/2gcgQD)
[Answer]
# Ruby, ~~27~~ 21 bytes
I'm new to ruby golfing, but here goes nothing. *Thanks to Jordan for saving 6 bytes!*
```
f=->s{(0...s).map &f}
```
This is a recursive function `f` (a proc, to be specific) and takes an argument `s`. It maps the proc `f` over `0...s`, which is the range `[0, s)`.
[Answer]
# [05AB1E](http://github.com/Adriandmen/05AB1E), ~~8~~ 7 bytes
```
)IF)©`®
```
**Explanation**
```
)         # wrap stack in a list, as stack is empty this becomes the empty list []
 IF       # input number of times do:
   )      # wrap stack in list
    ©     # store a copy of the list in the register
     `    # flatten the list
      ®   # push the copy from the register
          # implicitly print top value of stack after the last loop iteration
```
[Try it online!](http://05ab1e.tryitonline.net/#code=KUlGKcKpYMKufQ&input=Mw)
Saved 1 byte thanks to Adnan.
[Answer]
# [CJam](http://sourceforge.net/projects/cjam/), 14 bytes
```
"[]"{_)@\]}ri*
```
[Try it online!](http://cjam.tryitonline.net/#code=IltdIntfKUBcXX1yaSo&input=Mw)
### Explanation
```
"[]"            e# Push this string. It is the representation of 0, and also serves
                e# to initialize
    {     }ri*  e# Repeat this block as many times as the input number
     _          e# Duplicate
      )         e# Uncons: split into array without the last element, and last element
       @\       e# Rotate, swap
         ]      e# Pack stack contents into an array
                e# Implicitly display
```
In each iteration, the block builds the representation of a number from that of the preceding one. To illustrate, let's consider the second iteration, where the representation of number `2` is built from that of `1`, which is the string `"[[]]"`.
1. The stack contains `"[[]]"`
2. After statement `_` (duplicate) it contains `"[[]]"`, `"[[]]"`
3. After statement `)` (uncons) it contains `"[[]]"`, `"[[]"`, `"]"`
4. After statement `@` (rotate) it contains `"[[]"`, `"]"`, `"[[]]"`
5. After statement `\` (swap) it contains `"[[]"`, `"[[]]"`, `"]"`
6. After statement `]` (pack into array) it contains `["[[]" "[[]]" "]"]`, which would be displayed as the string `"[[][[]]]"`.
[Answer]
# Cheddar, 17 bytes
```
n f->(|>n).map(f)
```
Short recursion + Short range + Short iteration = A challenge where cheddar does very well
# Non-competing, 11 bytes
```
n f->|>n=>f
```
The `=>` operator was added after this challenge was released making this answer non-competing.
This may look confusing but let me simplify it:
```
n f -> |> n => f
```
basically `n` is the input and `f` is the function itself. `|>n` generates [0, n) and `=>` maps that over `f`.
[Answer]
# Mathematica, 14 bytes
```
Array[#0,#,0]&
```
[Answer]
# Pyth, 4 bytes
```
LyMb
```
[Test suite](https://pyth.herokuapp.com/?code=LyMby&test_suite=1&test_suite_input=0%0A1%0A2%0A3&debug=0)
`L`: Define the function `y` with input `b`
`yMb`: `y` mapped over the range `0, 1, ..., b-1`
On the input 0, this map returns `[]`. Otherwise, it returns `y` mapped over all numbers up to `b`.
[Answer]
# [MATL](http://github.com/lmendo/MATL), 13 bytes
```
Xhi:"tY:Xh]&D
```
[Try it online!](http://matl.tryitonline.net/#code=WGhpOiJ0WTpYaF0mRA&input=Mw)
### Explanation
```
Xh              % Concatenate the stack contents into cell array. Since the stack
                % is empty, this produces the empty cell array, {}
  i:"     ]     % Take input number. Repeat that many times
     t          % Duplicate the cell array that is at the top of the stack
      Y:        % Unbox it, i.e., push its contents onto the stack
        Xh      % Concatenate the stack contents into a cell array
           &D   % String representation. Implicitly display
```
[Answer]
# Perl, 27 bytes
Includes +1 for `-p`
Many different methods all seem to end up as either 27 or 28 bytes. e.g.
```
#!/usr/bin/perl -p
$\=$_="{@F}"for@F[0..$_]}{
```
The best I could find is
```
#!/usr/bin/perl -p
s/./{$_/ for($\="{}")x$_}{
```
since on older perls you can drop the space before the `for` and get 26 bytes
[Answer]
# [Husk](https://github.com/barbuz/Husk), 10 bytes
```
`:'}:'{ṁ₀ŀ
```
[Try it online!](https://tio.run/##yygtzv7/P8FKvdZKvfrhzsZHTQ1HG/7//28CAA "Husk – Try It Online")
```
`:'}:'{ṁ₀ŀ
         ŀ  Range [0, n)
       ṁ₀   For all numbers in that range, run this function on them
       ṁ    Then concatenate those representations together
    :'{     Prepend '{'
`:'}        Append '}'
```
[Answer]
# Mathematica, 31 bytes
Straightforwardly implements the definition as a nested list. Uses an unnamed function that recursively calls itself using `#0`.
```
If[#<1,{},Join[t=#0[#-1],{t}]]&
```
[Answer]
## [Retina](http://github.com/mbuettner/retina), ~~24~~ 18 bytes
```
.+
$*1<>
+`1<
<<$'
```
[Try it online!](http://retina.tryitonline.net/#code=JShHYAouKwokKjE8PgorYDE8Cjw8JCc&input=MAoxCjIKMwo0CjU) (The first line enables a linefeed-separated test suite.)
### Explanation
```
.+
$*1<>
```
This converts the input to unary and appends `<>`, the representation of `0`.
```
+`1<
<<$'
```
Here, the `+` indicates that this substitution should be run in a loop until the string stops changing. It's easier to explain this by going through the individual steps I took golfing it down. Let's with this version of the substitution:
```
1<(.*)>
<<$1>$1>
```
This matches the last `1` of the unary representation of the remaining input (to remove it and decrement the input), as well as the contents of the current set at the end. This is then replaced with a new set containing the previous one as well as its contents. However, we can notice that `$1` is followed by `>` in both cases and hence we can include it in the capture itself and omit it from the substitution pattern. That leads to the form
```
1<(.*)
<<$1$1
```
However, now we can observe that `(.*)` just captures the suffix of the string after `1<` and we even reinsert this suffix at the end with `$1`. Since the substitution syntax gives us a way to refer to the part of a string *after* a match with `$'` we can simply omit both of those parts and end up with the version used in the answer:
```
1<
<<$'
```
[Answer]
# [Underload](https://github.com/catseye/stringie), 14 bytes
```
((:a*)~^()~^a)
```
[Try it online!](https://tio.run/##K81LSS3KyU9M@a9hpWWlpflfQ8MqUUuzLk4DiBM1/8cF/wcA "Underload – Try It Online")
Underload full programs can't take input via any of our defined methods, so this is a function that takes input from the stack as a Church numeral (the normal way to define integers in Underload), and produces output to the stack as a string.
The `(…)` grouping markers are required to make this a function (reusable) rather than a snippet (only usable once). The wrapper in the TIO link calls the function in question destructively using `^`, but it could be reused via making a copy of it and only consuming one of the copies when calling it. It also provides input to the program (here, `(:*:*)`, i.e. 4), and prints the output using `S`.
## Explanation
Underload's surprisingly suited for this task as Turing tarpits go, having such useful primitives as "copy" and "surround with parentheses". (Somehow, Underload, normally a very verbose language, is beating Mathematica, normally a language which wins due to having a huge set of builtins, via having more appropriate builtins!) Here's how the program works:
```
((:a*)~^()~^a)
(            )   Make a snippet into a function
 (   )~^         Exponentiate the following function by the top of stack:
  :                Copy the top stack element
   a               Surround the copy in parentheses
    *              Append the copy to the original, popping the copy
          ~^     Run the resulting function, with the following argument on its stack:
        ()         Empty string
            a    Surround the result in parentheses
```
Function exponentiation effectively causes the steps of the function to repeat that many times, so, e.g., `(:a*)`³ would be `(:a*:a*:a*)`. That's the idiomatic way to write a loop that repeats a given number of times in Underload. (You can note that the `~^` is described two different ways above; that's because integers in Underload are defined *as* function exponentiation specialised to that integer, so in order to do a function exponentiation, you simply try to execute an integer as though it were a function.)
[Answer]
# [Pari/GP](http://pari.math.u-bordeaux.fr/), 23 bytes
```
f(n)=[f(i)|i<-[0..n-1]]
```
[Try it online!](https://tio.run/##K0gsytRNL/j/P00jT9M2Ok0jU7Mm00Y32kBPL0/XMDb2f1p@kUaegq2CgY6CqY5CQVFmXgmQr6SgawckQJo0Nf8DAA "Pari/GP – Try It Online")
[Answer]
# APL(NARS), 15 chars, 30 bytes
```
{⍵=0:⍬⋄∇¨¯1+⍳⍵}
```
test:
```
  f←{⍵=0:⍬⋄∇¨¯1+⍳⍵}
  o←⎕fmt
  o f 0
┌0─┐
│ 0│
└~─┘
  o f 1
┌1───┐
│┌0─┐│
││ 0││
│└~─┘2
└∊───┘
  o f 2
┌2──────────┐
│┌0─┐ ┌1───┐│
││ 0│ │┌0─┐││
│└~─┘ ││ 0│││
│     │└~─┘2│
│     └∊───┘3
└∊──────────┘
  o f 3
┌3────────────────────────┐
│┌0─┐ ┌1───┐ ┌2──────────┐│
││ 0│ │┌0─┐│ │┌0─┐ ┌1───┐││
│└~─┘ ││ 0││ ││ 0│ │┌0─┐│││
│     │└~─┘2 │└~─┘ ││ 0││││
│     └∊───┘ │     │└~─┘2││
│            │     └∊───┘3│
│            └∊──────────┘4
└∊────────────────────────┘
  o f 4
┌4────────────────────────────────────────────────────┐
│┌0─┐ ┌1───┐ ┌2──────────┐ ┌3────────────────────────┐│
││ 0│ │┌0─┐│ │┌0─┐ ┌1───┐│ │┌0─┐ ┌1───┐ ┌2──────────┐││
│└~─┘ ││ 0││ ││ 0│ │┌0─┐││ ││ 0│ │┌0─┐│ │┌0─┐ ┌1───┐│││
│     │└~─┘2 │└~─┘ ││ 0│││ │└~─┘ ││ 0││ ││ 0│ │┌0─┐││││
│     └∊───┘ │     │└~─┘2│ │     │└~─┘2 │└~─┘ ││ 0│││││
│            │     └∊───┘3 │     └∊───┘ │     │└~─┘2│││
│            └∊──────────┘ │            │     └∊───┘3││
│                          │            └∊──────────┘4│
│                          └∊────────────────────────┘5
└∊────────────────────────────────────────────────────┘
```
I don't know if this would be accepted...
Zilde is ⍬ here it represent the void set {}
if I want print the Zilde element or one element full of Zilde, and Zilde enclosed
all what happen is print nothing...
so for see Zilde one has to define one function I call it o (`o←⎕fmt`)
I do not insert in the count because the element and its structure exist
even if the sys not print it...It is possible if io is 0
```
{⍵=0:⍬⋄∇¨⍳⍵}
```
could be 12 characters solution too...
[Answer]
# [Pip](https://github.com/dloscutoff/pip) `-p`, 4 bytes
```
fM,a
```
[Try it online!](https://tio.run/##K8gs@P8/zVcn8f///7oF/40B "Pip – Try It Online")
The basic recursive approach works well in Pip:
```
f     The main function, i.e. the whole program treated as a function
 M    mapped to
  ,a  range(argument)
```
The result is a nested list, which is printed using square brackets thanks to the `-p` flag.
[Answer]
# [Raku](https://github.com/nxadm/rakudo-pkg), ~~17~~ 15 bytes
```
(),{|$_,$_}...*
```
[Try it online!](https://tio.run/##K0gtyjH7/z@3UsEh0VZDU6e6RiVeRyW@Vk9PT8v6f3EiSDw6PbUk9r8pAA "Perl 6 – Try It Online")
An anonymous lazy list. You can assign it to a variable like:
`my @list = (),{|$_,$_}...* ;`
and access it with `@list[n]`.
[Answer]
# [Brachylog](http://github.com/JCumin/Brachylog), 14 bytes
```
yk:{,[]:?:gi}a
```
[Try it online!](http://brachylog.tryitonline.net/#code=eWs6eyxbXTo_OmdpfWE&input=Mw&args=Wg)
### Explanation
```
yk                The range [0, ..., Input - 1]
  :{        }a    Apply on each element of the range
    ,[]:?:gi      Group the empty list [] in a list Input times
```
[Answer]
## [GAP](http://gap-system.org), 22 bytes
```
f:=n->Set([0..n-1],f);
```
For example:
```
gap> f(3);                            
[ [  ], [ [  ] ], [ [  ], [ [  ] ] ] ]
```
[Answer]
## Racket 119 bytes
```
(λ(n)(define ll(list'()))(for((i(range 1 n)))(set! ll(cons ll(for/list((j(length ll)))(list-ref ll j)))))(reverse ll))
```
Ungolfed:
```
(define f
  (λ (n)
    (define ll (list '()))
    (for ((i (range 1 n)))
      (set! ll
            (cons ll
                  (for/list ((j (length ll)))
                    (list-ref ll j)
                    ))))
    (reverse ll)))
```
Testing (In Racket {} is same as () and default output is ()):
```
(f 4)
'(() (()) ((()) ()) (((()) ()) (()) ()))
```
To clearly see each number (0 to 3): 
```
(for((i (f 4)))  (println (reverse i)))
'()
'(())
'(() (()))
'(() (()) ((()) ()))
```
[Answer]
## Batch, 74 bytes
```
@set s={}
@for /l %%i in (1,1,%1)do @call set s={%%s%%%%s:~1%%
@echo %s%
```
Uses the fact that each answer is equal to the previous answer inserted into itself after the leading `{`. The first few outputs are as follows:
```
{}
{{}}
{{{}}{}}
{{{{}}{}}{{}}{}}
{{{{{}}{}}{{}}{}}{{{}}{}}{{}}{}}
{{{{{{}}{}}{{}}{}}{{{}}{}}{{}}{}}{{{{}}{}}{{}}{}}{{{}}{}}{{}}{}}
```
[Answer]
# x86-64 machine code, 22 bytes
```
31 C0 99 B0 7B AA FF C2 0F BC CA 39 F1 B0 7D F3 AA 75 F0 66 AB C3
```
[Try it online!](https://tio.run/##TVFLb8IwDD7Hv8LrhJSOgqoxDYnHDmPXXXaaBBzaNIFMbdo1BVIh/vo6BxjaxZbzvWxFVNVgI0TXJbZAjh8Bh@EmL9MkRwVqwlxZo0xc5AswkX1DPWFFucckjzB241dgtiltCkwbgTIjUmoVSuElfhJFdZ2shv/KN2C1rPCq/jIS64vXwQMNhAGGU5CukbXBYBHgcV/qDBUX26R@QBuhNg2acHoCuKfwfJdJnNkm0@Vw@wLg0SLRhodwpDVIhLW0u7xZjuJ4PQWm6DR@9sA5xlNqszmOqff7ITDSMMUvisjH0FzVRFc86Gns2ZUJ6D26mnr8BDfGyrwnYqvpKFFmchJ42Ec5HxVhS2NW4vGPjr348ZPs2jnnO2P1xsgMz3eGKly6fn9NZ@Jhq3OJvMU7MnGLkTe9OXBaKm0bacPzYo7AU9f9CJUnG9sNiucnKvTJc@LL/Bc "C++ (gcc) – Try It Online")
Following the standard calling convention for Unix-like systems (from the System V AMD64 ABI), this takes in RDI an address at which to place the result, as a null-terminated byte string, and takes the number `n` in RSI.
In assembly:
```
f:  xor eax, eax    #
    cdq             # Set EAX and EDX to 0.
r:  mov al, 0x7B    # Put the ASCII code of '{' into AL.
    stosb           # Add that to the string, advancing the pointer.
    inc edx         # Add 1 to EDX.
    bsf ecx, edx    # Set ECX to the lowest position of a 1 bit in EDX.
    cmp ecx, esi    # Compare that number with n.
    mov al, 0x7D    # Put the ASCII code of '}' in AL.
    rep stosb       # Add that to the string ECX times, advancing the pointer.
    jne r           # Repeat if the number is not equal to n.
    stosw           # Add two bytes from AX to the string: one more '}' and a null byte.
    ret             # Return.
```
]