Plume is a programming language that aims to be as simple as existing languages like Python. It has a great learning curve, permitting users either to perform simple tasks or to accomplish large projects. Its syntax has been designed to be non-aggressive and free, without sacrificing performance.
require "std:io/http"
port = 8000
create_server(
port, Some("Server running on port $port"),
fn(res, body: str) {
res.respond("Hello, world!", 200)
}
)Because simplicity, elegance, and readability should be the norm in programming languages nowadays.
Interpreted languages shouldn't always mean bad performance: Plume aims at being fast and efficient.
Plume is designed to be flexible and to adapt to the user's needs, not the other way around.
Great interoperability enables great native softwares. Plume's dynamic library support is designed to be easy to use.
As Plume needs to be flexible, it is designed to be easily extended, by enabling function overloading with type extensions.
The language itself and its standard library are designed to be type safe, avoiding any runtime errors from them.
Plume is a programming language that aims to be as simple as existing languages like Python. It has a great learning curve, permitting users either to perform simple tasks or to accomplish large projects. Its syntax has been designed to be non-aggressive and free, without sacrificing performance.
Because runtime errors shouldn't be a thing nowadays. Plume is designed to trap every possible error at compile time, permitting the user to focus on the logic of the program.
The standard library is also fully safe, no function will ever throw a runtime error. It has a little cost obviously, especially in terms of codebase-size, but it's worth it.
list = [1, 2, 3, 4]
// Will print Some(1)
println(list[0])
// Will print None
println(list[98])
Why should you use even more longer names for functions that are doing philosophically the same thing? Plume is designed to be easily extended, by enabling function overloading with type extensions.
Type extensions come with three key features:
(+) for any type that implements numeric interface.
interface show<A> {
fn show(x: A): str
}
extend show<str> {
fn show(x) => "\"" + x + "\""
}
fn log<A extends show>(x: A) =>
println(x.show())
What's a language without the ability to express your own data-structures? Plume permits you to define your own types thanks to ADTs (resp. Algebraic Data Types).
ADT is a complex name for a simple concept: an ADT express a type that can be one of several "functions" (resp. ADT constructors) where each function can have a variable number of types.
type LinkedList<A> {
Empty,
Cons(A, LinkedList<A>)
}
xs = Cons(1, Cons(2, Cons(3, Empty)))
// Slightly equivalent to:
// xs = [1, 2, 3]Plume is in its early stages, and we need your help to make it better. If you want to contribute, please check out our contributing guidelines. We plan to implement many cool features, such as:
The Plume Project Manager, formally called ppm, is a tool that will help you manage your Plume projects. It will be able to create new projects, build them, and run them. And also providing a way to manage dependencies, and even native libraries.
The Plume compiler is currently written in Haskell. This is a great languages for compilers but it is really heavy to install and heavy to build. So, we plan to rewrite the compiler in Plume itself, to make it easier to install, to build, and to maintain.
As Plume is designed to be easily extended, we plan to enable the user to define its own compiler extensions. Like actual user-defined types, these extensions will be defined in the language itself, and will be compiled by the bootstrapped compiler. This should enable the user to define its own syntax, extend the typechecker, and even the code generator.
Current standard library is quite minimal, and we plan to extend it with more functions, more types, and more modules. We also plan to add more documentation to it, to make it easier to use. This could be combined with the project manager to provide a way to install new standard modules.
And even more features in the future! If you want to know more about the project, please check out our milestones.