@compute.ts/array
    TypeScript icon, indicating that this package has built-in type declarations

    2.1.1 • Public • Published

    Presentation

    The engine is based on incremental computation algorithms. When a calculation is submitted to the engine, all the computed values are memorized. So, if you change some variable and query an evaluation, the engine is able to compute the result very fast because it recomputes only what has changed.

    compute.ts

    Libraries

    The project provides several libraries that each comes with dozens of operators. Please note the cross-compatibility of the libraries.

    Imports

    Typescript

    import {/* required operators */} from '@compute.ts/array';

    Javascript

    const {/* required operators */} = require('@compute.ts/array');

    Operators

    array

    array.ofType() ➜ x[type]
    array.ofType(values) ➜ x[type]

    The array operator allows you to create a array expression which evals to the given value. If no value is provided the expression is a variable of the model

    import {array} from "@compute.ts/array"
    
    const x = string('Hello');
    const y = array.ofString([x1, 'World'])
    
    const value = y.eval() // ['Hello', 'World']

    access

    x[type].access(ynumber) ➜ ztype

    The access operator allows to create an expression which eval to the node value of the element at the given position of the given array.

    import {array} from "@compute.ts/array";
    import {number} from "@compute.ts/number";
    
    const x = array.ofNumber([1, 2, 3]);  
    const y = number();  
    const z = x.access(y);
    
    y.affect(1);
    const value = z.eval(); // 2

    accessFirst

    x[type].accessFirst() ➜ ztype

    The accessFirst operator allows to create an expression which eval to the first element of the given array.

    import {array} from "@compute.ts/array";
    import {number} from "@compute.ts/number";
    
    const x = array.ofNumber([1, 2, 3]);  
    const z = y.accessFirst(y);
    
    const value = y.eval(); // 1

    accessLast

    x[type].accessLast() ➜ ztype

    The accessLast operator allows to create an expression which eval to the last element of the give array.

    import {array} from "@compute.ts/array";
    import {number} from "@compute.ts/number";
    
    const x = array.ofNumber([1, 2, 3]);  
    const z = y.accessLast();
    
    const value = y.eval(); // 3

    concatRight

    x[type].concatRight(y0type, y1type, ..., yntype) ➜ z[type]

    The concatRight operator allows to create an expression which eval given array with the given elements at the end.

    import {array} from "@compute.ts/array";
    import {number} from "@compute.ts/number";
    
    const x = array.ofNumber([1, 2, 3]);
    const y1 = number(4);
    const y2 = number(5);
    const z = x.concatRight(y1, y2);
    
    const value = z.eval(); // [1, 2, 3, 4, 5]

    leftTail

    x[type].leftTail(ytype) ➜ z[type]

    The leftTail operator allows to create an expression which eval to the given array without the last element.

    import {array} from "@compute.ts/array";
    import {number} from "@compute.ts/number";
    
    const x = array.ofNumber([1, 2, 3]);
    const y = x.leftTail();
    
    const value = y.eval(); // [1, 2]

    concatLeft

    x[type].concatLeft(y0type, y1type, ..., yntype) ➜ z[type]

    The concatLeft operator allows to create an expression which eval to the given array with the given elements at the begining.

    import {array} from "@compute.ts/array";
    import {number} from "@compute.ts/number";
    
    const x = array.ofNumber([1, 2, 3]);
    const y1 = number(4);
    const y2 = number(5);
    const z = x.concatLeft(y1, y2);
    
    const value = z.eval(); // [4, 5, 1, 2, 3]

    rightTail

    x[type].rightTail(y0type, y1type, ..., yntype) ➜ z[type]

    The rightTail operator allows to create an expression which eval to the given array without the first element.

    import {array} from "@compute.ts/array";
    import {number} from "@compute.ts/number";
    
    const x = array.ofNumber([1, 2, 3]);
    const y = x.rightTail();
    
    const value = y.eval(); // [2, 3]

    firstIndexOf

    x[type].firstIndexOf(ytype) ➜ znumber

    The firstIndexOf operator allows to create an expression which eval to the first index of the given node value.

    import {array} from "@compute.ts/array";
    import {number} from "@compute.ts/number";
    
    const x = array.ofNumber([1, 2, 3, 2, 1]);
    const y = number(2);
    const z = x.firstIndexOf(y);
    
    const value = z.eval(); // 1

    indexesOf

    x[type].indexesOf(ytype) ➜ z[number]

    The indexesOf operator allows to create an expression which eval to the indexes of the given node value.

    import {array} from "@compute.ts/array";
    import {number} from "@compute.ts/number";
    
    const x = array.ofNumber([1, 2, 3, 2, 1]);
    const y = number(2);
    const z = x.firstIndexOf(y);
    
    const value = z.eval(); // [1, 3]

    lastIndexOf

    x[type].lastIndexOf(ytype) ➜ znumber

    The lastIndexOf operator allows to create an expression which eval to the last index of the given node value.

    import {array} from "@compute.ts/array";
    import {number} from "@compute.ts/number";
    
    const x = array.ofNumber([1, 2, 3, 2, 1]);
    const y = number(2);
    const z = x.lastIndexOf(y);
    
    const value = z.eval(); // 3

    includes

    x[type].includes(ytype) ➜ zboolean

    The includes operator allows to create an expression which eval to true if the given element is in the given array.

    import {array} from "@compute.ts/array";
    import {number} from "@compute.ts/number";
    
    const x = array.ofNumber([1, 2, 3, 2, 1]);
    const y = number(2);
    const z = x.includes(y);
    
    const value = z.eval(); // true

    reverse

    x[type].reverse() ➜ y[type]

    The reverse operator allows to create an expression which evals to the reverse of the given array.

    import {array} from "@compute.ts/array";
    import {number} from "@compute.ts/number";
    
    const x = array.ofNumber([1, 2, 3]);
    const y = x.reverse();
    
    const value = y.eval(); // [3, 2, 1]

    size

    x[type].size() ➜ ynumber

    The size operator allows to create an expression which evals to the size of the given array.

    import {array} from "@compute.ts/array";
    import {number} from "@compute.ts/number";
    
    const x = array.ofNumber([1, 2, 3]);
    const y = x.size();
    
    const value = y.eval(); // 3

    isEmpty

    x[type].isEmpty() ➜ yboolean

    The isEmpty operator allows to create an expression which evals to true if the given array is empty.

    import {array} from "@compute.ts/array";
    import {number} from "@compute.ts/number";
    
    const x = array.ofNumber([1, 2, 3]);
    const y = x.isEmpty();
    
    const value = y.eval(); // false

    subArray

    x[type].subArray(y1number, y2number) ➜ z[type]

    The subArray operator allows to create an expression which evals to true if the given array is empty.

    import {array} from "@compute.ts/array";
    import {number} from "@compute.ts/number";
    
    const x = array.ofNumber([1, 2, 3, 2, 1]);
    const y1 = number(1);
    const y2 = number(3);
    const z = x.subArray(y1, y2);
    
    const value = z.eval(); // [2, 3, 2]

    shuffle

    x[type].shuffle() ➜ z[type]

    The shuffle operator allows to create an expression which evals to the given array shuffled.

    import {array} from "@compute.ts/array";
    import {number} from "@compute.ts/number";
    
    const x = array.ofNumber([1, 2, 3, 2, 1]);
    const y = x.shuffle();
    
    const value = z.eval(); // [1, 3, 1, 2, 2]

    About the author

    I am a software developer with 4 years of project specializing in the development of web solutions. Digital Nomad, I work while traveling. After 3 years into the french industry, I've started to work as a freelance software architect or fullstack developer.

    Based on state-of-the-art web technologies, I offer you to architect & develop the best version of your project. My experience in the web app development assure you to build a nice looking, performant and stable product.

    Minimalist, I like to travel, to meet people, learn new things and handmade stuff. Scuba & sky diving licenced. I like also hamburgers, Kinder chocolate and crepes. Karate black belt.

    https://berthellemy.com/


    Install

    npm i @compute.ts/array

    DownloadsWeekly Downloads

    25

    Version

    2.1.1

    License

    MIT

    Unpacked Size

    56.4 kB

    Total Files

    58

    Last publish

    Collaborators

    • mberthellemy