Gleam (programming language)

Last updated

Gleam
Gleam Lucy.png
Lucy, the starfish mascot for Gleam [1]
Paradigm Multi-paradigm: functional, concurrent [2]
Designed by Louis Pilfold
Developer Louis Pilfold
First appearedJune 13, 2016;8 years ago (2016-06-13)
Stable release
1.5.1 [3]   OOjs UI icon edit-ltr-progressive.svg / 26 September 2024
Typing discipline Type-safe, static, inferred [2]
Memory management Garbage collected
Implementation language Rust
OS FreeBSD, Linux, macOS, OpenBSD, Windows [4]
License Apache License 2.0 [5]
Filename extensions .gleam
Website gleam.run
Influenced by
[6]

Gleam is a general-purpose, concurrent, functional high-level programming language that compiles to Erlang or JavaScript source code. [2] [7] [8]

Contents

Gleam is a statically-typed language, [9] which is different from the most popular languages that run on Erlang’s virtual machine BEAM, Erlang and Elixir. Gleam has its own type-safe implementation of OTP, Erlang's actor framework. [10] Packages are provided using the Hex package manager, and an index for finding packages written for Gleam is available. [11]

History

The first numbered version of Gleam was released on April 15, 2019. [12] Compiling to JavaScript was introduced with version v0.16. [13]

In 2023 the Erlang Ecosystem Foundation funded the creation of a course for learning Gleam on the learning platform Exercism. [14]

Version v1.0.0 was released on March 4, 2024. [15]

Features

Gleam includes the following features, many common to other functional programming languages: [8]

Example

A "Hello, World!" example:

import gleam/io  pub fn main() {   io.println("hello, friend!") }

Gleam supports tail call optimization: [16] 

