Lily: An interpreted language with a focus on expressiveness and type safety

go run source.go

gives you the compile time checks, while still giving you the source code visibility and simplicity of scripts

I think for your use case though, Go would be perfect. Everything is statically compiled, so you don't need to mess with virtualenvs, and everything is statically typed ahead of time. I'm a professional Python developer, but I often do my prototyping in Go because the type system is more ergonomic than Python/mypy.

With https://github.com/DanielKeep/cargo-script you can have single file Rust "scripts" with ecosystem dependencies.

When executing the file (via the cargo-script wrapper), dependencies are fetched and a binary is compiled on demand (and cached for re-runs).

It's pretty awesome for scripts where type safety is important.

    #!/usr/bin/env run-cargo-script
    //! This is a regular crate doc comment, but it also contains a partial
    //! Cargo manifest.  Note the use of a *fenced* code block, and the
    //! `cargo` "language".
    //!
    //! ```cargo
    //! [dependencies]
    //! time = "0.1.25"
    //! ```
    extern crate time;
    fn main() {
        println!("{}", time::now().rfc822z());
    }

print(str, int)

Example:

    #!/usr/bin/env kscript
    // Declare dependencies
    @file:DependsOn(“com.offbytwo:docopt:0.6.0.20150202“)
    import org.docopt.Docopt
    val usage = “...”
    val doArgs = Docopt(usage).parse(args.toList())

    println("Hello from Kotlin!")
    println("Parsed script arguments are: \n" + doArgs)

You could do virtualenv style by setting the CLASSPATH environment variable if you really want. The ecosystem tends to prefer using explicit dependencies though.

> It has Ammonite where you can declare dependencies at the top of files but that seems kind of hacky.

Sort of, but I don't think you'll do better anywhere else. Lots of other replies are suggesting various languages that do essentially the same thing - a magic comment at the top of the file that declares your dependencies.

Gradual typing: https://perl6.party/post/Perl-6-Types--Made-for-Humans Command line arguments: https://perl6advent.wordpress.com/2010/12/02/day-2-interacti...

And at the end of the day it's perl, so it's the king of command line scripts.

One advantage of Lily not mentioned (with regard to typing), is that the type-checking is very fast. One of the reasons I made Lily interpreted and homebrewed all the parts was because as much as I like static typing, it's often slow. Slow static typing, I think, diminishes some of the value of it since you're still waiting but in a different way.

If you want the Option behavior, there's .get()

Anyways, very cool looking language.

Sometimes it is, sometimes it isn't. Most languages allow you to choose whether you want a hash to throw a key error on non-existing keys or return a signal value. My favorite is the uber-flexible approach and nice syntax in Crystal:

  hash[foo] is sugar for hash.fetch(foo)

  hash[foo]? is sugar for hash.fetch(foo, nil)

  hash.fetch(foo) will return the default value of the hash table on nonexistent keys if one was assigned, otherwise raise keyerror

  hash.fetch(foo, nil) will return nil on nonexistent keys