Nanotechnology Promises Much

    js-array2-ex

    0.0.4 • Public • Published

    JsArray2Ex

    A ReScript library that extends Js.Array2 module.

    Installation

    yarn add js-array2-ex
    or
    npm install js-array2-ex

    Add it to bsconfig.json

    "bs-dependencies": ["js-array2-ex"]

    Getting started

    JsArray2Ex extends Js.Array2 module. open JsArray2Ex will opens Js.Array2 module too.

    open JsArray2Ex
    
    let fib = n => unfold(((x, (a, b))) => x < n ? Some(a + b, (x + 1, (b, a + b))) : None, (0, (0, 1)))
    fib(10)
    ->pairwise
    ->windowed(4)
    ->groupBy(x =>
      x->averageIntBy(y =>
        switch y {
        | (f, _) => f
        }
      )
    )
    ->forEach(x => {
      let (f, s) = x
      Js.log(j`Average:$f by the first value of pairs`)
      Js.log(s)
    })
    
    // result =>
    Average:2.75 by the first value of pairs
    [ [ [ 1, 2 ], [ 2, 3 ], [ 3, 5 ], [ 5, 8 ] ] ]
    Average:4.5 by the first value of pairs
    [ [ [ 2, 3 ], [ 3, 5 ], [ 5, 8 ], [ 8, 13 ] ] ]
    Average:7.25 by the first value of pairs
    [ [ [ 3, 5 ], [ 5, 8 ], [ 8, 13 ], [ 13, 21 ] ] ]
    Average:11.75 by the first value of pairs
    [ [ [ 5, 8 ], [ 8, 13 ], [ 13, 21 ], [ 21, 34 ] ] ]
    Average:19 by the first value of pairs
    [ [ [ 8, 13 ], [ 13, 21 ], [ 21, 34 ], [ 34, 55 ] ] ]
    Average:30.75 by the first value of pairs
    [ [ [ 13, 21 ], [ 21, 34 ], [ 34, 55 ], [ 55, 89 ] ] ]

    APIs

    t

    type t<'a> = array<'a>

    create: int => t<'a>

    let intNums:t<int> = create(10)
    let floatNums:t<float> = create(10)
    let strings:t<string> = create(10)

    chunkBySize: (t<'a>, int) => t<t<'a>>

    let result = [1, 2, 3, 4, 5, 6, 7] -> chunkBySize(4)
    
    // result => [[1, 2, 3, 4], [5, 6, 7]]

    throws JsArray2Ex.Invalid_argument if chunkSize argument is not positive.

    countBy: (t<'a>, 'a => 'key) => t<('key, int)>

    let result = [1, 1, 2, 2, 1, 3, 2] -> countBy(x => mod(x, 2) == 0)
    
    // result => [(false, 4), (true, 3)]

    scan: (t<'a>, ('b, 'a) => 'b, 'b) => t<'b>

    let result = [1, 2, 3] -> scan((x, y) => x + y, 0)
    
    // result => [0, 1, 3, 6]

    scanRight: (t<'a>, ('a, 'b) => 'b, 'b) => t<'b>

    let result = [1, 2, 3, 4, 5, 6, 7, 8, 9, 10] -> scanRight((x, y) => x + y, 0) 
          
    // result => [55, 54, 52, 49, 45, 40, 34, 27, 19, 10, 0]

    unfold: ('a => option<('b, 'a)>, 'a) => t<'b>

    let fib = n => unfold(((x, (a, b))) => x < n ? Some(a + b, (x + 1, (b, a + b))) : None, (0, (0, 1)))
    let result = fib(10)
    
    // result => [1, 2, 3, 5, 8, 13, 21, 34, 55, 89]

    mapFold : (t<'a>, ('b, 'a) => ('c, 'b), 'b) => (t<'c>, 'b)

    let arr1To10 = Belt.Array.makeBy(10, x => x + 1)
    let result = arr1To10 -> mapFold((x, y) => (x + y, x + y), 0)
    
    // result => ([1, 3, 6, 10, 15, 21, 28, 36, 45, 55], 55)

    mapFoldRight: (t<'a>, ('a, 'b) => ('c, 'b), 'b) => (t<'c>, 'b)

    let arr1To10 = Belt.Array.makeBy(10, x => x + 1)
    let result = arr1To10 -> mapFoldRight((x, y) => (x + y, x + y), 0)
    
    // result => ([55, 54, 52, 49, 45, 40, 34, 27, 19, 10], 55)

    distinct: t<'a> => t<'a>

    let result = 
    [{"name": "Jack", "age": 10.4},
     {"name": "Jack", "age": 10.4},
     {"name": "Bliss", "age": 10.2}] -> distinct
    
    // result => [{"name": "Jack", "age": 10.4}, {"name": "Bliss", "age": 10.2}]

    distinctBy: (t<'a>, 'a => 'b) => t<'a>

    let result = [{name: "a", age: 10.4}, {name: "b", age: 10.4}, {name: "c", age: 10.4}] -> distinctBy(x => x.age)
    
    // result => [{name: "a", age: 10.4}]      

    groupBy: (t<'a>, 'a => 'b) => t<('b, t<'a>)>

    let result = [1, 2, 3, 4, 5, 6] -> groupBy(x => mod(x, 2) == 0)
    
    // result => [(false, [1, 3, 5]), (true, [2, 4, 6])]

    skip: (t<'a>, int) => t<'a>

    let result = [1, 2, 3, 4, 5] -> skip(2)
    
    // result => [3, 4, 5]

    skipWhile: (t<'a>, 'a => bool) => t<'a>

    let result = [1, 2, 3, 4] -> skipWhile(x => x < 3)
    
    // result => [3, 4]

    take: (t<'a>, int) => t<'a>

    let result = [1, 2, 3] -> take(2) 
    
    // result => [1, 2]

    takeWhile: (t<'a>, 'a => bool) => t<'a>

    let result = [1,2,3,4,5,6] -> takeWhile(x => x < 2)
    
    // result => [1]

    splitAt: (t<'a>, int) => (t<'a>, t<'a>)

    let result = [1, 2, 3, 4, 5] -> splitAt(3)
    
    // result => ([1, 2, 3], [4, 5])

    throws JsArray2Ex.Invalid_operation if the source array has insufficient number of elements.

    transpose: t<t<'a>> => t<t<'a>>

    let result = [[1, 2], [4, 5]] -> transpose  
    
    // result => [[1, 4], [2, 5]]                                       

    throws JsArray2Ex.Invalid_argument if the lengths of the elements of the input array is not the same.

    windowed: (t<'a>, int) => t<t<'a>>

    let result = [1,2,3,4,5] -> windowed(2) 
    
    // result =>  [[1,2], [2,3], [3,4],[4,5]]

    throws JsArray2Ex.Invalid_argument if the size argument is less than or equal to zero.

    except: (t<'a>, t<'a>) => t<'a>

    let result = [1, 2, 3] -> except([1, 2])
    
    // result => [3]

    head: t<'a> => 'a

    let result = [1,2,3] -> head
    
    // result => 1
    

    throws JsArray2Ex.Invalid_argument if the source array is empty

    tryHead: t<'a> => option<'a>

    let result = [1,2,3] -> tryHead
    
    // result => Some(1)

    tail: t<'a> => t<'a>

    let result = [1,2,3] -> tail
    
    // result => [2, 3] 

    map2: (t<'a>, t<'b>, ('a, 'b) => 'c) => t<'c>

    let result = map2([1, 2, 3], [4, 5, 6], (x, y) => x + y)
    
    // result => [5, 7, 9]

    throws JsArray2Ex.Invalid_argument if the lengths of the input arrays are not the same.

    map3: (t<'a>, t<'b>, t<'c>, ('a, 'b, 'c) => 'd) => t<'d>

    let result = map3([1, 2, 3], [4, 5, 6], [7,8,9], (x, y, z) => x + y + z)
    
    // result => [12, 15, 18]

    throws JsArray2Ex.Invalid_argument if the lengths of the input arrays are not the same.

    pairwise: t<'a> => t<('a, 'a)>

    let result = [1, 2, 3, 4] -> pairwise
    
    // result => [(1, 2), (2, 3), (3, 4)]

    minInt: t<int> => int

    let result = [1,2,3] -> minInt 
    
    // result => 1

    throws JsArray2Ex.Invalid_argument if the input array is empty.

    maxInt: t<int> => int

    let result = [1,2,3] -> maxInt
    
    // result => 3

    throws JsArray2Ex.Invalid_argument if the input array is empty.

    minFloat: t<float> => float

    let result = [1., 2., 3.] -> minFloat
    
    // result => 1.

    throws JsArray2Ex.Invalid_argument if the input array is empty.

    maxFloat: t<float> => float

    let result = [1., 2., 3.] -> maxFloat
    
    // result => 3.

    throws JsArray2Ex.Invalid_argument if the input array is empty.

    sumInt: t<int> => int

    let result = [1, 2, 3] -> sumInt
    
    // result => 6

    sumFloat: t<float> => float

    let result = [1., 2., 3.] -> sumFloat
    
    // result => 6.

    averageInt: t<int> => float

    let result = [1, 2, 3] -> averageInt
    
    // result => 2.

    throws JsArray2Ex.Invalid_argument if the input array is empty.

    averageFloat: t<float> => float

    let result = [1., 2., 3.] -> averageFloat
    
    // result => 2.

    throws JsArray2Ex.Invalid_argument if the input array is empty.

    sumIntBy: (t<'a>, 'a => int) => int

    let result = [1, 2, 3, 4] -> sumIntBy(x => x > 2 ? x : 0)
    
    // result => 7

    sumFloatBy: (t<'a>, 'a => float) => float

    let result = [1, 2, 3, 4] -> sumFloatBy(x => x > 2 ? Js.Int.toFloat(x) : 0.)
    
    // result => 7.

    minBy: (t<'a>, 'a => 'b) => 'a

    let people = [{"name": "abc", "age": 10.}, {"name": "def", "age": 20.}]
    let result =   people->minBy(x => x["age"])
    
    // result => {"name": "abc", "age": 10.}  

    throws JsArray2Ex.Invalid_argument if the input array is empty.

    maxBy: (t<'a>, 'a => 'b) => 'a

    let people = [{"name": "abc", "age": 10.}, {"name": "def", "age": 20.}]
    let result =   people->maxBy(x => x["age"])
    
    // result => {"name": "def", "age": 20.}  

    throws JsArray2Ex.Invalid_argument if the input array is empty.

    averageIntBy: (t<'a>, 'a => int) => float

    let result = [1, 2, 3, 4, 5]->averageIntBy(x => x > 2 ? x : 0)
    
    // result => 2.4

    throws JsArray2Ex.Invalid_argument if the input array is empty.

    averageFloatBy: (t<'a>, 'a => float) => float

    let result = [1., 2., 3., 4., 5.]->averageFloatBy(x => x > 2. ? x : 0.)
    
    // result => 2.4

    throws JsArray2Ex.Invalid_argument if the input array is empty.


    Author

    Nyi Nyi Than (Jazz)

    License

    MIT

    Install

    npm i js-array2-ex

    DownloadsWeekly Downloads

    0

    Version

    0.0.4

    License

    MIT

    Unpacked Size

    47.5 kB

    Total Files

    11

    Last publish

    Collaborators

    • nyinyithann