test.ts

import { Show } from "@fp-ts/codec/Show"
import * as C from "@fp-ts/data/Context"

interface Meta<P> {
  meta: P
}

interface MetaSchema<C> extends Meta<unknown> {
  _tag: unknown
  _C?: C
}

function make<T extends Meta<unknown>>(_tag: C.Tag<T>, meta: T["meta"]): MetaSchema<T> {
  return { _tag, meta }
}

interface StringType extends Meta<{}> {}
export const StringType = C.Tag<StringType>()
export const string: MetaSchema<StringType> = make(StringType, {})

interface MinLengthRefinement extends Meta<{ of: Meta<unknown>; length: number }> {}
export const MinLengthRefinement = C.Tag<MinLengthRefinement>()
export function minLength<P>(
  of: MetaSchema<P>,
  length: number
): MetaSchema<P | MinLengthRefinement> {
  return make(MinLengthRefinement, { of, length })
}

interface ArrayType extends Meta<{ of: Meta<unknown> }> {}
export const ArrayType = C.Tag<ArrayType>()
export function array<P>(of: MetaSchema<P>): MetaSchema<P | ArrayType> {
  return make(ArrayType, { of })
}


interface ShowBuilder<T>{
  build: (meta: Meta<T>) => Show<any>
}

function showFor<C>(schema: MetaSchema<C>) {
  return (context: C.Context<C extends infer T ? ShowBuilder<T> : never>): Show<any> {
    
  }
}

const schema = array(minLength(string, 3))
const show = showFor(schema)