@fncts/base 0.0.39 → 0.0.41

package/_src/collection/immutable/ReadonlyArray/constructors.ts

@@ -0,0 +1,47 @@
+/**
+ * @tsplus static fncts.ArrayOps empty
+ */
+export function empty<A = never>(): ReadonlyArray<A> {
+  return [];
+}
+
+/**
+ * @tsplus static fncts.ArrayOps makeBy
+ */
+export function makeBy<A>(n: number, f: (i: number) => A): ReadonlyArray<A> {
+  const j   = Math.max(0, Math.floor(n));
+  const out = Array(n);
+  for (let i = 0; i < j; i++) {
+    out[i] = f(i);
+  }
+  return out;
+}
+
+/**
+ * @tsplus static fncts.ArrayOps range
+ */
+export function range(start: number, end: number): ReadonlyArray<number> {
+  return Array.makeBy(end - start + 1, (i) => start + i);
+}
+
+/**
+ * @tsplus static fncts.ArrayOps replicate
+ */
+export function replicate<A>(n: number, a: A): ReadonlyArray<A> {
+  return Array.makeBy(n, () => a);
+}
+
+/**
+ * tsplus static fncts.ArrayOps __call
+ */
+export function make<A>(...values: ReadonlyArray<A>): ReadonlyArray<A> {
+  return values;
+}
+
+/**
+ * @tsplus getter fncts.Array asReadonlyArray
+ * @tsplus macro identity
+ */
+export function asReadonlyArray<A>(self: Array<A>): ReadonlyArray<A> {
+  return self;
+}

package/_src/collection/{compat/Array → immutable/ReadonlyArray}/definition.ts

@@ -15,6 +15,14 @@ declare global {
   export interface ArrayConstructor {}
 }
 
+export interface ReadonlyArrayF extends HKT {
+  type: ReadonlyArray<this["A"]>;
+  variance: {
+    A: "+";
+  };
+  index: number;
+}
+
 export type ESArray<A> = globalThis.Array<A>;
 export type ESReadonlyArray<A> = globalThis.ReadonlyArray<A>;
 

package/_src/collection/immutable/{ImmutableArray → ReadonlyArray}/instances.ts

@@ -1,4 +1,4 @@
-import type { ImmutableArrayF } from "@fncts/base/collection/immutable/ImmutableArray/definition";
+import type { ReadonlyArrayF } from "@fncts/base/collection/immutable/ReadonlyArray/definition";
 import type * as P from "@fncts/base/typeclass";
 
 import {
@@ -27,13 +27,13 @@ import {
   wiltWithIndex,
   wither,
   witherWithIndex,
-} from "@fncts/base/collection/immutable/ImmutableArray/api";
-import { empty } from "@fncts/base/collection/immutable/ImmutableArray/constructors";
+} from "@fncts/base/collection/immutable/ReadonlyArray/api";
+import { empty } from "@fncts/base/collection/immutable/ReadonlyArray/constructors";
 
 /**
  * @tsplus implicit
  */
