feat: Create immutable.res (#1)

Starting to work on this concept: rescript-lang/rescript-core#23

Author: jderochervlk

.gitignore

@@ -0,0 +1,2 @@
+node_modules
+lib

bsconfig.json

@@ -0,0 +1,25 @@
+{
+  "name": "rescript-immutable-data",
+  "sources": [
+    {
+      "dir": "src",
+      "subdirs": true
+    },
+     {
+      "dir": "examples",
+      "subdirs": true,
+       "mode": "dev"
+    }
+  ],
+  "package-specs": [
+    {
+      "module": "commonjs",
+      "in-source": true
+    }
+  ],
+  "suffix": ".bs.js",
+  "bs-dependencies": [
+    "@rescript/core"
+  ],
+  "bsc-flags": ["-open RescriptCore"]
+}

examples/one.bs.js

@@ -0,0 +1,15 @@
+let t1 = [1]
+
+let t2 = t1->Immutable.Array.fromArray->Immutable.Array.head
+// let t3 = t1->Immutable.Array.head
+let t4 = t1->Immutable.Array.fromArray->Immutable.Array.tail
+
+let t5 = Dict.make()
+let t6 = t5->Immutable.Dict.make->Immutable.Dict.set("t", 1)
+
+let t10 = Dict.fromArray([("foo", "bar")])->Immutable.Dict.make
+
+// let t11 = t1->Immutable.Array.make->Array.map(n => n + 1)
+
+let t11 = t1->Immutable.Array.fromArray
+let t12 = t11->Immutable.Array.at(1)

examples/one.res

@@ -0,0 +1,21 @@
+{
+  "name": "@jvlk/rescript-immutable-data",
+  "version": "1.0.0-alpha.1",
+  "description": "Aplha attempt at immmutable data for ReScript Core",
+  "scripts": {
+    "build": "rescript",
+    "format": "prettier . --write",
+    "res:build": "rescript build -with-deps",
+    "res:dev": "rescript build -w -with-deps"
+  },
+  "keywords": [],
+  "author": "Josh Derocher",
+  "license": "MIT",
+  "devDependencies": {
+  },
+  "dependencies": {
+    "@rescript/core": "^0.3.1",
+    "@rescript/react": "^0.11.0",
+    "rescript": "^10.1.4"
+  }
+}

package-lock.json

@@ -0,0 +1,49 @@
+module Array = {
+  // new to Immutable
+  type t<'a> = array<'a>
+  let fromArray = arr => arr->Array.copy
+  let toArray = fromArray
+
+  // different from array
+  let set = (t, i, v) => {
+    let c = t->Array.copy
+    c->Array.set(i, v)
+    c
+  }
+
+  // same as Array
+
+  let at = Array.at
+
+  let concatMany = Array.concatMany
+  let concat = (t, a) => [a]->Array.concat(t)
+  let copy = Array.copy
+  let copyAlllWithin = Array.copyAllWithin
+  let copyWithin = Array.copyWithin
+  let copyWithinToEnd = Array.copyWithinToEnd
+
+  let get = Array.get
+  let map = Array.map
+
+  // not sure we want to add these
+  let append = (t, a) => t->Array.concat([a])
+  let isEmpty = t => t->Array.length == 0
+  let head = t => t->Array.get(0)
+  let tail = t => isEmpty(t) ? [] : t->Array.slice(~start=1, ~end=t->Array.length)
+}
+
+
+// Dict seems like another good candidate for being Immutable
+module Dict = {
+  type t<'a> = Dict.t<'a>
+  let make = Dict.copy
+  let set = (o, k, v) => {
+    let c = o->Dict.copy
+    c->Dict.set(k, v)
+    c
+  }
+  let get = Dict.get
+  let fromArray = Dict.fromArray
+  let fromIterator = Dict.fromIterator
+  let toArray = Dict.toArray
+}