time-to-botec

Benchmark sampling in different programming languages
Log | Files | Refs | README

builtin.js (3124B)

      1 import { makeDefinition } from "../library/registry/fnDefinition.js";
      2 import { frAny, frArray, frBool, frNumber, frString, } from "../library/registry/frTypes.js";
      3 import { FnFactory } from "../library/registry/helpers.js";
      4 import { vArray, vBool, vString, isEqual } from "../value/index.js";
      5 const maker = new FnFactory({
      6     nameSpace: "",
      7     requiresNamespace: false,
      8 });
      9 export const library = [
     10     maker.nn2n({ name: "add", fn: (x, y) => x + y }),
     11     maker.ss2s({ name: "add", fn: (x, y) => x + y }),
     12     maker.nn2n({ name: "subtract", fn: (x, y) => x - y }),
     13     maker.nn2n({ name: "multiply", fn: (x, y) => x * y }),
     14     maker.nn2n({ name: "divide", fn: (x, y) => x / y }),
     15     maker.nn2n({ name: "pow", fn: (x, y) => Math.pow(x, y) }),
     16     maker.nn2b({ name: "smaller", fn: (x, y) => x < y }),
     17     maker.nn2b({ name: "smallerEq", fn: (x, y) => x <= y }),
     18     maker.nn2b({ name: "larger", fn: (x, y) => x > y }),
     19     maker.nn2b({ name: "largerEq", fn: (x, y) => x >= y }),
     20     maker.bb2b({ name: "or", fn: (x, y) => x || y }),
     21     maker.bb2b({ name: "and", fn: (x, y) => x && y }),
     22     maker.n2n({ name: "unaryMinus", fn: (x) => -x }),
     23     maker.make({
     24         name: "not",
     25         definitions: [
     26             makeDefinition([frNumber], ([x]) => {
     27                 return vBool(x !== 0);
     28             }),
     29             makeDefinition([frBool], ([x]) => {
     30                 return vBool(!x);
     31             }),
     32         ],
     33     }),
     34     maker.make({
     35         name: "concat",
     36         definitions: [
     37             makeDefinition([frString, frString], ([a, b]) => {
     38                 return vString(a + b);
     39             }),
     40             makeDefinition([frArray(frAny), frArray(frAny)], ([a, b]) => {
     41                 return vArray([...a, ...b]);
     42             }),
     43             makeDefinition([frString, frAny], ([a, b]) => {
     44                 return vString(a + b.toString());
     45             }),
     46         ],
     47     }),
     48     maker.make({
     49         name: "add",
     50         definitions: [
     51             makeDefinition([frString, frAny], ([a, b]) => {
     52                 return vString(a + b.toString());
     53             }),
     54         ],
     55     }),
     56     maker.make({
     57         name: "equal",
     58         definitions: [
     59             makeDefinition([frAny, frAny], ([a, b]) => {
     60                 return vBool(isEqual(a, b));
     61             }),
     62         ],
     63     }),
     64     maker.make({
     65         name: "unequal",
     66         definitions: [
     67             makeDefinition([frAny, frAny], ([a, b]) => {
     68                 return vBool(!isEqual(a, b));
     69             }),
     70         ],
     71     }),
     72     maker.make({
     73         name: "typeOf",
     74         definitions: [
     75             makeDefinition([frAny], ([v]) => {
     76                 return vString(v.publicName);
     77             }),
     78         ],
     79     }),
     80     maker.make({
     81         name: "inspect",
     82         definitions: [
     83             makeDefinition([frAny], ([value]) => {
     84                 console.log(value);
     85                 return value;
     86             }),
     87             makeDefinition([frAny, frString], ([value, label]) => {
     88                 console.log(`${label}: ${value.toString()}`);
     89                 return value;
     90             }),
     91         ],
     92     }),
     93 ];
     94 //# sourceMappingURL=builtin.js.map