Function Chunk

packages/effect/src/Schema.ts:11537–11591

(value: Value)

 * @since 3.10.0
 */
export function Chunk<Value extends Constraint>(value: Value): Chunk<Value> {
  const schema = declareConstructor<
    Chunk_.Chunk<Value["Type"]>,
    Chunk_.Chunk<Value["Encoded"]>,
    ChunkIso<Value>
  >()(
    [value],
    ([value]) => {
      const values = ArraySchema(value)
      return (input, ast, options) => {
        if (Chunk_.isChunk(input)) {
          return Effect.mapBothEager(
            SchemaParser.decodeUnknownEffect(values)(Arr.fromIterable(input), options),
            {
              onSuccess: Chunk_.fromIterable,
              onFailure: (issue) => SchemaIssue.makeCompositeAtKey(ast, "values", issue, input, options)
            }
          )
        }
        return Effect.fail(new SchemaIssue.InvalidType(ast, input, options))
      }
    },
    {
      representation: {
        id: "effect/schema/Chunk",
        payload: null
      },
      toCode: ({ typeParameters }) => ({
        runtime: `Schema.Chunk(${typeParameters[0].runtime})`,
        Type: `Chunk.Chunk<${typeParameters[0].Type}>`
      }),
      expected: "Chunk",
      toCodec: ([value]) =>
        link<Chunk_.Chunk<Value["Encoded"]>>()(
          ArraySchema(value),
          SchemaTransformation.transform({
            decode: Chunk_.fromIterable,
            encode: Arr.fromIterable
          })
        ),
      toArbitrary: ([value]) => (fc, ctx) =>
        collectionArbitrary(fc, ctx, value.arbitrary, value.terminal, Chunk_.fromIterable),
      toEquivalence: ([value]) => Chunk_.makeEquivalence(value),
      toFormatter: ([value]) => (t) => {
        const size = Chunk_.size(t)
        if (size === 0) {
          return "Chunk(0) {}"
        }
        const values = globalThis.Array.from(t).sort().map((v) => `${value(v)}`)
        return `Chunk(${size}) { ${values.join(", ")} }`
      }
    }
  )
  return make(schema.ast, { value })
}

/**
 * Reviver for persisted {@link Chunk} declarations.