Comment on page
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
Derw
Next - Guides
Creating your first project
Last modified 1yr ago