-export const Align = HKT.instance<P.Align<ImmutableArrayF>>({
+export const Align = HKT.instance<P.Align<ReadonlyArrayF>>({
   map,
   alignWith,
   nil: empty,
@@ -41,20 +41,20 @@ export const Align = HKT.instance<P.Align<ImmutableArrayF>>({
 /**
  * @tsplus implicit
  */
-export const Functor = HKT.instance<P.Functor<ImmutableArrayF>>({
+export const Functor = HKT.instance<P.Functor<ReadonlyArrayF>>({
   map,
 });
 /**
  * @tsplus implicit
  */
-export const FunctorWithIndex = HKT.instance<P.FunctorWithIndex<ImmutableArrayF>>({
+export const FunctorWithIndex = HKT.instance<P.FunctorWithIndex<ReadonlyArrayF>>({
   map,
   mapWithIndex,
 });
 /**
  * @tsplus implicit
  */
-export const Apply = HKT.instance<P.Apply<ImmutableArrayF>>({
+export const Apply = HKT.instance<P.Apply<ReadonlyArrayF>>({
   map,
   zip: cross,
   zipWith: crossWith,
@@ -62,34 +62,34 @@ export const Apply = HKT.instance<P.Apply<ImmutableArrayF>>({
 /**
  * @tsplus implicit
  */
-export const Applicative = HKT.instance<P.Applicative<ImmutableArrayF>>({
+export const Applicative = HKT.instance<P.Applicative<ReadonlyArrayF>>({
   map,
   zip: cross,
   zipWith: crossWith,
-  pure: (a) => ImmutableArray(a),
+  pure: (a) => [a],
 });
 /**
  * @tsplus implicit
  */
-export const Alt = HKT.instance<P.Alt<ImmutableArrayF>>({
+export const Alt = HKT.instance<P.Alt<ReadonlyArrayF>>({
   map,
   alt,
 });
 /**
  * @tsplus implicit
  */
-export const Alternative = HKT.instance<P.Alternative<ImmutableArrayF>>({
+export const Alternative = HKT.instance<P.Alternative<ReadonlyArrayF>>({
   map,
   zip: cross,
   zipWith: crossWith,
-  pure: (a) => ImmutableArray(a),
+  pure: (a) => [a],
   alt,
   nil: empty,
 });
 /**
  * @tsplus implicit
  */
-export const Filterable = HKT.instance<P.Filterable<ImmutableArrayF>>({
+export const Filterable = HKT.instance<P.Filterable<ReadonlyArrayF>>({
   map,
   filter: filter,
   filterMap: filterMap,
@@ -99,7 +99,7 @@ export const Filterable = HKT.instance<P.Filterable<ImmutableArrayF>>({
 /**
  * @tsplus implicit
  */
-export const FilterableWithIndex = HKT.instance<P.FilterableWithIndex<ImmutableArrayF>>({
+export const FilterableWithIndex = HKT.instance<P.FilterableWithIndex<ReadonlyArrayF>>({
   ...FunctorWithIndex,
   ...Filterable,
   filterWithIndex: filterWithIndex,
@@ -110,14 +110,14 @@ export const FilterableWithIndex = HKT.instance<P.FilterableWithIndex<ImmutableA
 /**
  * @tsplus implicit
  */
-export const Foldable = HKT.instance<P.Foldable<ImmutableArrayF>>({
+export const Foldable = HKT.instance<P.Foldable<ReadonlyArrayF>>({
   foldLeft,
   foldRight,
 });
 /**
  * @tsplus implicit
  */
-export const FoldableWithIndex = HKT.instance<P.FoldableWithIndex<ImmutableArrayF>>({
+export const FoldableWithIndex = HKT.instance<P.FoldableWithIndex<ReadonlyArrayF>>({
   ...Foldable,
   foldLeftWithIndex,
   foldRightWithIndex,
@@ -125,21 +125,21 @@ export const FoldableWithIndex = HKT.instance<P.FoldableWithIndex<ImmutableArray
 /**
  * @tsplus implicit
  */
-export const FlatMap = HKT.instance<P.FlatMap<ImmutableArrayF>>({
+export const FlatMap = HKT.instance<P.FlatMap<ReadonlyArrayF>>({
   ...Functor,
   flatMap,
 });
 /**
  * @tsplus implicit
  */
-export const Monad = HKT.instance<P.Monad<ImmutableArrayF>>({
+export const Monad = HKT.instance<P.Monad<ReadonlyArrayF>>({
   ...Applicative,
   ...FlatMap,
 });
 /**
  * @tsplus implicit
  */
-export const Traversable = HKT.instance<P.Traversable<ImmutableArrayF>>({
+export const Traversable = HKT.instance<P.Traversable<ReadonlyArrayF>>({
   ...Functor,
   ...Foldable,
   traverse,
@@ -147,7 +147,7 @@ export const Traversable = HKT.instance<P.Traversable<ImmutableArrayF>>({
 /**
  * @tsplus implicit
  */
-export const TraversableWithIndex = HKT.instance<P.TraversableWithIndex<ImmutableArrayF>>({
+export const TraversableWithIndex = HKT.instance<P.TraversableWithIndex<ReadonlyArrayF>>({
   ...Traversable,
   ...FoldableWithIndex,
   ...FunctorWithIndex,
@@ -156,7 +156,7 @@ export const TraversableWithIndex = HKT.instance<P.TraversableWithIndex<Immutabl
 /**
  * @tsplus implicit
  */
-export const Witherable = HKT.instance<P.Witherable<ImmutableArrayF>>({
+export const Witherable = HKT.instance<P.Witherable<ReadonlyArrayF>>({
   ...Traversable,
   ...Filterable,
   wither,
@@ -165,7 +165,7 @@ export const Witherable = HKT.instance<P.Witherable<ImmutableArrayF>>({
 /**
  * @tsplus implicit
  */
-export const WitherableWithIndex = HKT.instance<P.WitherableWithIndex<ImmutableArrayF>>({
+export const WitherableWithIndex = HKT.instance<P.WitherableWithIndex<ReadonlyArrayF>>({
   ...TraversableWithIndex,
   ...FilterableWithIndex,
   ...Witherable,

package/_src/collection/immutable/ReadonlyArray.ts

@@ -0,0 +1,12 @@
+// codegen:start { preset: barrel, include: ./ReadonlyArray/*.ts }
+export * from "./ReadonlyArray/api.js"
+export * from "./ReadonlyArray/constructors.js"
+export * from "./ReadonlyArray/definition.js"
+export * from "./ReadonlyArray/instances.js"
+// codegen:end
+
+// codegen:start { preset: barrel, include: ./ReadonlyArray/api/*.ts }
+export * from "./ReadonlyArray/api/chunksOf.js"
+export * from "./ReadonlyArray/api/splitAt.js"
+export * from "./ReadonlyArray/api/splitWhere.js"
+// codegen:end