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