type res = {.
  [@bs.meth] "send": string => string
 };
type handler = (string, res) => string;
type expressApp = {.
  [@bs.meth] "listen": (int) => unit,
  [@bs.meth] "get": (string, handler) => string
};

[@bs.module] external express: unit => expressApp = "express";

let app = express();

app##get("/", (_, res) => res##send("Hello World!"));

app##listen(3000);

type t;
[@bs.new] external createDate: unit => t = "Date";

let date = createDate();

type momentResult = {.
  [@bs.meth] "format": (string) => string
};

[@bs.new] [@bs.module]  external moment: unit => momentResult = "";

let date = moment();
Js.log(date##format("YYYY"));

class type _moment =
  [@bs]
  {
    pub format: (string) => string;
  };
type momentResult = Js.t(_moment);

[@bs.new] [@bs.module]  external moment: unit => momentResult = "";
let date = moment();
Js.log(date##format("YYYY")); /* 2018 */

type res = {.
  [@bs.meth] "send": string => string
 };

type nextFun = unit => string;
type handler = (string, res, nextFun) => string;

type expressApp = {.
  [@bs.meth] "listen": (int) => unit,
  [@bs.meth] "get": (string, handler, handler) => string
};

[@bs.module] external express: unit => expressApp = "express";

let app = express();

app##get("/", (_, _, next) => {
  Js.log("hello next");
  next();
}, (_, res, _) => res##send("Hello World!"));

app##listen(3000);

type option('a) = None | Some('a);

let personHasCar = false;

if(personHasCar) {
  Some(5);
} else {
  None;
}

let licenseNumber = Some(5);

switch (licenseNumber) {
  | None => print_endline("The person doesn't have a car")
  | Some(number) =>
    print_endline("The person's license number is " ++ string_of_int(number))
  };

let aaa = Some(Some(Some(5)))

let bbb = Some(None);

[@bs.module "MyIdValidator"] external myId: Js.Nullable.t(string) = "MyID";

[@bs.module "MyIdValidator"] external validate: Js.Nullable.t(string) => bool = "validate";

let personId: Js.Nullable.t(string) = Js.Nullable.return("abc123");

let result = validate(personId);

type intCoordinates = (int, int, int);
type floatCoordinates = (float, float, float);

let buddy: intCoordinates = (10, 20, 20);

type coordidate('a) = ('a, 'a, 'a);

type coordidateAlias = coordidate(int);

let buddy: coordidateAlias = (10, 20, 20);

let buddy = (10, 20, 20);

let greetings = ["hello", "world", "how are you"];

type result('a, 'b) =
  | Ok('a)
  | Error('b);
type myPayload = {data: string};

type myPayloadResults('errorType) = list(result(myPayload, 'errorType));

let payloadResults: myPayloadResults(string) = [
  Ok({data: "hi"}),
  Ok({data: "bye"}),
  Error("Something wrong happened!")
];

type student = {taughtBy: teacher}
and teacher = {student: list(student)};

let myMap = Js.Dict.empty();

Js.Dict.set(myMap, "Allison", 10);

[@bs.val] external studentAge: Js.Dict.t(int) = "student";

switch (Js.Dict.get(studentAge, "Joe")) {
| None => Js.log("Joe can't be found")
| Some(age) => Js.log("Joe is " ++ string_of_int(age));
};

[@bs.deriving abstract]
type person = {
  name: string,
  age: int,
  job: string
};

[@bs.val] external john: person = "john";

[@bs.deriving abstract]
type person = {
  name: string,
  age: int,
  job: string,
};

let joe = person(~name="Joe", ~age=20, ~job="teacher")

[@bs.deriving abstract]
type data = {
  [@bs.as "type"] type_: string,
  [@bs.as "aria-checked"] ariaLabel: string
};

let d = data(~type_="message", ~ariaLabel="hello");

[[@bs.deriving abstract]
type person = {
  [@bs.optional] name: string,
  age: int,
  job: string
};

let joe = person(~age=19, ~job="sleep", ());
Js.log(joe);

[@bs.deriving abstract]
type person = {
  [@bs.optional] name: string,
  age: int,
  job: string,
};

let joe = person(~age=20, ~job="teacher", ());

let twenty = ageGet(joe);
Js.log(twenty);

/**
也可以寫成這樣
joe-> ageGet-> Js.log
**/

[@bs.deriving abstract]
type person = {
  [@bs.optional] name: string,
  mutable age: int,
  job: string,
};

let joe = person(~age=20, ~job="teacher", ());

joe-> ageGet-> Js.log; /* 20 */
joe-> ageSet(21)-> Js.log;
joe-> ageGet-> Js.log; /* 21 */

[@bs.deriving abstract]
type cord = {
  [@bs.optional] mutable x: int,
  y: int,
};

[@bs.deriving abstract]
type cord = {
  [@bs.optional] x: int,
  y: int,
};

type person = {
  .
  name: string,
  age: int,
  job: string
};

type person = Js.t({
  .
  name: string,
  age: int,
  job: string
});

let john = {"name": "john", "age": 11};

john##name -> Js.log;

type person = Js.t({
  .
  name: string,
  age: int,
  job: string
});

let john = {
  "name": "john",
  "age": 11,
  "job": "development"
};

let johnName = john##name;

[%%raw "var a = 1, b = 2"];
let add = [%raw "a + b"];
let myFunction = [%raw "(a, b) =>  a + b"]
Js.log(myFunction(1)(2));

Js.log({js|你好，
世界|js});

let world = "world";
let helloWorld = {j|hello, $world|j};

[@bs.val] external setTimeout/* 在 Reason 中使用的模組名稱 */: (unit => unit, int) => float = "setTimeout";/* 對應到 Javascript 中的模組名稱 */

let eventId = setTimeout(() => Js.log("hello setTimeout"), 1000);
Js.log(eventId);

[@bs.send] external map: (array('a), 'a => 'b) => array('b) = "";
[@bs.send] external filter: (array('a), 'a => 'b) => array('b) = "";

let mapResult = map([|1, 2, 3|], a => a + 1);
let result = filter(mapResult, a => a mod 2 === 0);
Js.log(result);

[@bs.send] external map: (array('a), 'a => 'b) => array('b) = "";
[@bs.send] external filter: (array('a), 'a => 'b) => array('b) = "";

[|1, 2, 3|]
->map(a => a+1)
->filter(a => a mod 2 === 0)
->Js.log

[@bs.val] [@bs.scope "Math"] external random: unit => float = "random";
let someNumber = random();
/**/

/* front end demo */
[@bs.val] [@bs.scope ("window", "location", "ancestorOrigins")] external length: int = "length";

let a = Some(5);
let b = None;

let JsNullable = Js.Nullable.null;
let JsUndefined = Js.Nullable.undefined;

let result1: Js.Nullable.t(string) = Js.Nullable.return("hello"); /* hello */
let result2: Js.Nullable.t(int) = Js.Nullable.fromOption(Some(10)); /* 10 */
let result3: option(int) = Js.Nullable.toOption(Js.Nullable.return(10)); /* 10 */

let default = (name: string, age: int) => Js.log({j|$name 年紀 $age|j});

[@bs.module "./LeftPad.bs"] external leftPad : (string, int) => string = "default";

leftPad("hello", 123);

[@bs.module "path"] external dirname: string => string = "";

Js.log(dirname("/foo/bar/baz/asdf/quux"));

[@bs.module "path"] [@bs.splice]
external join : array(string) => string = "";

Js.log(join([|"/", "hello", "/", "world"|]));

type person = {
  age: int,
  name: string
};

let tomas = {
  age: 35,
  name: "Tomas Lin"
};

let tomasName = tomas.name;
print_endline(tomasName); /* Tomas Lin */

type person = {
  age: int,
  name: string
};

let tomas: person = {
  age: 35,
  name: "Tomas Lin"
};

let tomasName = tomas.name;
print_endline(tomasName);
let simon = {
  age: 22,
  name: "Simon"
};

type cat = {color: string, call: string};

let whiteCat: AnimalType.cat = {
  color: "white",
  call: "喵!"
};

print_endline(whiteCat.call);

type person = {
  age: int,
  name: string
};

let tomas: person = {
  age: 35,
  name: "Tomas Lin"
};

let tomasName = tomas.name;
print_endline(tomasName);
let simon = {
  age: 22,
  name: "Simon"
};

let tomasNextYear = {...tomas, age: tomas.age + 1};

Js.log(tomasNextYear.age);/* 36 */

type person = {
  age: int,
  mutable name: string
};

let tomas: person = {
  age: 25,
  name: "Tomas Lin"
};

let name = "Simon";

let simon = {
  age: 25,
  name
};

tomas.age = tomas.age + 1;

Js.log(tomas.age); /* 26 */
Js.log(simon.name); /* Simon */

type person = {age: int, name: string};
type monster = {age: int, hasTentacles: bool};

let getAge = (entity) => entity.age;
let kraken = {age: 9999, hasTentacles: true};
let me = {age: 5, name: "Baby Reason"};

getAge(kraken);
getAge(me); 
  /* get Error:
    This has type:
      person
    But somewhere wanted:
      monster  */

type tesla = {
  .
  color: string
};

type car(`a) = {
  ..
  color: string
} as `a;

type tesla = {
  .
  color: string,
};

let obj: tesla = {
  val red = "Red";
  pub color = red;
};

Js.log(obj#color) /* "Red" */

type tesla = {.
  drive: (int) => int
};

let obj: tesla = {
  val hasEnvy = ref(false);
  pub drive = (speed) => {
    this#enableEnvy(true);
    speed;
  };
  pri enableEnvy = (envy) => hasEnvy := envy
};

type tesla('a) = {
  ..
  drive: int => int
} as 'a;

type teslaParams = {.
  drive: int => int,
  doYouWant: unit => bool
};

let obj: tesla(teslaParams) = {
  val hasEnvy = ref (false);
  pub drive = (speed) => {
    this#enableEnvy(true);
    speed;
  };
  pub doYouWant = () => hasEnvy^;
  pri enableEnvy = (envy) => hasEnvy := envy
};

Js.log(obj#doYouWant());
Js.log(obj#drive(11));
Js.log(obj#doYouWant());

let someInts = (10, 20);
let (ten, twenty) = someInts;
Js.log(ten);
Js.log(twenty);

type person = {name: string, age: int};
let somePerson: person = {name: "Tomas", age: 30};
let {name, age} = somePerson;
Js.log(name);
Js.log(age);

type person = {name: string, age: int};
let somePerson: person = {name: "Tomas", age: 30};
let {name: n, age: a} = somePerson;
Js.log(n);
Js.log(a);

type person = {name: string, age: int};
let somePerson: person = {name: "Tomas", age: 30};
let {name: (n: string), age: (a: int)} = somePerson;
Js.log(n);
Js.log(a);

type person = {
  name: string,
  age: int
};

let tomas = {name: "Tomas", age: 25};

let someFunction = (~person as {name}) => {
  Js.log(name);
};

let otherFunction = (~person as {name} as thePerson) => {
  Js.log(thePerson);
  Js.log(name);
};

someFunction(~person=tomas);
otherFunction(~person=tomas);

type total = ref(int);
let x: total = ref(5);
x := x^ + 1;
Js.log(x); // 6

let greet = (hello, name) => hello ++ " " ++ name;
Js.log(greet("Hello", "Tomas"));

let sayHello = () => "Hello";
Js.log(sayHello()); /* Hello */

let subNumber = (x, y) => {
  return x - y;
};

Js.log(subNumber(1, 2)); /* 1 */

let subNumber = (~x, ~y) => {
  return x - y;
};

Js.log(subNumber(~x=1, ~y=2));

let drawCircle = (~radius as r, ~color as c) => {
  setColor(c);
  startAt(r, r);
  /* ... */
};

drawCircle(~radius=10, ~color="red");

let saySomeThing = (~name, ~title) => {
  switch title {
  | None => "Hello " ++ name;
  | Some(t_) => t_ ++ name;
  };
}

Js.log(saySomeThing(~name="Tomas"));

type testTuple = (int, int, int);
let test: testTuple = (1, 2, 3);

let (_, second, _) = test;

Js.log(second);/* 2 */

/* Js.log(fst(test));  get compiler Error */
type test2Tuple = (int, int);

switch (isWindowOpen, isDoorOpen) {
| (true, true) => "window and door are open!"
| (true, false) => "just window open"
| (false, true) => "just door open"
| (false, false) => "window and door are not open"
}

let tuple1 = (1, 2);
let tuple2 = (fst(tuple1), 4);
Js.log(tuple2);

let myList: list(int) = [1, 2, 3];
let anotherList = [0, ...myList];

let myList: list(int) = [1,2,3];
let anotherList = [0, ...myList];
Js.log(ListLabels.length(myList)); /* 3 */
Js.log(ListLabels.length(anotherList)); /* 4 */

let myList: list(int) = [1, 2];
let message = 
  switch (myList) {
  | [] => "This list is Empty"
  | [a, ...rest] => "a: " ++ string_of_int(a) ++ " rest.length is " ++ string_of_int(ListLabels.length(rest))
  };

Js.log(message); /* a: 1 rest.length is 1 */

let arrayTest = [|"hello", "eeee", "yo"|];

Js.log(arrayTest[0]);

arrayTest[1] = "gggg";

Js.log(arrayTest[1]); /* gggg */

let array1 = [|0,2,3,4,5,6|];
let array2 = Js.Array.copyWithin(~to_=3, array1);
Js.log(array1);/* [ 0, 2, 3, 0, 2, 3 ] */
Js.log(array2);/* [ 0, 2, 3, 0, 2, 3 ] */
let array3 = Js.Array.push(1, array1);
Js.log(array3);/* [ 0, 2, 3, 0, 2, 3, 1 ] */

let score = 10;

let a: string = "hello";

let a: string = "hello";
Js.log(a);

if (displayGreeting) {
  let message = "Enjoying the docs so far?";
  print_endline(message)
};
/*這裡不能呼叫 message*/

let message = {
  let part1 = "hello";
  let part2 = "world";
  part1 ++ " " ++ part2
};

Js.log(message);

let a: string = "hello";
a = "hello world";

let message = "hello";
Js.log(message); /* Prints "hello" */
let message = "bye";
Js.log(message); /* Prints "bye" */

let a = "1";

let b = a ++ "hello";

Js.log(b); /* 1hello */

let a = 1;

let b = a ++ "hello";

Js.log(b); /* Error: */

let testNum = 1;
let isZero: bool = testNum === 0;
Js.log(isZero);

let tuple1 = (1, 2, 3);
let tuple2 = (1, 2, 3);
let tuple3 = tuple2;

Js.log(tuple1 == tuple2); /* true */
Js.log(tuple1 == tuple3); /* true */
Js.log(tuple1 === tuple2); /* false */
Js.log(tuple1 === tuple3); /* false */
Js.log(tuple2 === tuple3); /* true */

let zero: int = 0;
let floatNumber: float = 0.1;

Js.log(zero); /* 0 */
Js.log(floatNumber); /* 0.1 */

/* zero === floatNumber will got Error by compiler*/

let addResult = 1 + 1;
Js.log(addresult);/* 2 */

let floatAddResult = 1.1 + 1.2; /* get compiler Error (WTF) */
Js.log(floatAddResult);

let addResult = 1 + 1;
Js.log(addresult);/* 2 */

let floatAddResult = 1.1 +. 1.2; /* 2.3 */
Js.log(floatAddResult);

let twoBiggerThanOne = 2 > 1;
Js.log(twoBiggerThanOne);

float_of_int(2) > 1.2; /* true */

let name: string = "Tomas";
let yourName: string = "哈囉世界!";
let a: char = 'a';

Js.log(name);
Js.log(a);
Js.log(yourName); /* \xe5\x93\x88\xe5\x9b\x89\xe4\xb8\x96\xe7\x95\x8c! */

let name: string = "Tomas";
let yourName: string = {js|哈囉世界!|js};
let world = {js|世界|js};
let helloWorld = {j|你好，$world|j};
let a: char = 'a';

Js.log(name);
Js.log(a);
Js.log(yourName); /* 哈囉世界! */

let hello = "Hello";
let world = "World"
Js.log(hello ++ " " ++ world); /* console.log("Hello World"); */

pragma solidity ^0.5.0;

contract Adoption {

}

pragma solidity ^0.5.0;

contract Adoption {
  address[16] public adopters;
}

pragma solidity ^0.5.0;

contract Adoption {
  address[16] public adopters;
  // Adopting a pet
  function adopt(uint petId) public returns (uint) {
    require(petId >= 0 && petId <= 15);

    adopters[petId] = msg.sender;

    return petId;
  }
}

function getAdopters() public view returns (address[16] memory) {
  return adopters;
}

pragma solidity ^0.5.0;

contract Adoption {
  address[16] public adopters;
  function adopt(uint petId) public returns (uint) {
    require(petId >= 0 && petId <= 15);
    adopters[petId] = msg.sender;
    return petId;
  }

  function getAdopters() public view returns (address[16] memory) {
    return adopters;
  }
}

pragma solidity ^0.5.0;

import "truffle/Assert.sol";
import "truffle/DeployedAddresses.sol";
import "../contracts/Adoption.sol";

contract TestAdoption {
  Adoption adoption = Adoption(DeployedAddresses.Adoption());

  uint expectedPetId = 8;

  address expectedAdopter = address(this);
}

function testUserCanAdoptPet() public {
  uint returnedId = adoption.adopt(expectedPetId);

  Assert.equal(returnedId, expectedPetId, "Adoption of the expected pet should match what is returned.");
}

function testGetAdopterAddressByPetId() public {
  address adopter = adoption.adopters(expectedPetId);

  Assert.equal(adopter, expectedAdopter, "Owner of the expected pet should be this contract");
}

function testGetAdopterAddressByPetIdInArray() public {
  address[16] memory adopters = adoption.getAdopters();

  Assert.equal(adopters[expectedPetId], expectedAdopter, "Owner of the expected pet should be this contract");
}