@fncts/base 0.0.20 → 0.0.21

package/_src/collection/immutable/ImmutableArray/derivations.ts

@@ -26,3 +26,16 @@ export function deriveDecoder<A extends ImmutableArray<any>>(
 ): Decoder<A> {
   return Decoder((u) => array.decode(u).map((as) => new ImmutableArray(as) as A), `ImmutableArray<${elem.label}>`);
 }
+
+/**
+ * @tsplus derive fncts.Encoder[fncts.ImmutableArray]<_> 10
+ */
+export function deriveEncoder<A extends ImmutableArray<any>>(
+  ...[element]: [A] extends [ImmutableArray<infer _A>]
+    ? Check<Check.IsEqual<A, ImmutableArray<_A>>> extends Check.True
+      ? [element: Encoder<_A>]
+      : never
+    : never
+): Encoder<A> {
+  return Encoder((inp) => inp._array.map((a) => element.encode(a)));
+}

package/_src/collection/immutable/ImmutableArray/instances.ts

@@ -4,148 +4,133 @@ import type * as P from "@fncts/base/typeclass";
 import type { Check } from "@fncts/typelevel/Check";
 
 import {
-  alignWith_,
-  alt_,
-  cross_,
-  crossWith_,
-  filter_,
-  filterMap_,
-  filterMapWithIndex_,
-  filterWithIndex_,
-  flatMap_,
-  foldLeft_,
-  foldLeftWithIndex_,
-  foldRight_,
-  foldRightWithIndex_,
-  map_,
-  mapWithIndex_,
-  partition_,
-  partitionMap_,
-  partitionMapWithIndex_,
-  partitionWithIndex_,
-  traverse_,
-  traverseWithIndex_,
+  alignWith,
+  alt,
+  cross,
+  crossWith,
+  filter,
+  filterMap,
+  filterMapWithIndex,
+  filterWithIndex,
+  flatMap,
+  foldLeft,
+  foldLeftWithIndex,
+  foldRight,
+  foldRightWithIndex,
+  map,
+  mapWithIndex,
+  partition,
+  partitionMap,
+  partitionMapWithIndex,
+  partitionWithIndex,
+  traverse,
+  traverseWithIndex,
   wilt,
   wiltWithIndex,
   wither,
   witherWithIndex,
 } from "@fncts/base/collection/immutable/ImmutableArray/api";
 import { empty } from "@fncts/base/collection/immutable/ImmutableArray/constructors";
-import { isImmutableArray } from "@fncts/base/collection/immutable/ImmutableArray/definition";
-import { CompoundError, OptionalIndexError, PrimitiveError } from "@fncts/base/data/DecodeError";
-import { Decoder } from "@fncts/base/data/Decoder";
 
 /**
  * @tsplus implicit
  */
 export const Align = HKT.instance<P.Align<ImmutableArrayF>>({
-  map: map_,
-  alignWith: alignWith_,
+  map,
+  alignWith,
   nil: empty,
 });
-
 /**
  * @tsplus implicit
  */
 export const Functor = HKT.instance<P.Functor<ImmutableArrayF>>({
-  map: map_,
+  map,
 });
-
 /**
  * @tsplus implicit
  */
 export const FunctorWithIndex = HKT.instance<P.FunctorWithIndex<ImmutableArrayF>>({
-  map: map_,
-  mapWithIndex: mapWithIndex_,
+  map,
+  mapWithIndex,
 });
-
 /**
  * @tsplus implicit
  */
 export const Apply = HKT.instance<P.Apply<ImmutableArrayF>>({
-  map: map_,
-  zip: cross_,
-  zipWith: crossWith_,
+  map,
+  zip: cross,
+  zipWith: crossWith,
 });
-
 /**
  * @tsplus implicit
  */
 export const Applicative = HKT.instance<P.Applicative<ImmutableArrayF>>({
-  map: map_,
-  zip: cross_,
-  zipWith: crossWith_,
+  map,
+  zip: cross,
+  zipWith: crossWith,
   pure: (a) => ImmutableArray(a),
 });
