Steel

Strongly Typed Experimental Expressive Language

Language that transpile to TypeScript and JavaScript.

Steel is a bootstraped language. That means the code itself is developed in Steel.

Check ./src folder for steel sources. Check ./lib for the compiled sources.

Highly inspired from LiveScript.

Goals

This language tries to implement strong static typing over a subset of Livescript.

To do so, it transpile first to TypeScript, and let it transpile to Javascript. This allow to use the power of a well typed and designed language while smoothing its syntax.

It alse tries not to fall into the same 'over-simplification' Livescript does, and avoid to implement features complexifying the read and understanding of the code.

At term, this language aim to be more functional, and might borrow some concepts from language like Haskell or Ocaml (custom operator?, immutability?, infinite lists?, ...).

Exemples

Basics

import
  fs
  path: { resolve }
  './localFile'
  './localFile2': customName

foo := number -> number -> number
foo = (a, b) -> a + b

bar = (c: number, d: number): number ~>
  if c? and d? and d isnt 0
    c + d
  else
    0

nonReturning = !-> 1

map    = <T>(f: (x: T): T, arr: T[]): T[] --> arr.map f
filter = <T>(f: (x: T): T, arr: T[]): T[] --> arr.filter f

[1, 2, 3]
  |> map (+ 2)
  |> filter (> 2)

class Animal
  a: 1
  b: -> 2
  constructor: (val: number) -> @a = val

class Dog: Animal

dog: Dog = new Dog 1

Transpiled in TypeScript with sc -cts source.s turns into:

(function () {
  import fs = require('fs');
  import _path = require('path');
  let {resolve} = _path;
  import localFile = require('./localFile');
  import customName = require('./localFile2');
  let foo:(a:number,b:number) => number = function (a, b) {
    return a + b;
  };
  let bar = (c:number, d:number): number => {
    if ((c != null) && (d != null) && d !== 0) {
      return c + d;
    } else {
      return 0;
    }
  };
  let nonReturning = function (it?:any) {
    1;
  };
  let map = curry$(function (f:any, arr:any) {
    return arr.map(f);
  });
  let filter = curry$(function (f:any, arr:any) {
    return arr.filter(f);
  });
  (filter(function (it:any) {
    return it>2;
  })(map(function (it:any) {
    return it+2;
  })([1, 2, 3])));
  class Animal {
    a = 1;
    b(it?:any) {
      return 2;
    }
    constructor(val:number) {
      this.a = val;
    }
  };
  class Dog extends Animal {};
  let dog:Dog = new Dog(1);
  function curry$(f: any, bound?: any){ let context: any, _curry: any = function(args?: any){ return f.length > 1 ? function(){ var params = args ? args.concat() :[]; context = bound ? context || this : this; return params.push.apply(params, arguments) < f.length && arguments.length ? _curry.call(context, params) : f.apply(context, params); } : f; }; return _curry(); }
})();

Install

npm install -g steel-lang

Compiler usage

Compiler name is sc, and stands for Steel Compiler.

Usage

$> sc -h

  Usage: sc [options] <files ...>


  Options:

    -V, --version          output the version number
    -c, --compile          Compile files
    -p, --print            Print files
    -o, --output <folder>  File/folder of output
    -s, --strict           Disallow implicit use of <Any> type
    -t, --typescript       Output Typescript instead of Javascript (no typechecking)
    -b, --bare             Dont wrap into top level anonymous function
    -q, --quiet            Dont output types errors/warnings (useful with -p)
    -h, --help             output usage information

Compile and execute on the fly

sc file.s

You can only compile and execute single file on the fly

Files extensions are .s. This extension is registered inside NodeJS when loading steel-lang to auto-compile steel files on the fly when required.

This means you can write

require('steel-lang');
const obj = require('./someFile.s');

Compile a file/folder

sc -c file1.s file2.s
sc -c folder/*.s
sc -c folder/**/*.s

