stoeffel / derw

An Elm-inspired language that transpiles to TypeScript

derw

An Elm-inspired language that transpiles to TypeScript

Example

You can find a bunch of examples in examples, along with the Typescript they generate. But the general gist is: Elm-compatible syntax where possible.

type Result a b
    = Err { error: a }
    | Ok { value: b }

asIs : Result a b -> Result a b
asIs result =
    case result of
        Err { error } -> Err { error }
        Ok { value } -> Ok { value }

Roadmap

0.0.1 alpha

• Arrays [ ], [ 1, 2, 3 ], [ [ 1, 2, 3 ], [ 3, 2, 1 ] ]
• Booleans true, false
• Boolean equality 1 < 2, 1 <= 2, 1 == 2, 1 != 2, 1 > 2, 1 >= 2
• Boolean operations true && false, not true, true || false
• Strings "", "hello world"
• Format strings ``, `Hello ${name}`
• Numbers -1, 0, 1, -1.1, 1.1
• Addition 1 + 2, "Hello" + name
• Subtraction 2 - 1
• Multiplication 2 * 1
• Division 2 / 1
• Pipe [1, 2, 3] |> List.fold add, List.fold add <| [1, 2, 3]
• Compose >>, <<
• Constants hello = "hello world"
• Function definitions
• Lists [ 1, 2, 3 ], [ "hello", "world" ]
• List ranges [ 1..5 ], [ start..end ]

add : number -> number -> number
add x y = x + y

• Function calls

three = add 1 2

• Module references

three = List.map identity [ 1, 2, 3 ]

• Union types

type Result a b
    = Err { error: a }
    | Ok { value: b }

• Type variables

type Thing a = Thing a

• Type aliases

type User =
    { name: string }

• Object literals

user: User
user = { name: string }

• Imports

import List
import Result exposing (map)

• Exports

exposing (map)

• Let statements

sayHiTo : User -> string
sayHiTo user =
    let
        name = user.name
    in
        "Hello " + name

sayHelloTo : User -> string
sayHelloTo user =
    let
        getName: User -> string
        getName user = user.name
    in
        "Hello" + getName user

• If statements

type Animal = Animal { age: number }
sayHiTo : Animal -> string
sayHiTo animal =
    if animal.age == 1 of
        "Hello little one!"
    else
        "You're old"

• Case..of

type Animal = Dog | Cat
sayHiTo : Animal -> string
sayHiTo animal =
    case animal of
        Dog -> "Hi dog!"
        Cat -> "Hi cat!"

• Destructing in case..of

type User = User { name: string }

sayHiTo : User -> string
sayHiTo user =
    case user of
        User { name } -> "Hi " + name + !"

• List destructing

sayHiTo : List number -> string
sayHiTo xs =
    case xs of
        [] -> "Empty"
        x::ys -> "Hello " + x + (sayHiTo ys)

• Constructing union types

type User = User { name: string }
noah = User { name: "Noah" }

• lambdas \x -> x + 1, \x y -> x + y
• Typescript output
• Javscript output
• Module resolution
• CLI
• Type checking
• Syntax highlighting for editors

1.0.0

• An automatic formatter with no options
• A standard library
• Support for Coed
• Testing support via Bach
• Benchmarking support via Mainc

Divergence from Elm

• All top level consts or functions must have type definitions
• Format strings ``
• No need for module names in the module file itself. Use exposing instead

Editor language support

Currently VSCode syntax highlighting is supported by this extenstion: https://github.com/eeue56/derw-syntax. It is not on the marketplace because Microsoft account creation was down when I tried.

Instead, you can do:

git clone https://github.com/eeue56/derw-syntax
cp -r derw-syntax ~/.vscode/extensions/derw-syntax-0.0.1

Name

derw which means oak. Oak is one of the native trees in Wales, famous for it's long life, tall stature, and hard, good quality wood.