import * as covariant from "@effect/typeclass/Covariant" import type * as invariant from "@effect/typeclass/Invariant" import type * as monoid from "@effect/typeclass/Monoid" import * as Effect from "effect/Effect" import * as Equal from "effect/Equal" import { dual, pipe } from "effect/Function" import * as Hash from "effect/Hash" import * as List from "effect/List" import * as Option from "effect/Option" import type * as DocStream from "../DocStream.js" // ----------------------------------------------------------------------------- // Models // ----------------------------------------------------------------------------- const DocStreamSymbolKey = "@effect/printer/DocStream" /** @internal */ export const DocStreamTypeId: DocStream.DocStreamTypeId = Symbol.for( DocStreamSymbolKey ) as DocStream.DocStreamTypeId const protoHash = { FailedStream: (_: DocStream.FailedStream) => pipe( Hash.string("@effect/printer/DocStream/FailedStream"), Hash.combine(Hash.string(DocStreamSymbolKey)) ), EmptyStream: (_: DocStream.EmptyStream) => pipe( Hash.string("@effect/printer/DocStream/EmptyStream"), Hash.combine(Hash.string(DocStreamSymbolKey)) ), CharStream: (self: DocStream.CharStream) => pipe( Hash.hash("@effect/printer/DocStream/CharStream"), Hash.combine(Hash.string(DocStreamSymbolKey)), Hash.combine(Hash.string(self.char)), Hash.combine(Hash.hash(self.stream)) ), TextStream: (self: DocStream.TextStream) => pipe( Hash.string("@effect/printer/DocStream/TextStream"), Hash.combine(Hash.string(DocStreamSymbolKey)), Hash.combine(Hash.string(self.text)), Hash.combine(Hash.hash(self.stream)) ), LineStream: (self: DocStream.LineStream) => pipe( Hash.string("@effect/printer/DocStream/LineStream"), Hash.combine(Hash.string(DocStreamSymbolKey)), Hash.combine(Hash.hash(self.stream)) ), PushAnnotationStream: (self: DocStream.PushAnnotationStream) => pipe( Hash.string("@effect/printer/DocStream/PopAnnotationStream"), Hash.combine(Hash.string(DocStreamSymbolKey)), Hash.combine(Hash.hash(self.annotation)), Hash.combine(Hash.hash(self.stream)) ), PopAnnotationStream: (self: DocStream.PopAnnotationStream) => pipe( Hash.string("@effect/printer/DocStream/PopAnnotationStream"), Hash.combine(Hash.string(DocStreamSymbolKey)), Hash.combine(Hash.hash(self.stream)) ) } const protoEqual = { FailedStream: (self: DocStream.FailedStream, that: unknown) => isDocStream(that) && that._tag === "FailedStream", EmptyStream: (self: DocStream.EmptyStream, that: unknown) => isDocStream(that) && that._tag === "EmptyStream", CharStream: (self: DocStream.CharStream, that: unknown) => isDocStream(that) && that._tag === "CharStream" && self.char === that.char && Equal.equals(self.stream, that.stream), TextStream: (self: DocStream.TextStream, that: unknown) => isDocStream(that) && that._tag === "TextStream" && self.text === that.text && Equal.equals(self.stream, that.stream), LineStream: (self: DocStream.LineStream, that: unknown) => isDocStream(that) && that._tag === "LineStream" && Equal.equals(self.stream, that.stream), PushAnnotationStream: (self: DocStream.PushAnnotationStream, that: unknown) => isDocStream(that) && that._tag === "PushAnnotationStream" && Equal.equals(self.annotation, that.annotation) && Equal.equals(self.stream, that.stream), PopAnnotationStream: (self: DocStream.PopAnnotationStream, that: unknown) => isDocStream(that) && that._tag === "PopAnnotationStream" && Equal.equals(self.stream, that.stream) } const proto = { [DocStreamTypeId]: { _A: (_: never) => _ }, [Hash.symbol](this: DocStream.DocStream): number { return Hash.cached(this, protoHash[this._tag](this as any)) }, [Equal.symbol](this: DocStream.DocStream, that: unknown): boolean { return protoEqual[this._tag](this as any, that) } } // ----------------------------------------------------------------------------- // Refinements // ----------------------------------------------------------------------------- /** @internal */ export const isDocStream = (u: unknown): u is DocStream.DocStream => typeof u === "object" && u != null && DocStreamTypeId in u /** @internal */ export const isFailedStream = ( self: DocStream.DocStream ): self is DocStream.FailedStream => self._tag === "FailedStream" /** @internal */ export const isEmptyStream = (self: DocStream.DocStream): self is DocStream.EmptyStream => self._tag === "EmptyStream" /** @internal */ export const isCharStream = (self: DocStream.DocStream): self is DocStream.CharStream => self._tag === "CharStream" /** @internal */ export const isTextStream = (self: DocStream.DocStream): self is DocStream.TextStream => self._tag === "TextStream" /** @internal */ export const isLineStream = (self: DocStream.DocStream): self is DocStream.LineStream => self._tag === "LineStream" /** @internal */ export const isPushAnnotationStream = ( self: DocStream.DocStream ): self is DocStream.PushAnnotationStream => self._tag === "PushAnnotationStream" /** @internal */ export const isPopAnnotationStream = ( self: DocStream.DocStream ): self is DocStream.PopAnnotationStream => self._tag === "PopAnnotationStream" // ----------------------------------------------------------------------------- // Constructors // ----------------------------------------------------------------------------- /** @internal */ export const failed: DocStream.DocStream = (() => { const op = Object.create(proto) op._tag = "FailedStream" return op })() /** @internal */ export const empty: DocStream.DocStream = (() => { const op = Object.create(proto) op._tag = "EmptyStream" return op })() /** @internal */ export const char = dual< (char: string) => (self: DocStream.DocStream) => DocStream.DocStream, (self: DocStream.DocStream, char: string) => DocStream.DocStream >(2, (self, char) => { const op = Object.create(proto) op._tag = "CharStream" op.char = char op.stream = self return op }) /** @internal */ export const text = dual< (text: string) => (self: DocStream.DocStream) => DocStream.DocStream, (self: DocStream.DocStream, text: string) => DocStream.DocStream >(2, (self, text) => { const op = Object.create(proto) op._tag = "TextStream" op.text = text op.stream = self return op }) /** @internal */ export const line = dual< (indentation: number) => (self: DocStream.DocStream) => DocStream.DocStream, (self: DocStream.DocStream, indentation: number) => DocStream.DocStream >(2, (self, indentation) => { const op = Object.create(proto) op._tag = "LineStream" op.indentation = indentation op.stream = self return op }) /** @internal */ export const pushAnnotation = dual< (annotation: B) => (self: DocStream.DocStream) => DocStream.DocStream, (self: DocStream.DocStream, annotation: B) => DocStream.DocStream >(2, (self, annotation) => { const op = Object.create(proto) op._tag = "PushAnnotationStream" op.annotation = annotation op.stream = self return op }) /** @internal */ export const popAnnotation = (stream: DocStream.DocStream): DocStream.DocStream => { const op = Object.create(proto) op._tag = "PopAnnotationStream" op.stream = stream return op } // ----------------------------------------------------------------------------- // Annotations // ----------------------------------------------------------------------------- type AnnotationRemoval = "Remove" | "DontRemove" const Remove: AnnotationRemoval = "Remove" const DontRemove: AnnotationRemoval = "DontRemove" /** @internal */ export const alterAnnotations = dual< (f: (a: A) => Option.Option) => (self: DocStream.DocStream) => DocStream.DocStream, (self: DocStream.DocStream, f: (a: A) => Option.Option) => DocStream.DocStream >(2, (self, f) => Effect.runSync(alterAnnotationSafe(self, f, List.nil()))) const alterAnnotationSafe = ( self: DocStream.DocStream, f: (a: A) => Option.Option, stack: List.List ): Effect.Effect> => { switch (self._tag) { case "CharStream": { return Effect.map( Effect.suspend(() => alterAnnotationSafe(self.stream, f, stack)), char(self.char) ) } case "TextStream": { return Effect.map( Effect.suspend(() => alterAnnotationSafe(self.stream, f, stack)), text(self.text) ) } case "LineStream": { return Effect.map( Effect.suspend(() => alterAnnotationSafe(self.stream, f, stack)), line(self.indentation) ) } case "PushAnnotationStream": { const altered = f(self.annotation) if (Option.isSome(altered)) { return Effect.map( Effect.suspend(() => alterAnnotationSafe(self.stream, f, List.prepend(stack, DontRemove))), pushAnnotation(altered.value) ) } return Effect.suspend(() => alterAnnotationSafe(self.stream, f, List.prepend(stack, Remove))) } case "PopAnnotationStream": { if (List.isNil(stack)) { return Effect.dieMessage( "BUG: DocStream.alterAnnotations - received empty stack to pop from" + " - please report an issue at https://github.com/Effect-TS/printer/issues" ) } if (stack.head === DontRemove) { return Effect.map( Effect.suspend(() => alterAnnotationSafe(self.stream, f, stack.tail)), popAnnotation ) } return Effect.suspend(() => alterAnnotationSafe(self.stream, f, stack.tail)) } default: { return Effect.succeed(self as unknown as DocStream.DocStream) } } } /** @internal */ export const reAnnotate = dual< (f: (a: A) => B) => (self: DocStream.DocStream) => DocStream.DocStream, (self: DocStream.DocStream, f: (a: A) => B) => DocStream.DocStream >(2, (self, f) => Effect.runSync(reAnnotateSafe(self, f))) const reAnnotateSafe = ( self: DocStream.DocStream, f: (a: A) => B ): Effect.Effect> => { switch (self._tag) { case "CharStream": { return Effect.map( Effect.suspend(() => reAnnotateSafe(self.stream, f)), char(self.char) ) } case "TextStream": { return Effect.map( Effect.suspend(() => reAnnotateSafe(self.stream, f)), text(self.text) ) } case "LineStream": { return Effect.map( Effect.suspend(() => reAnnotateSafe(self.stream, f)), line(self.indentation) ) } case "PushAnnotationStream": { return Effect.map( Effect.suspend(() => reAnnotateSafe(self.stream, f)), pushAnnotation(f(self.annotation)) ) } case "PopAnnotationStream": { return Effect.suspend(() => reAnnotateSafe(self.stream, f)) } default: { return Effect.succeed(self as unknown as DocStream.DocStream) } } } /** @internal */ export const unAnnotate = (self: DocStream.DocStream): DocStream.DocStream => Effect.runSync(unAnnotateSafe(self)) const unAnnotateSafe = ( self: DocStream.DocStream ): Effect.Effect> => { switch (self._tag) { case "CharStream": { return Effect.map( Effect.suspend(() => unAnnotateSafe(self.stream)), char(self.char) ) } case "TextStream": { return Effect.map( Effect.suspend(() => unAnnotateSafe(self.stream)), text(self.text) ) } case "LineStream": { return Effect.map( Effect.suspend(() => unAnnotateSafe(self.stream)), line(self.indentation) ) } case "PushAnnotationStream": case "PopAnnotationStream": { return Effect.suspend(() => unAnnotateSafe(self.stream)) } default: { return Effect.succeed(self as unknown as DocStream.DocStream) } } } // ----------------------------------------------------------------------------- // Folding // ----------------------------------------------------------------------------- /** @internal */ export const foldMap = dual< (M: monoid.Monoid, f: (a: A) => M) => (self: DocStream.DocStream) => M, (self: DocStream.DocStream, M: monoid.Monoid, f: (a: A) => M) => M >(3, (self, M, f) => Effect.runSync(foldMapSafe(self, M, f))) const foldMapSafe = ( self: DocStream.DocStream, M: monoid.Monoid, f: (a: A) => M ): Effect.Effect => { switch (self._tag) { case "CharStream": { return Effect.suspend(() => foldMapSafe(self.stream, M, f)) } case "TextStream": { return Effect.suspend(() => foldMapSafe(self.stream, M, f)) } case "LineStream": { return Effect.suspend(() => foldMapSafe(self.stream, M, f)) } case "PushAnnotationStream": { return Effect.map( Effect.suspend(() => foldMapSafe(self.stream, M, f)), (that) => M.combine(f(self.annotation), that) ) } case "PopAnnotationStream": { return Effect.suspend(() => foldMapSafe(self.stream, M, f)) } default: { return Effect.succeed(M.empty) } } } /** @internal */ export const match = dual< ( patterns: { readonly FailedStream: () => R readonly EmptyStream: () => R readonly CharStream: (char: string, stream: DocStream.DocStream) => R readonly TextStream: (text: string, stream: DocStream.DocStream) => R readonly LineStream: (indentation: number, stream: DocStream.DocStream) => R readonly PushAnnotationStream: (annotation: A, stream: DocStream.DocStream) => R readonly PopAnnotationStream: (stream: DocStream.DocStream) => R } ) => (self: DocStream.DocStream) => R, ( self: DocStream.DocStream, patterns: { readonly FailedStream: () => R readonly EmptyStream: () => R readonly CharStream: (char: string, stream: DocStream.DocStream) => R readonly TextStream: (text: string, stream: DocStream.DocStream) => R readonly LineStream: (indentation: number, stream: DocStream.DocStream) => R readonly PushAnnotationStream: (annotation: A, stream: DocStream.DocStream) => R readonly PopAnnotationStream: (stream: DocStream.DocStream) => R } ) => R >(2, (self, patterns) => { switch (self._tag) { case "FailedStream": { return patterns.FailedStream() } case "EmptyStream": { return patterns.EmptyStream() } case "CharStream": { return patterns.CharStream(self.char, self.stream) } case "TextStream": { return patterns.TextStream(self.text, self.stream) } case "LineStream": { return patterns.LineStream(self.indentation, self.stream) } case "PushAnnotationStream": { return patterns.PushAnnotationStream(self.annotation, self.stream) } case "PopAnnotationStream": { return patterns.PopAnnotationStream(self.stream) } } }) // ----------------------------------------------------------------------------- // Instances // ----------------------------------------------------------------------------- /** @internal */ export const map: { (f: (a: A) => B): (self: DocStream.DocStream) => DocStream.DocStream (self: DocStream.DocStream, f: (a: A) => B): DocStream.DocStream } = reAnnotate /** @internal */ export const imap = covariant.imap(map) /** @internal */ export const Covariant: covariant.Covariant = { map, imap } /** @internal */ export const Invariant: invariant.Invariant = { imap }