This language follows an Elm-inspired syntax and structure.
- everything is an expression blah blah blah
- lisp-style functions
- whitespace delimited

Grammar
`verb object object...`
with pipes
`verb object |> verb object |> verb`

example:
`align reference.fa query.fa`

maybe allow for a different currying syntax, e.g.
`align - query.fa`?
`records |> for-each align - reference.fa |> visualize`


Early iterations will be dynamically typed and interpreted.
- automatically generating help pages / command line parsers with your tools
- currying on the command line?

Later iterations will be statically typed (with type inference) and compiled (as well as interpreted). 
- once gradual typing is added, add a macro that lets you write this language inline in Rust
- what would currying on the command-line look like?
- the compilation aspect is generally scary, so maybe there's nothing really to be gained from that
    - might be hard, require dynamically linked libraries and what not
    - the interpreter should never be the hot path (underlying verbs, written in rust and consume much )


`yecko`
```
[nice greeting with version]
[have different commands]
```

`yecko align`
```
align to [reference] with [query]
version
William Owens ()

possible other arguments
```

`yecko align human.fa`
```
version (maybe just print the version of this package)
align to human.fa with [query]
# warning if human.fa does not exist
# warning if human.fa is type which cannot be converted to reference
```

`yecko align human.fa meme.fa`

`yecko map align human.fa [query.fa query.fa query.fa]`


Built in commands
- sketch: mash based ideas
- align (local and global)
- align_global
- blast 
- translate 
- reverse_translate (codon optimization)
- transcribe
- rev_transcribe
- rev_translate
    - how to capture this idea? return a consensus or codon optimize
- translate
- melt_temp
- assemble

# stuff to extract
- tidy (different from print?)

# extracting fields from files
- sequence
- features
- files

# later
- predict_domains
- fold 

# stringy stuff

- find (match)
    - automatic checks with sequences to see if they use the right alphabets

# iteration
- map (maybe choose a different word)
- fold (maybe choose a different word)
- filter