One alternative to submodules in your case would be to use an additional argument to distinguish the type of analysis to do. For example:

```
abstract AnalysisType
immutable Linear <: AnalysisType
end
immutable Quadratic <: AnalysisType
end
analyze(::Type{Linear}, x) = println("Linear analysis of $x")
analyze(::Type{Quadratic}, x) = println("Quadratic analysis of $x")
```

which you could run like this:

```
analyze(Linear, [1,2,3])
```

With a design like this, users can implement their own compatible analysis types by creating a new `AnalysisType`

and a new method for the same `analyze()`

function.

Or, if you donâ€™t like using types as values, a slightly different signature for `analyze`

would be:

```
analyze(::Linear, x) = println("Linear analysis of $x")
analyze(::Quadratic, x) = println("Quadratic analysis of $x")
```

which you could use like this:

```
analyze(Linear(), [1,2,3])
```

(note the extra `()`

after `Linear`

in this case).

The Interpolations.jl package uses a design like this.