The format of the path is the same as for gulp. If you want to compile recursively or exclude some folders for exemple.

Compile to a diferent output

sc -o dir -c file1.s file2.s
sc -o dir -c folder/*.s

Will output compiled files into dir folder.

If the folder doesnt exists, it is created on the fly.

The arborescence is recreated if a folder is recursively compiled.

Features

• Indent based language

  if a is b
    a
  else
    b

• Variable declaration

  foo = 1
  bar = -> 2

• Inline type declaration

  foo: number = 1
  bar = (a: number, b: number): number -> a + b

• Externalized type declaration

  foo := number
  foo = 1
  
  bar := number -> number -> number
  bar = (a, b) -> a + b

• Function declaration

  • Standard function

    foo = (a, b) -> a + b

  • Arrow function

    foo = (a, b) ~> a + b

  • Last statement is returned (can be disabled by '!')

    foo = (a, b) -> a + b
    # bar does not return its result
    bar = (a, b) !-> a + b

  • Argument types

    foo = (a:number, b: number):number -> a + b

• Function call

  • with parentheses

    foo(1, 'a', var1)

  • with spaces

    foo 1, 'a', var1

  • with '!' for no arguments

    foo()
    # same as
    foo!

• Generics

  map = <T>(f: any, arr: T[]): T[] -> arr.map f
  map (+ 2), [1, 2, 3]

• Curry operator

  # Exists for arrow function : '~~>'
  add = (a, b) --> a + b
  add5 = add 5
  add5 5 # === 10

• Auto add argument 'it' when only one

  a = -> it + 2
  a 2 # === 4

• Shorthand function declaration

  add2 = (+ 2)
  add2 2 # === 4
  
  obj = a: 1
  getA = (.a)
  getA obj # === 1

• Chained calls

  [1, 2, 3]
    |> map (+ 2)
    |> filter (> 2)

• Objects

  obj1 = {}
  obj1 = { a: 1 }
  obj1 = a: 1, b: variable, c: -> 3, d: e: 4
  obj2 =
    a: 1
    b: variable
    c: -> 3
    d:
      e: 4

• Object usage

    obj.a.b(a.b).1.c!.f 1, 2 .d

• Array

    arr = [1, 2, 3]

• Class

  class Animal
    walk: -> 1
  
  class Dog: Animal
    a: 1
    walk: -> super.walk! + 1

• Interface

  interface Test
    a: number
    b?: string

• If / Else

  if a is b
    a
  else
    b

• For / While

  while a < b
    a = a + 1
  
  for i = 0; i < 10; i++
    console.log i

• Try / Catch

  try
    a = JSON.parse foo
  catch e
    console.error e

• 'not' stands for '!'

• '?' for existance checks (!= null)

• 'is / isnt' become '=== / !=='

• 'and / or' become '&& / ||'

• Arithmetic operations

• Import

  import
    fs
    lodash: _
    path: { resolve }
    './foo/bar'

  Become

  import fs = require('fs');
  import _ = require('lodash');
  import _path = require('path');
  let {resolve} = _path;
  import bar = require('./foo/bar');

  You can use require instead of import to make a regular require

TODO:

• fix bug with $curry that swallows arguments type
• generics specification on func call (map(f, arr))
• decimals
• return loops
• typeof, delete, instanceof, ...
• Exports
• Expression as assignable (if, while, ...)
• implements
• Class visibility (public, private,...)
• class static
• Class types for methods and properties
• cast
• Generics
• readonly for interface
• propname for interface
• index for interface
• func type for interface
• abstract
• Transpile code in template strings
• Better error system (more details, more accuracy)
• Std lib
• Multiline string
• Better error management for on-the-fly compilation (get rid of typescript-simple)
• Import native (through options)
• Add tests for
  • Operation
  • Existance
  • Function shorthand
  • Import native
  • Full compile
  • Comments
  • Generics / array type
• Support tsconfig.json
• (Plugin system ?)
• |< operator for chained call with flipped arguments