pub fn factorial(x: Int) -> Int {   // The public function calls the private tail recursive function   factorial_loop(x, 1) }  fn factorial_loop(x: Int, accumulator: Int) -> Int {   case x {     1 -> accumulator      // The last thing this function does is call itself     _ -> factorial_loop(x - 1, accumulator * x)   } }

Implementation

Gleam's toolchain is implemented in the Rust programming language. [17] The toolchain is a single native binary executable which contains the compiler, build tool, package manager, source code formatter, and language server. A WebAssembly binary containing the Gleam compiler is also available, enabling Gleam code to be compiled within a web browser.

Related Research Articles

<span class="mw-page-title-main">Erlang (programming language)</span> Programming language

Erlang is a general-purpose, concurrent, functional high-level programming language, and a garbage-collected runtime system. The term Erlang is used interchangeably with Erlang/OTP, or Open Telecom Platform (OTP), which consists of the Erlang runtime system, several ready-to-use components (OTP) mainly written in Erlang, and a set of design principles for Erlang programs.

OCaml is a general-purpose, high-level, multi-paradigm programming language which extends the Caml dialect of ML with object-oriented features. OCaml was created in 1996 by Xavier Leroy, Jérôme Vouillon, Damien Doligez, Didier Rémy, Ascánder Suárez, and others.

Standard ML (SML) is a general-purpose, high-level, modular, functional programming language with compile-time type checking and type inference. It is popular for writing compilers, for programming language research, and for developing theorem provers.

<span class="mw-page-title-main">F Sharp (programming language)</span> Microsoft programming language

F# is a general-purpose, high-level, strongly typed, multi-paradigm programming language that encompasses functional, imperative, and object-oriented programming methods. It is most often used as a cross-platform Common Language Infrastructure (CLI) language on .NET, but can also generate JavaScript and graphics processing unit (GPU) code.

<span class="mw-page-title-main">D (programming language)</span> Multi-paradigm system programming language

D, also known as dlang, is a multi-paradigm system programming language created by Walter Bright at Digital Mars and released in 2001. Andrei Alexandrescu joined the design and development effort in 2007. Though it originated as a re-engineering of C++, D is now a very different language. As it has developed, it has drawn inspiration from other high-level programming languages. Notably, it has been influenced by Java, Python, Ruby, C#, and Eiffel.

In computer science, a tail call is a subroutine call performed as the final action of a procedure. If the target of a tail is the same subroutine, the subroutine is said to be tail recursive, which is a special case of direct recursion. Tail recursion is particularly useful, and is often easy to optimize in implementations.

Squirrel is a high level imperative, object-oriented programming language, designed to be a lightweight scripting language that fits in the size, memory bandwidth, and real-time requirements of applications like video games.

<span class="mw-page-title-main">Scala (programming language)</span> General-purpose programming language

Scala is a strong statically typed high-level general-purpose programming language that supports both object-oriented programming and functional programming. Designed to be concise, many of Scala's design decisions are intended to address criticisms of Java.

<span class="mw-page-title-main">Node.js</span> JavaScript runtime environment

Node.js is a cross-platform, open-source JavaScript runtime environment that can run on Windows, Linux, Unix, macOS, and more. Node.js runs on the V8 JavaScript engine, and executes JavaScript code outside a web browser.

Haskell is a general-purpose, statically-typed, purely functional programming language with type inference and lazy evaluation. Designed for teaching, research, and industrial applications, Haskell has pioneered several programming language features such as type classes, which enable type-safe operator overloading, and monadic input/output (IO). It is named after logician Haskell Curry. Haskell's main implementation is the Glasgow Haskell Compiler (GHC).

<span class="mw-page-title-main">Rust (programming language)</span> General-purpose programming language

Rust is a general-purpose programming language emphasizing performance, type safety, and concurrency. It enforces memory safety, meaning that all references point to valid memory. It does so without a traditional garbage collector; instead, both memory safety errors and data races are prevented by the "borrow checker", which tracks the object lifetime of references at compile time.

Dart is a programming language designed by Lars Bak and Kasper Lund and developed by Google. It can be used to develop web and mobile apps as well as server and desktop applications.

<span class="mw-page-title-main">Red (programming language)</span> Computer programming language released in 2011

Red is a programming language designed to overcome the limitations of the programming language Rebol. Red was introduced in 2011 by Nenad Rakočević, and is both an imperative and functional programming language. Its syntax and general usage overlaps that of the interpreted Rebol language.

<span class="mw-page-title-main">Elm (programming language)</span> Functional programming language

Elm is a domain-specific programming language for declaratively creating web browser-based graphical user interfaces. Elm is purely functional, and is developed with emphasis on usability, performance, and robustness. It advertises "no runtime exceptions in practice", made possible by the Elm compiler's static type checking.

Elixir is a functional, concurrent, high-level general-purpose programming language that runs on the BEAM virtual machine, which is also used to implement the Erlang programming language. Elixir builds on top of Erlang and shares the same abstractions for building distributed, fault-tolerant applications. Elixir also provides tooling and an extensible design. The latter is supported by compile-time metaprogramming with macros and polymorphism via protocols.

<span class="mw-page-title-main">Nim (programming language)</span> Programming language

Nim is a general-purpose, multi-paradigm, statically typed, compiled high-level system programming language, designed and developed by a team around Andreas Rumpf. Nim is designed to be "efficient, expressive, and elegant", supporting metaprogramming, functional, message passing, procedural, and object-oriented programming styles by providing several features such as compile time code generation, algebraic data types, a foreign function interface (FFI) with C, C++, Objective-C, and JavaScript, and supporting compiling to those same languages as intermediate representations.

<span class="mw-page-title-main">Mix (build tool)</span> Build automation software for Elixir

Mix is a build automation tool for working with applications written in the Elixir programming language. Mix was created in 2012 by Anthony Grimes, who took inspiration from Clojure's Leiningen. Soon after, Mix was merged into the Elixir programming language itself and to this day is one of the six applications that are part of the Elixir language. Mix provides functionality for creating, compiling, and testing Elixir source code and for managing dependencies and deploying Elixir applications.

BEAM is the virtual machine at the core of the Erlang Open Telecom Platform (OTP). BEAM is part of the Erlang Run-Time System (ERTS), which compiles Erlang source code into bytecode, which is then executed on the BEAM. BEAM bytecode files have the .beam file extension.

<span class="mw-page-title-main">PureScript</span> Strongly-typed language that compiles to JavaScript

PureScript is a strongly-typed, purely-functional programming language that transpiles to JavaScript, C++11, Erlang, and Go. It can be used to develop web applications, server side apps, and also desktop applications with use of Electron or via C++11 and Go compilers with suitable libraries. Its syntax is mostly comparable to that of Haskell. In addition, it introduces row polymorphism and extensible records. Also, contrary to Haskell, the PureScript language is defined as having a strict evaluation strategy, although there are non-conforming back-ends which implement a lazy evaluation strategy.

<span class="mw-page-title-main">Reason (programming language)</span> Syntax extension and toolchain for OCaml

Reason, also known as ReasonML, is a general-purpose, high-level, multi-paradigm, functional and object-oriented programming language and syntax extension and toolchain for OCaml created by Jordan Walke, who also created the React framework, at Facebook. Reason uses many syntax elements from JavaScript, compiles to native code using OCaml's compiler toolchain, and can compile to JavaScript using the ReScript compiler.

References

  1. ↑ "gleam-lang/gleam Issues - New logo and mascot #2551". GitHub .
  2. 1 2 3 "Gleam Homepage". 2024.
  3. ↑ "Release 1.5.1". September 26, 2024. Retrieved October 21, 2024.
  4. ↑ "Installing Gleam". 2024.
  5. ↑ "Gleam License File". GitHub . December 5, 2021.
  6. ↑ Pilfold, Louis (February 7, 2024). "Gleam: Past, Present, Future!". FOSDEM 2024– via YouTube.
  7. ↑ Krill, Paul (March 5, 2024). "Gleam language available in first stable release". InfoWorld. Retrieved March 26, 2024.
  8. 1 2 Eastman, David (June 22, 2024). "Introduction to Gleam, a New Functional Programming Language". The New Stack. Retrieved July 29, 2024.
  9. ↑ De Simone, Sergio (March 16, 2024). "Erlang-Runtime Statically-Typed Functional Language Gleam Reaches 1.0". InfoQ. Retrieved March 26, 2024.
  10. ↑ Getting to know Actors in Gleam - Raúl Chouza. Code BEAM America. March 27, 2024. Retrieved May 6, 2024– via YouTube.
  11. ↑ "Introducing the Gleam package index – Gleam". gleam.run. Retrieved May 7, 2024.
  12. ↑ "Hello, Gleam! – Gleam". gleam.run. Retrieved May 6, 2024.
  13. ↑ "v0.16 - Gleam compiles to JavaScript! – Gleam". gleam.run. Retrieved May 7, 2024.
  14. ↑ Alistair, Woodman (December 2023). "Erlang Ecosystem Foundation Annual General Meeting 2023 Chair's Report".
  15. ↑ "Gleam version 1 – Gleam". gleam.run. Retrieved May 7, 2024.
  16. ↑ "Tail Calls". The Gleam Language Tour. Retrieved March 26, 2024.
  17. ↑ gleam-lang/gleam, Gleam, May 6, 2024, retrieved May 6, 2024


This page is based on this Wikipedia article
Text is available under the CC BY-SA 4.0 license; additional terms may apply.
Images, videos and audio are available under their respective licenses.