BuckleScript User Manual

git clone https://github.com/bucklescript/bucklescript
cd bucklescript
npm install

git clone https://github.com/bucklescript/bucklescript
cd bucklescript/vendor/ocaml
./configure -prefix `pwd` # put your preferred directory
make world.opt
make install

cd ../../jscomp
make world

let world = {j|世界|j}
let hello_world = {j|你好，$world|j}

let hello_world = {j|你好，$(world)|j}

identifier := leading_identifier_char identifier_chars
leading_identifier_char := 'a' .. 'z' | '_'
identifier_chars := 'a' .. 'z' | 'A' .. 'Z' | '0' .. '9' | '_' | '\'

external imul : int -> int -> int = "Math.imul" [@@bs.val]
type dom
(* Abstract type for the DOM *)
external dom : dom = "document" [@@bs.val]

type param
external executeCommands : string -> param array -> unit = ""
[@@bs.scope "commands"] [@@bs.module "vscode"][@@bs.splice]

let f a b c  =
  executeCommands "hi"  [|a;b;c|]

var Vscode = require("vscode");
function f(a, b, c) {
  Vscode.commands.executeCommands("hi", a, b, c);
  return process.env;
}

external makeBuffer : int -> buffer = "Buffer"
[@@bs.new] [@@bs.scope "global"]
external hi : string = ""
[@@bs.module "z"] [@@bs.scope "a0", "a1", "a2"]
external ho : string = ""
[@@bs.val] [@@bs.scope "a0","a1","a2"]
external imul : int -> int -> int = ""
[@@bs.val] [@@bs.scope "Math"]
let f2 ()  =
  makeBuffer 20 , hi , ho, imul 1 2

var Z      = require("z");
function f2() {
  return /* tuple */[
          new (global.Buffer)(20),
          Z.a0.a1.a2.hi,
          a0.a1.a2.ho,
          Math.imul(1, 2)
        ];
}

external create_date : unit -> t = "Date" [@@bs.new]
let date = create_date ()

var date = new Date();

external add : int -> int -> int = "add" [@@bs.module "x"]
external add2 : int -> int -> int = "add2"[@@bs.module "y", "U"] (1)
let f = add 3 4
let g = add2 3 4

var U = require("y");
var X = require("x");
var f = X.add(3, 4);
var g = U.add2(3, 4);

type http
external http : http = "http" [@@bs.module] (1)

type id (** Abstract type for id object *)
external get_by_id : dom -> string -> id =
  "getElementById" [@@bs.send]

get_by_id dom "xx"

dom.getElementById("xx")

