gleam-lang / gleam Goto Github PK

⭐️ A friendly language for building type-safe, scalable systems!

License: Apache License 2.0

Erlang 0.27% Rust 93.92% Makefile 0.13% Dockerfile 0.02% CSS 0.77% HTML 0.95% Cap'n Proto 0.15% JavaScript 1.47% Gleam 2.06% Shell 0.16% Elixir 0.02% TypeScript 0.07% PowerShell 0.02%

gleam programming-language compiler erlang statically-typed

gleam's Introduction

Gleam is a friendly language for building type-safe systems that scale! For more information see the website.

Sponsors

Gleam is kindly supported by its sponsors. If you would like to support Gleam please consider sponsoring its development on GitHub.

Thank you to our sponsors! Gleam would not be possible without you.

gleam's People

Contributors

Stargazers

Watchers

Forkers

scripttease adituv hengestone ktec stefanluptak stjordanis mainshayne233 sailfish009 jepotter1-archive mbrukman bgmarx starbelly monkeygroover antonrich exadra37 ontofractal paryz lahiguera jjl rodr0m4 inigosola migzone ricelang lazercorn surprisetalk imor aircom-inc kination seeekr adambrodzinski jwsonic benreyn dirk shritesh bsnyder788 filmor xtian gazler ychclone allysh0w zepedroresende killvxk stephensong thehabbos007 seanpowell zoldar smorimoto zjhmale isgasho gamebox evinasgu davydog187 theannie swelham ericdeansanchez itsgreggreg tomwhatmore kyle-sammons toranb zeta1999 michaeljones dmitri64 quinnwilton chenjianxin borski badboy hoangpq hindenbug mwatts benmyles leomindez oneness gustavonmartins dfischer devonestes lkonya mrgleam up1 cschembor3 sabiwara scrabsha tevinthuku vishalsodani leostera ian-gl masven rasouli tsloughter zimt28 codebay takashiidobe sporto l1x petejodo mjftw zabrane thara davidpdrsn inoas cybernetics

gleam's Issues

Ensure private types do not leak from module

enum PrivateType = P;

pub fn go() {
  P // Invalid, private type would be leaked out of module here 
}

Type annotations

All are optional

fn id(x: Int) -> Int {
  x
}

Parsing
Module fn args
Module fn return
Anon fn args

Function captures

foo(_, 1)

Is equivalent to

fn(x) { foo(x, 1) }

Code formatter

gleam format path/to/file.gleam

Reuse the pretty printing algebra used for Erlang code generation. Effectively it's a new compiler backend that skips type inference and compiles to Gleam.

Retaining comments

Strip the comments out, parse the remaining AST, traverse the AST and use positions in the AST and the comments to determine where to annotate which nodes with which comments.

Custom lalrpop tokenizer:

Rename record to map

It may be worth doing this to avoid confusion with Erlang records

Full exhaustiveness checking of assignments and case expressions

edit: See comments below for current status.

External type definition

pub external type Name

Render errors

https://github.com/brendanzab/codespan

https://github.com/brendanzab/pikelet/blob/aee44a084d4a9be0af4bb96031e5bd0179c13192/src/syntax/parse/errors.rs

REPL

Maybe https://github.com/efene/efene/blob/master/src/fn_repl.erl can serve as an example

Type aliases

type IntMap = Map(Int, Int)

Try structopt for CLI

https://github.com/TeXitoi/structopt

Seems better than clap as it has a type safe API. Need to check that the user experience is as nice.

Escape function names if they collide with Erlang keywords

Keywords

if
case
!
receive
bnot
div
rem
band
bor
bxor
bsl
bsr
not
and
or
xor
orelse
andalso
when
end
fun
try
catch
after

Multiple module type inference

Construct a record for each AST node

Example project using rebar3 hooks to run compiler

https://github.com/purerl/purerl_otp_sandbox

After reading about the OCaml implicit module PR I've had the idea for a system of implicit parameters bouncing round my head, giving Gleam a way of producing polymorphic functions such as enum:map which could operate on more than 1 type of data structure with less boilerplate.

Now it seems Scala has a very similar system already! A good place to start research.

https://docs.scala-lang.org/tour/implicit-parameters.html

https://docs.scala-lang.org/tutorials/FAQ/finding-implicits.html

https://discuss.ocaml.org/t/critique-of-implicits/3031/59

Error if an invalid pattern is specified

Incorrect precedence for infix `+`, `-`, `+.`, `-.`

https://github.com/lpil/gleam/blob/17ed8014292e4b95f1fcaa503328dad6e72fef59/src/gleam_parser.yrl#L17

These should all be left-associative with precedence between that of comparisons and *, /. Elixir has them at precedence 210 (elixir_parser.yrl).

Reference types from other modules

import lib:SomeType

enum Thing =
  | A(SomeType)

Replace => with the more Erlang-aligned ->

Just a reminder issue to discuss using => for functions vs ->, which is more Erlang-aligned.

Inter-module function calls

my_mod:func()

Explore GADTs

Prior discussion #27

https://mads-hartmann.com/ocaml/2015/01/05/gadt-ocaml.html
http://caml.inria.fr/pub/docs/manual-ocaml/extn.html#s%3Agadts

External function definition

pub external fn new(a) -> Any = 'gleam_foreign' 'identity'

Parser should construct a module or an expression.

Module for use by the compiler.

Expression for use by the repl.

Rename Foreign to Unknown

This name seems clearer and avoids any association with the language of xenophobia.

Compile regexs to binary at compile time

{ok, Pattern} = re:compile("abc\\s").

Investigate 1ML

alpaca-lang/alpaca#251 (comment)

Pipe operator

1 |> run

Parsing and typing is done, but the code generator is currently incorrect.

enum MyError extends LibraryError =
  | ExtraError
  | AnotherError

enum Maybe = 
  | Just(Whatever) // What is this?
  | Nothing

gleam eunit CLI

First class documentation

doc """
Say hello to a person
"""
fn greet(name) {
  "Hello, " <> name <> "!"
}

http://erlang.org/eeps/eep-0048.html

https://github.com/elixir-lang/elixir/blob/master/lib/elixir/src/elixir_erl.erl

Remove module header syntax

Current syntax:

module Calculator
  exposing add/2, sub/2, div/2, mult/2

fn add(a, b) {
  a + b
}

fn sub(a, b) {
  a - b
}

fn div(a, b) {
  a / b
}

fn mult(a, b) {
  a * b
}

Proposed syntax:

pub fn add(a, b) {
  a + b
}

pub fn sub(a, b) {
  a - b
}

pub fn div(a, b) {
  a / b
}

pub fn mult(a, b) {
  a * b
}

Advantages

Removing the module header removes duplication between filename and source, making renaming easier and removing potential typos
Removing the export list removes duplication of name/arity between the list and the function definitions, making renaming easier and removing potential typos
Slightly more concise
May be more familiar to mainstream language users

Disadvantages

Slight increase in noise for public function definitions
Public interface of a module is less clear
Less familiar to Erlang and ML users

Notes on typed pids

Existing example in Alpaca: https://github.com/alpaca-lang/alpaca/blob/master/Tour.md#processes. A limited approach as it's not possible to implement something such as an OTP supervisor with it (without using FFI to cheat the type system)

Parser is awkwardly restrictive with sequences and operators

Syntax error:

pub fn go() {
  True |> run
  1
}

OK:

pub fn go() {
  let a = True |> run
  1
}

This is not obvious or friendly.

My parser-fu isn't the best, so I would welcome advice from others on the best way to improve the grammar here.