# Wiki: Janet

• Take advantage of short functions. For example, something like `(some-function(def a val)a)` can be `(|(some-function \$ \$)val)`
• Recursive functions are often shorter than mutable variables.
• `(defn f[a]...)(f a)` => `((fn f[a]...)a)`
• Use `pp` instead of `print` for numbers and quotes
• Often you can use a symbol or quote instead of a string, e.g. `"Fizz"` => `'Fizz` or `:Fizz`. Using `'Fizz` also means it will work with `pp`
• Read the docs. There are a lot of useful functions in there.
• A lot of functions take variadic arguments, especially math ones. So you can reuse them, such as `(-= i(* 2 x))` => `(-= i x x)` or `(<(pp i)x y)`
• Splice is useful, e.g. `sum` => `+;`, or you can do `string;` to join a list, `print;`, etc.
• Note that `sum` does work on strings, which can't be spliced

# Looping over arguments

``````(reduce2|[(f \$1)(g \$1)](dyn :args))
(map|[(f \$)(g \$)](drop 1(dyn :args)))
(each a(drop 1(dyn :args))(f a)(g a))
``````

`each` is good when you have multiple statements and/or nested functions, otherwise `map`/`reduce2` is better. `reduce2` avoids the first argument, but is slightly longer and you have to use \$1 instead \$ which evens up after 4 uses.

# Indexing

There's a few different ways to get a value from a data structure such as a tuple:

``````(ds idx)               # Shortest, but no default and errors when out of range
(idx ds)               # The same but with different execution order I guess
(in ds idx default?)   # Has default, still throws error when out of range, so only good for dictionaries
(get ds idx default?)  # Nil/default when out of range
``````

Related, you can use `put` on arrays/buffers and it will extend it and fill the empty spaces with nils/null bytes.

# Conditionals

``````(if(cond)x y)          # Short circuits, you can leave the false section out to return nil, needs a truthy or (falsey/nil) condition
(and/or cond x)        # Short circuits, multiple conditions
(case n v x default)   # Short circuits, checks specific values, has default
(in{v x}n default)     # Same as case, but no short circuit
({v x n default}n)     # Same again, but with more whitespace to save though using n twice
([x y]n)               # Needs a numeric 0/1 condition
``````