---
title: "Custom Functions (defs)"
description: "In addition to the Dino built-in functions, you can of course define your own functions. The keyword def is used to start a function definition. def triassic() { return 'T-Rex came later'; } Function…"
url: "https://support.wheelhousemfg.com/article/gk3yji6ae8-custom-functions-defs"
category: "Dino Script® Language Reference"
updated_at: "2020-01-29T18:12:56Z"
---

# Custom Functions (defs)

In addition to the Dino built-in functions, you can of course define your own functions. The keyword **def** is used to start a function definition.

```
def triassic() {
    return 'T-Rex came later';
}
```

Functions are not required to return a value. A function body without a return statement will just return a special value known as **null**.

```
def nothing() {
}

var fossil = nothing(); // null
```

Functions can take any number of parameters. Parameters in Dino are dynamically typed; you do not specify what the type is – you simply use one or more identifiers.

```
def rex(name, age) {
    // ...
}
```

### Function Visibility

Functions can have **private** visibility so that they are not imported. By default, functions have public visibility. You can include the **public** keyword if you want, but it is not required.

```
// egg.dino
private def egg() {
    return 'Only my mother can see me.';
}

print(egg()); // ok, we are in the script

def rex() {
    return 'I can be seen by others.';
}
```

```
// outsideWorld.dino
import script 'egg.dino' as e;

print(e.rex()); // ok
print(e.egg()): // error, the egg function is privately defined in egg.dino
```

### Functions as Variables

You can assign functions to variables and call them. This is often referred to as a delegate, and when passed as an argument to another function, a callback or function pointer.

```
def info(a) {
    return a + ' is a big dino.';
}
private var delegate = info;
print(delegate('brontosaurus')); // 'brontosaurus is a big dino'
```

### Nested Functions

Functions do not have to be declared in the global scope – they can be defined in any scope. Functions defined in a local scope such as another function body are always **private** visibility, and calling them outside of their local scope is an error.

```
def outside(a, b) {
    def inside(c) {
        return a + c;
    }
    return inside(b);
}

outside(4, 5); // 9
inside(3); // error, unknown symbol 'inside'
```

### Parameter Defaults

Def statements may define “parameter defaults”, that is parameters that are considered optional from the call site and will have a default value if omitted.

```
def rex(a, b = 10) {
    return a +  b;
}
var a = rex(10); // a == 20
```

In Dino, all parameters are optional – missing arguments are simply set to null, and extra arguments are discarded and ignored. What this means is that setting a parameter to a default of **null** is technically not required, because the missing argument will cause the parameter to be set to **null** in any case.

```
def rex(a, b) {
}
rex(10); // ok, b will just be null
```

```
def rex(a, b = null) {
} // same as above for practical purposes
rex(10); // ok
rex(10, 20, 30, 40, 50); // last 3 args are discarded
```

Parameters with default values must come last in the parameter list. It is an error to define a parameter with a default value and follow it with another that does not have a default value.

```
def rex(a = 20, b) {
} // error

def raptor(a = 10, b = 15, c = 20, d = 25) {
} // ok, all params have defaults
```