-
 /**
  * @tsplus implicit
  */
 export const Alt = HKT.instance<P.Alt<ImmutableArrayF>>({
-  map: map_,
-  alt: alt_,
+  map,
+  alt,
 });
-
 /**
  * @tsplus implicit
  */
 export const Alternative = HKT.instance<P.Alternative<ImmutableArrayF>>({
-  map: map_,
-  zip: cross_,
-  zipWith: crossWith_,
+  map,
+  zip: cross,
+  zipWith: crossWith,
   pure: (a) => ImmutableArray(a),
-  alt: alt_,
+  alt,
   nil: empty,
 });
-
 /**
  * @tsplus implicit
  */
 export const Filterable = HKT.instance<P.Filterable<ImmutableArrayF>>({
-  map: map_,
-  filter: filter_,
-  filterMap: filterMap_,
-  partition: partition_,
-  partitionMap: partitionMap_,
+  map,
+  filter: filter,
+  filterMap: filterMap,
+  partition: partition,
+  partitionMap: partitionMap,
 });
-
 /**
  * @tsplus implicit
  */
 export const FilterableWithIndex = HKT.instance<P.FilterableWithIndex<ImmutableArrayF>>({
   ...FunctorWithIndex,
   ...Filterable,
-  filterWithIndex: filterWithIndex_,
-  filterMapWithIndex: filterMapWithIndex_,
-  partitionWithIndex: partitionWithIndex_,
-  partitionMapWithIndex: partitionMapWithIndex_,
+  filterWithIndex: filterWithIndex,
+  filterMapWithIndex: filterMapWithIndex,
+  partitionWithIndex: partitionWithIndex,
+  partitionMapWithIndex: partitionMapWithIndex,
 });
-
 /**
  * @tsplus implicit
  */
 export const Foldable = HKT.instance<P.Foldable<ImmutableArrayF>>({
-  foldLeft: foldLeft_,
-  foldRight: foldRight_,
+  foldLeft,
+  foldRight,
 });
-
 /**
  * @tsplus implicit
  */
 export const FoldableWithIndex = HKT.instance<P.FoldableWithIndex<ImmutableArrayF>>({
   ...Foldable,
-  foldLeftWithIndex: foldLeftWithIndex_,
-  foldRightWithIndex: foldRightWithIndex_,
+  foldLeftWithIndex,
+  foldRightWithIndex,
 });
-
 /**
  * @tsplus implicit
  */
 export const FlatMap = HKT.instance<P.FlatMap<ImmutableArrayF>>({
   ...Functor,
-  flatMap: flatMap_,
+  flatMap,
 });
-
 /**
  * @tsplus implicit
  */
@@ -153,16 +138,14 @@ export const Monad = HKT.instance<P.Monad<ImmutableArrayF>>({
   ...Applicative,
   ...FlatMap,
 });
-
 /**
  * @tsplus implicit
  */
 export const Traversable = HKT.instance<P.Traversable<ImmutableArrayF>>({
   ...Functor,
   ...Foldable,
-  traverse: traverse_,
+  traverse,
 });
-
 /**
  * @tsplus implicit
  */
@@ -170,9 +153,8 @@ export const TraversableWithIndex = HKT.instance<P.TraversableWithIndex<Immutabl
   ...Traversable,
   ...FoldableWithIndex,
   ...FunctorWithIndex,
-  traverseWithIndex: traverseWithIndex_,
+  traverseWithIndex,
 });
-
 /**
  * @tsplus implicit
  */
@@ -182,7 +164,6 @@ export const Witherable = HKT.instance<P.Witherable<ImmutableArrayF>>({
   wither,
   wilt,
 });
-
 /**
  * @tsplus implicit
  */

package/_src/collection/immutable/ImmutableArray.ts

@@ -5,7 +5,6 @@ export * from "./ImmutableArray/definition.js";
 export * from "./ImmutableArray/derivations.js";
 export * from "./ImmutableArray/instances.js";
 // codegen:end
-
 // codegen:start { preset: barrel, include: ./ImmutableArray/api/*.ts }
 export * from "./ImmutableArray/api/chunksOf.js";
 export * from "./ImmutableArray/api/slice.js";