external map : ('a -> 'b [@bs]) -> 'b array =
  "" [@@bs.send.pipe: 'a array] (1)
external forEach: ('a -> unit [@bs]) -> 'a array =
  "" [@@bs.send.pipe: 'a array]
let test arr =
    arr
    |> map (fun [@bs] x -> x + 1)
    |> forEach (fun [@bs] x -> Js.log x)

type t
external create : int -> t = "Int32Array" [@@bs.new]
external get : t -> int -> int = "" [@@bs.get_index]
external set : t -> int -> int -> unit = "" [@@bs.set_index]

type textarea
external set_name : textarea -> string -> unit = "name" [@@bs.set]
external get_name : textarea -> string = "name" [@@bs.get]

external readFileSync :
  name:string ->
  ([ `utf8
   | `my_name [@bs.as "ascii"] (1)
   ] [@bs.string]) ->
  string = ""
  [@@bs.module "fs"]

let _ =
  readFileSync ~name:"xx.txt" `my_name

var Fs = require("fs");
Fs.readFileSync("xx.txt", "ascii");

external test_int_type :
  ([ `on_closed (1)
   | `on_open [@bs.as 3] (2)
   | `in_bin (3)
   ]
   [@bs.int]) -> int =
  "" [@@bs.val]

type readline
external on :
    (
    [ `close of unit -> unit
    | `line of string -> unit
    ] (1)
    [@bs.string])
    -> readline = "" [@@bs.send.pipe: readline]
let register rl =
  rl
  |> on (`close (fun event -> () ))
  |> on (`line (fun line -> print_endline line))

function register(rl) {
  return rl.on("close", function () {
                return /* () */0;
              })
           .on("line", function (line) {
              console.log(line);
              return /* () */0;
            });
}

function padLeft(string, padding) {
  if (typeof padding === "number") {
    return Array(padding + 1).join(" ") + value;
  }
  if (typeof padding === "string") {
    return padding + value;
  }
  throw new Error(`Expected string or number, got '${padding}'.`);
}

external padLeft :
  string
  -> ([ `String of string
      | `Int of int
      ] [@bs.unwrap])
  -> string
  = "" [@@bs.val]

let _ = padLeft "Hello World" (`Int 4)
let _ = padLeft "Hello World" (`String "bs: ")

padLeft("Hello World", 4);
padLeft("Hello World", "bs: ");

external add : (int [@bs.ignore]) -> int -> int = ""
[@@bs.val]
let v = add 0 1 2 (1)

var v = add (1,2)

type _ kind =
  | Float : float kind
  | String : string kind
external add : ('a kind [@bs.ignore]) -> 'a -> 'a -> 'a = "" [@@bs.val]

let () =
  Js.log (add Float 3.0 2.0);
  Js.log (add String "x" "y");

let string_of_kind (type t) (kind : t kind) =
  match kind with
  | Float -> "float"
  | String -> "string"

external add_dyn : ('a kind [@bs.ignore]) -> string -> 'a -> 'a -> 'a = ""
[@@bs.val]

let add2 k x y =
  add_dyn k (string_of_kind k) x y

external process_on_exit : (_ [@bs.as "exit"]) -> (int -> unit) -> unit =
  "process.on" [@@bs.val]

let () =
    process_on_exit (fun exit_code ->
        Js.log( "error code: " ^ string_of_int exit_code ))

process.on("exit", function (exit_code) {
      console.log("error code: " + exit_code);
      return /* () */0;
    });

type process

external on_exit : (_ [@bs.as "exit"]) -> (int -> unit) -> unit =
    "on" [@@bs.send.pipe: process]
let register (p : process) =
        p |> on_exit (fun i -> Js.log i)

function register(p) {
  return p.on("exit", function (i) {
              console.log(i);
              return /* () */0;
            });
}

external io_config :
    stdio:(_ [@bs.as "inherit"]) -> cwd:string -> unit -> _ = "" [@@bs.obj]

let config = io_config ~cwd:"." ()

var config = {
  stdio: "inherit",
  cwd: "."
};

external on_exit_slice5 :
    int
    -> (_ [@bs.as 3])
    -> (_ [@bs.as {json|true|json}])
    -> (_ [@bs.as {json|false|json}])
    -> (_ [@bs.as {json|"你好"|json}])
    -> (_ [@bs.as {json| ["你好",1,2,3] |json}])
    -> (_ [@bs.as {json| [{ "arr" : ["你好",1,2,3], "encoding" : "utf8"}] |json}])
    -> (_ [@bs.as {json| [{ "arr" : ["你好",1,2,3], "encoding" : "utf8"}] |json}])
    -> (_ [@bs.as "xxx"])
    -> ([`a|`b|`c] [@bs.int])
    -> (_ [@bs.as "yyy"])
    -> ([`a|`b|`c] [@bs.string])
    -> int array
    -> unit
    =
    "xx" [@@bs.send.pipe: t] [@@bs.splice]

let _ = x |> on_exit_slice5 __LINE__ `a `b [|1;2;3;4;5|]

x.xx(114, 3, true, false, ("你好"), ( ["你好",1,2,3] ), ( [{ "arr" : ["你好",1,2,3], "encoding" : "utf8"}] ), ( [{ "arr" : ["你好",1,2,3], "encoding" : "utf8"}] ), "xxx", 0, "yyy", "b", 1, 2, 3, 4, 5)

external map : 'a array -> 'b array -> ('a -> 'b -> 'c [@bs]) -> 'c array
= "map" [@@bs.val]

let f : 'a0 -> 'a1 -> .. 'b0 [@bs] =
  fun [@bs] a0 a1 .. aN -> b0
let b : 'b0 = f a0 a1 a2 .. aN [@bs]

let f : unit -> 'b0 [@bs] = fun [@bs] () -> b0
let b : 'b0 = f () [@bs]

type 'a return = int -> 'a [@bs]
type 'a u0 = int -> string -> 'a return [@bs] (1)
type 'a u1 = int -> string -> int -> 'a [@bs] (2)
type 'a u2 = int -> string -> (int -> 'a [@bs]) [@bs] (3)

external map : 'a array -> ('a -> 'b[@bs]) -> 'b array = "" [@@bs.send] (1)
map [|1;2;3|] (fun [@bs] x -> x + 1) (2)

external map : 'a array -> ('a -> 'b [@bs.uncurry]) -> 'b array = "" [@@bs.send] (1)
map [|1;2;3|] (fun x -> x+ 1) (2)

let f x y z = x + y + z
let a = f 1 2 3
let b = f 1 2

function f(x){
  return function (y){
    return function (z){
      return x + y + z
    }
  }
}
var a = f (1) (2) (3)
var b = f (1) (2)

function f(x,y,z) {return x + y + z}
var a = f(1,2,3)
var b = function(z){return f(1,2,z)}

x.onload = function(v){
  console.log(this.response + v )
}

type x
external set_onload : x -> (x -> int -> unit [@bs.this]) -> unit = "onload" [@@bs.set]
external resp : x -> int = "response" [@@bs.get]
set_onload x begin fun [@bs.this] o v ->
  Js.log(resp o + v )
end

x.onload = function(v){
  var o = this ; (1)
  console.log(o.response + v);
}

let f : 'obj -> 'b [@bs.this] =
  fun [@bs.this] obj -> ....
let f1 : 'obj -> 'a0 -> 'b [@bs.this] =
  fun [@bs.this] obj a -> ...

exports.height = 3
exports.width  = 3

external demo : < height : int ; width : int > Js.t = "" [@@bs.module]

let test f =
  f##hi 1 (1)
let test2 f =
  let u = f##hi in
  u 1
let test3 f =
  let u = f##hi in
  u 1 [@bs]

val test : < hi : int -> 'a [@bs.meth]; .. > -> 'a (1)
val test2 : < hi : int -> 'a ; .. > -> 'a
val test3 : < hi : int -> 'a [@bs]; .. >

class type _rect = object
  method height : int
  method width : int
  method draw : unit -> unit
end [@bs] (1)
type rect = _rect Js.t

type rect = < height : int ; width : int ; draw : unit -> unit [@bs.meth] > Js.t

f##property (1)
f##property #= v
f##js_method args0 args1 args2 (2)

let fn = f0##f in
let a = fn 1 2
(* f##field a b would think `field` as a method *)

let b = f1##f 1 2

val f0 : < f : int -> int -> int > Js.t
val f1 : < f : int -> int -> int [@bs.meth] > Js.t

console##log "fine"
let u = console##log
let () = u "fine" (1)

let u = [%bs.obj { x = { y = { z = 3}}} ] (1)

var u = { x : { y : { z : 3 }}}}

val u : < x : < y : < z : int > Js.t > Js.t > Js.t

val u : [%bs.obj: < x : < y : < z : int > > > ]

let u = [%bs.obj ( { x = { y = { z = 3 }}} : < x : < y : < z : int > > > ]

let xs = [%bs.obj [| { x = 3 } ; { x = 3 } |] : < x : int > array ]
let ys = [%bs.obj [| { x = 3 } ; { x = 4 } |] ]

var xs = [ { x : 3 } , { x : 3 } ]
var ys = [ { x : 3 } , { x : 4 } ]

external make_config : hi:int -> lo:int -> unit -> t = "" [@@bs.obj]
let v = make_config ~hi:2 ~lo:3

var v = { hi : 2 , lo : 3 }

external make_config : hi:int -> ?lo:int -> unit -> t = "" [@@bs.obj] (1)
let u = make_config ~hi:3 ()
let v = make_config ~lo:2 ~hi:3 ()

var u = {hi : 3}
var v = {hi : 3 , lo: 2}

let u = [%bs.obj {
  x = { y = { z = 3 } };
  fn = fun [@bs] u v -> u + v (1)
  } ]
let h = u##x##y##z
let a = u##fn
let b = a 1 2 [@bs]

var u = { x : { y : { z : 3 } }, fn : function (u, v) {return u + v}}
var h = u.x.y.z
var a = u.fn
var b = a(1,2)

let v2 =
  let x = 3. in
  object (self) (1)
    method hi x y = self##say x +. y
    method say x = x *. self##x ()
    method x () = x
  end [@bs] (2)

var v2 = {
  hi: function (x, y) {
    var self = this ;
    return self.say(x) + y;
  },
  say: function (x) {
    var self = this ;
    return x * self.x();
  },
  x: function () {
    return 3;
  }
};

val v2 : <
  hi : float -> float -> float [@bs.meth];
  say : float -> float [@bs.meth];
  x : unit -> float [@bs.meth]
> [@bs]

let f (u : rect) =
  (* the type annotation is un-necessary,
     but it gives better error message
  *)
   Js.log u##height;
   Js.log u##width;
   u##width #= 30;
   u##height #= 30;
   u##draw ()

function f(u){
  console.log(u.height);
  console.log(u.width);
  u.width = 30;
  u.height = 30;
  return u.draw()
}

f##_open
f##_MAX_LENGTH

f.open
f.MAX_LENGTH

f##draw__cat (x,y)
f##draw__dog (x,y)

f.draw(x,y) // f.draw in JS can accept different types
f.draw(x,y)

let test () =
  match [%external __DEV__] with
  | Some _ -> Js.log "dev mode"
  | None -> Js.log "production mode"

function test() {
  var match = typeof (__DEV__) === "undefined" ? undefined : (__DEV__);
  if (match !== undefined) {
    console.log("dev mode");
    return /* () */0;
  }
  else {
    console.log("production mode");
    return /* () */0;
  }
}

let test2 () =
  match [%external __filename] with
  | Some f -> Js.log f
  | None -> Js.log "non node environment"

function test2() {
  var match = typeof (__filename) === "undefined" ? undefined : (__filename);
  if (match !== undefined) {
    console.log(match);
    return /* () */0;
  }
  else {
    console.log("non node environment");
    return /* () */0;
  }
}

let keys : t -> string array [@bs] = [%bs.raw "Object.keys" ]
let unsafe_lt : 'a -> 'a -> Js.boolean [@bs] = [%bs.raw{|function(x,y){return x < y}|}]

[%%bs.raw{|
  console.log ("hey");
|}]

let x : string = [%bs.raw{|"\x01\x02"|}]

var x = "\x01\x02"

   [%%bs.raw{|
   // Math.imul polyfill
   if (!Math.imul){
       Math.imul = function (..) {..}
    }
   |}]

external describe : string -> (unit -> unit [@bs]) -> unit = "" [@@bs.val]
external it : string -> (unit -> unit [@bs]) -> unit = "" [@@bs.val]

external eq : 'a -> 'a -> unit = "deepEqual" [@@bs.module "assert"]

let assert_equal = eq
let from_suites name suite =
    describe name (fun [@bs] () ->
         List.iter (fun (name, code) -> it name code) suite
         )

 var Assert = require("assert");
 var List = require("bs-platform/lib/js/list");

function assert_equal(prim, prim$1) {
 return Assert.deepEqual(prim, prim$1);
 }

function from_suites(name, suite) {
 return describe(name, function () {
   return List.iter(function (param) {
    return it(param[0], param[1]);
      }, suite);
  });
 }