gleam-lang / gleam Goto Github PK

https://github.com/brendanzab/codespan

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

http://2ality.com/2018/01/polymorphic-variants-reasonml.html

I like the extendibility here, I could imagine extendable error unions to be very useful. Perhaps having an explicit extension syntax would be good alternative to fully polymorphic variants.

enum MyError extends LibraryError =
  | ExtraError
  | AnotherError

edit: See comments below for current status.

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

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

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

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).

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

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

https://www.rebar3.org/docs/using-templates#section-plugin-templates

https://github.com/arpunk/rebar3_lfe_templates/blob/master/lfe_lib/lfe_lib_rebar.config.tpl

All are optional

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

• Parsing
• Module fn args
• Module fn return
• Anon fn args

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.

https://github.com/purerl/purerl_otp_sandbox

https://ferd.ca/erlang-otp-21-s-new-logger.html

https://github.com/rust-lang-nursery/mdBook

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

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

foo(_, 1)

Is equivalent to

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

1 |> run

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

tomprimozic/type-systems@4403586

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.

Module for use by the compiler.

Expression for use by the repl.

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)

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

Keywords

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

For use in Elixir projects

To improve stacktraces.

Example from Alpaca: alpaca-lang/alpaca#258

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:

• https://github.com/lalrpop/lalrpop/blob/8a96e9646b3d00c2226349efed832c4c25631c53/doc/calculator/src/main.rs#L143-L148
• https://github.com/lalrpop/lalrpop/blob/8a96e9646b3d00c2226349efed832c4c25631c53/doc/calculator/src/calculator8.lalrpop
• https://github.com/lalrpop/lalrpop/blob/8a96e9646b3d00c2226349efed832c4c25631c53/doc/calculator/src/tok8.rs

Imitate the erlc CLI http://erlang.org/doc/man/erlc.html

alpaca-lang/alpaca#251 (comment)