Roadmap

Derw is currently in a usable place, but there's a lot more planned. This page documents the current features, along with some ideas I have yet to implement.

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 alias User =
    { name: string }
```
Object literals
```
user: User
user = { name: "Noah" }
```

Object literals updates

user: User
user = { ...noah, name: "Noah" }

Imports

import List
import Result exposing ( map )
import something as banana

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 + !"

strings in case..of

defaults in case..of

sayHiTo : string -> string
sayHiTo name =
    case name of
        "Noah" -> "Hi " + name + !"
        default: "I don't know you"

List destructing

sum: List number -> number
sum xs =
    case xs of
        [] -> 0
        y :: ys :: [] -> y + ys
        z :: zs -> z + sum zs
        default -> 0

List destructing with string values

sum: List string -> number
sum xs =
    case xs of
        [] -> 0
        "1" :: ys :: [] -> 1 + 2
        "2" :: zs -> 2 + sum zs
        default -> 0

List destructing with union types values

sum: List (Maybe number) -> number
sum xs =
    case xs of
        [] -> 0
        Just { value } :: rest -> value + sum rest
        Nothing :: rest -> sum rest
        default -> 0

Constructing union types

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

Accessors

type alias User = { name: string }
names = List.map .name [ { name: "Noah" }, { name: "Dave" } ]

Nested accessors

type alias Group = { person: { name: string } }
names = List.map .person.name [ { person: { name: "Noah" } }, { person: { name: "Dave" } } ]

Errors on type name collison

The name `Person` has been used for different things.
8 - 10:

```
type Person =
    Person { name: string }
```

11 - 14:

```
type alias Person = {
    name: string
}
```

Errors on function name collison

The name `isTrue` has been used for different things.
0 - 3:

```
isTrue: boolean -> boolean
isTrue x =
    x == true
```

4 - 7:

```
isTrue: boolean -> boolean
isTrue x =
    x != true
```

Some form of basic type errors

Failed to parse examples/errors/mismatching_types.derw due to:
Error on lines 0 - 3
Expected `boolean` but got `number` in the body of the function:

```
isTrue: boolean -> boolean
isTrue x =
    1 + 2
```

Error on lines 4 - 7
Expected `List string` but got `List number`:

```
names: List string
names =
    [1..2]
```

lambdas \x -> x + 1, \x y -> x + y
Typescript output
Javscript output
Elm output
Module resolution
CLI
Basic type checking
Detect if types exist in current namespace
Syntax highlighting for editors
Collision detection for names in a module

Importing of Derw files

import "./other"
import "./something" as banana
import "./another" exposing ( isTrue, isFalse )
import "./Maybe" as Maybe exposing (Maybe)

Errors when failing to find relative import

Warning! Failed to find `examples/derw_imports/banana` as either derw, ts or js

Single line comments

-- hello
isTrue: boolean -> boolean
isTrue x =
    x

Single line comments in function or const bodies

isTrue: boolean -> boolean
isTrue x =
    -- hello
    x

Multiline comments

{-
hello
world
-}
isTrue: boolean -> boolean
isTrue x =
    x

Function arguments

map: (a -> b) -> a -> b
map fn value =
    fn value

Globals
Globals can be accessed through the globalThis module which is imported into every namespace. E.g globalThis.console.log

Constant if statements

name: string
name =
    if 1 == 1 then
        "Noah"
    else
        "James"

Constant case statements

name: string
name =
    case person of
        "n" -> "Noah"
        "j" -> "James"
        default -> "Other"

List prepend

numbers: List number
numbers =
    1 :: [ 2, 3 ]

1.0.0

An automatic formatter with no options
```
derw format
```
A standard library
Support for Coed
Use html
Testing support via Bach
Write a file with _test as an extension (e.g List_test.derw).
```
import Test exposing (equals)

testMath: boolean -> void
testMath a? =
    equals 1 1
```
Compile it, then run bach via npx @eeue56/bach
Type checking
Benchmarking support via Mainc
Async support
Packaging
Package init
```
derw init
```
Package testing
```
# inside a package directory
derw test
```
Compile a package
```
derw compile
```

Install a package

derw install --name derw-lang/stdlib --version main

An info command to find out stats about modules
```
derw init
```
A repl
```
derw repl
```

Bundling

derw bundle --entry src/Main.derw --output dist/index.js --watch --quiet

English output
```
derw compile --target english
```

Template generation

derw template --path src/Main.derw --template web

Do notation

sayHi: string -> void
sayHi name =
    do
        globalThis.console.log "Hello" name
    return
        undefined

2.0.0

Time travelling debugger
Type checking with interop with TypeScript
Derw compiler is written in Derw

PreviousDerw NextCreating your first project

Last updated 3 years ago