# 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. * [x] Arrays `[ ]`, `[ 1, 2, 3 ]`, `[ [ 1, 2, 3 ], [ 3, 2, 1 ] ]` * [x] Booleans `true`, `false` * [x] Boolean equality `1 < 2`, `1 <= 2`, `1 == 2`, `1 != 2`, `1 > 2`, `1 >= 2` * [x] Boolean operations `true && false`, `not true`, `true || false` * [x] Strings `""`, `"hello world"` * [x] Format strings ` `` `, `` `Hello ${name}` `` * [x] Numbers `-1`, `0`, `1`, `-1.1`, `1.1` * [x] Addition `1 + 2`, `"Hello" + name` * [x] Subtraction `2 - 1` * [x] Multiplication `2 * 1` * [x] Division `2 / 1` * [x] Pipe `[1, 2, 3] |> List.fold add`, `List.fold add <| [1, 2, 3]` * [ ] Compose `>>`, `<<` * [x] Constants `hello = "hello world"` * [x] Function definitions * [x] Lists `[ 1, 2, 3 ]`, `[ "hello", "world" ]` * [x] List ranges `[ 1..5 ]`, `[ start..end ]` ```elm add : number -> number -> number add x y = x + y ``` * [x] Function calls ```elm three = add 1 2 ``` * [x] Module references ```elm three = List.map identity [ 1, 2, 3 ] ``` * [x] Union types ```elm type Result a b = Err { error: a } | Ok { value: b } ``` * [x] Type variables ``` type Thing a = Thing a ``` * [x] Type aliases ```elm type alias User = { name: string } ``` * [x] Object literals ```elm user: User user = { name: "Noah" } ``` * [x] Object literals updates ```elm user: User user = { ...noah, name: "Noah" } ``` * [x] Imports ```elm import List import Result exposing ( map ) import something as banana ``` * [x] Exports ```elm exposing ( map ) ``` * [x] Let statements ```elm 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 ``` * [x] If statements ```elm type Animal = Animal { age: number } sayHiTo : Animal -> string sayHiTo animal = if animal.age == 1 of "Hello little one!" else "You're old" ``` * [x] Case..of ```elm type Animal = Dog | Cat sayHiTo : Animal -> string sayHiTo animal = case animal of Dog -> "Hi dog!" Cat -> "Hi cat!" ``` * [x] Destructing in case..of ```elm type User = User { name: string } sayHiTo : User -> string sayHiTo user = case user of User { name } -> "Hi " + name + !" ``` * [x] strings in case..of * [x] defaults in case..of ```elm sayHiTo : string -> string sayHiTo name = case name of "Noah" -> "Hi " + name + !" default: "I don't know you" ``` * [x] List destructing ```elm sum: List number -> number sum xs = case xs of [] -> 0 y :: ys :: [] -> y + ys z :: zs -> z + sum zs default -> 0 ``` * [x] List destructing with string values ```elm sum: List string -> number sum xs = case xs of [] -> 0 "1" :: ys :: [] -> 1 + 2 "2" :: zs -> 2 + sum zs default -> 0 ``` * [x] List destructing with union types values ```elm sum: List (Maybe number) -> number sum xs = case xs of [] -> 0 Just { value } :: rest -> value + sum rest Nothing :: rest -> sum rest default -> 0 ``` * [x] Constructing union types ```elm type User = User { name: string } noah = User { name: "Noah" } ``` * [x] Accessors ```elm type alias User = { name: string } names = List.map .name [ { name: "Noah" }, { name: "Dave" } ] ``` * [ ] Nested accessors ```elm type alias Group = { person: { name: string } } names = List.map .person.name [ { person: { name: "Noah" } }, { person: { name: "Dave" } } ] ``` * [x] Errors on type name collison ````markdown The name `Person` has been used for different things. 8 - 10: ``` type Person = Person { name: string } ``` 11 - 14: ``` type alias Person = { name: string } ``` ```` * [x] Errors on function name collison ````markdown 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 ``` ```` * [x] Some form of basic type errors ````markdown 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] ``` ```` * [x] lambdas `\x -> x + 1`, `\x y -> x + y` * [x] Typescript output * [x] Javscript output * [x] Elm output * [x] Module resolution * [x] CLI * [x] Basic type checking * [x] Detect if types exist in current namespace * [x] Syntax highlighting for editors * [x] Collision detection for names in a module * [x] Importing of Derw files ```elm import "./other" import "./something" as banana import "./another" exposing ( isTrue, isFalse ) import "./Maybe" as Maybe exposing (Maybe) ``` * [x] Errors when failing to find relative import ``` Warning! Failed to find `examples/derw_imports/banana` as either derw, ts or js ``` * [x] Single line comments ```elm -- hello isTrue: boolean -> boolean isTrue x = x ``` * [x] Single line comments in function or const bodies ```elm isTrue: boolean -> boolean isTrue x = -- hello x ``` * [x] Multiline comments ```elm {- hello world -} isTrue: boolean -> boolean isTrue x = x ``` * [x] Function arguments ```elm map: (a -> b) -> a -> b map fn value = fn value ``` * [x] Globals Globals can be accessed through the `globalThis` module which is imported into every namespace. E.g `globalThis.console.log` * [x] Constant if statements ```elm name: string name = if 1 == 1 then "Noah" else "James" ``` * [x] Constant case statements ```elm name: string name = case person of "n" -> "Noah" "j" -> "James" default -> "Other" ``` * [x] List prepend ```elm numbers: List number numbers = 1 :: [ 2, 3 ] ``` ### 1.0.0 * [x] An automatic formatter with no options ``` derw format ``` * [ ] A standard library * [x] Support for [Coed](https://github.com/eeue56/coed) Use [html](https://github.com/derw-lang/html) * [x] Testing support via [Bach](https://github.com/eeue56/bach) Write a file with `_test` as an extension (e.g `List_test.derw`). ```elm 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](https://github.com/eeue56/mainc) * [ ] Async support * [x] Packaging * [x] Package init ``` derw init ``` * [x] Package testing ``` # inside a package directory derw test ``` * [x] Compile a package ``` derw compile ``` * [x] Install a package ``` derw install --name derw-lang/stdlib --version main ``` * [x] An info command to find out stats about modules ``` derw init ``` * [x] A repl ``` derw repl ``` * [x] Bundling ``` derw bundle --entry src/Main.derw --output dist/index.js --watch --quiet ``` * [x] English output ``` derw compile --target english ``` * [x] Template generation ``` derw template --path src/Main.derw --template web ``` * [x] Do notation ```elm 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 --- # Agent Instructions: Querying This Documentation If you need additional information that is not directly available in this page, you can query the documentation dynamically by asking a question. Perform an HTTP GET request on the current page URL with the `ask` query parameter: ``` GET https://docs.derw-lang.com/roadmap.md?ask= ``` The question should be specific, self-contained, and written in natural language. The response will contain a direct answer to the question and relevant excerpts and sources from the documentation. Use this mechanism when the answer is not explicitly present in the current page, you need clarification or additional context, or you want to retrieve related documentation sections.