export type URI = typeof URI

export type Validation<L, A> = Failure<L, A> | Success<L, A>

import { Validation, getApplicative, success, failure } from 'fp-ts/lib/Validation'
import { NonEmptyArray, getSemigroup } from 'fp-ts/lib/NonEmptyArray'

interface Person {
  readonly name: string
  readonly age: number
}

// curried constructor
const person = (name: string) => (age: number): Person => ({ name, age })

// validators
function validateName(input: string): Validation<NonEmptyArray<string>, string> {
  return input.length === 0 ? failure(new NonEmptyArray('Invalid name: empty string', [])) : success(input)
}
function validateAge(input: string): Validation<NonEmptyArray<string>, number> {
  const n = parseFloat(input)
  if (isNaN(n)) {
    return failure(new NonEmptyArray(`Invalid age: not a number ${input}`, []))
  }
  return n % 1 !== 0 ? failure(new NonEmptyArray(`Invalid age: not an integer ${n}`, [])) : success(n)
}

// get an `Applicative` instance for Validation<NonEmptyArray<string>, ?>
const A = getApplicative(getSemigroup<string>())

function validatePerson(input: Record<string, string>): Validation<NonEmptyArray<string>, Person> {
  return A.ap(validateName(input['name']).map(person), validateAge(input['age']))
}

assert.deepStrictEqual(
  validatePerson({ name: '', age: '1.2' }),
  failure(new NonEmptyArray('Invalid name: empty string', ['Invalid age: not an integer 1.2']))
)

assert.deepStrictEqual(validatePerson({ name: 'Giulio', age: '44' }), success({ name: 'Giulio', age: 44 }))

export class Failure<L, A> {
  constructor(readonly value: L) { ... }
  ...
}

map<B>(f: (a: A) => B): Validation<L, B> { ... }

bimap<V, B>(f: (l: L) => V, g: (a: A) => B): Validation<V, B> { ... }

reduce<B>(b: B, f: (b: B, a: A) => B): B { ... }

fold<B>(failure: (l: L) => B, success: (a: A) => B): B { ... }

getOrElse(a: A): A { ... }

getOrElseL(f: (l: L) => A): A { ... }

mapFailure<M>(f: (l: L) => M): Validation<M, A> { ... }

swap(): Validation<A, L> { ... }

inspect(): string { ... }

toString(): string { ... }

isFailure(): this is Failure<L, A> { ... }

isSuccess(): this is Success<L, A> { ... }

export class Success<L, A> {
  constructor(readonly value: A) { ... }
  ...
}

map<B>(f: (a: A) => B): Validation<L, B> { ... }

bimap<V, B>(f: (l: L) => V, g: (a: A) => B): Validation<V, B> { ... }

reduce<B>(b: B, f: (b: B, a: A) => B): B { ... }

fold<B>(failure: (l: L) => B, success: (a: A) => B): B { ... }

getOrElse(a: A): A { ... }

getOrElseL(f: (l: L) => A): A { ... }

mapFailure<M>(f: (l: L) => M): Validation<M, A> { ... }

swap(): Validation<A, L> { ... }

inspect(): string { ... }

toString(): string { ... }

isFailure(): this is Failure<L, A> { ... }

isSuccess(): this is Success<L, A> { ... }

export const URI = ...

export const validation: Functor2<URI> & Bifunctor2<URI> & Foldable2v2<URI> & Traversable2v2<URI> = ...

export const failure = <L, A>(l: L): Validation<L, A> => ...

export const fromEither = <L, A>(e: Either<L, A>): Validation<L, A> => ...

export function fromPredicate<L, A, B extends A>(
  predicate: Refinement<A, B>,
  f: (a: A) => L
): (a: A) => Validation<L, B>
export function fromPredicate<L, A>(predicate: Predicate<A>, f: (a: A) => L): (a: A) => Validation<L, A> { ... }

export const getAlt = <L>(S: Semigroup<L>): Alt2C<URI, L> => ...

export const getApplicative = <L>(S: Semigroup<L>): Applicative2C<URI, L> => ...

import { Validation, success, failure, getApplicative } from 'fp-ts/lib/Validation'
import { getArraySemigroup } from 'fp-ts/lib/Semigroup'

interface Person {
  name: string
  age: number
}

const person = (name: string) => (age: number): Person => ({ name, age })

const validateName = (name: string): Validation<string[], string> =>
  name.length === 0 ? failure(['invalid name']) : success(name)

const validateAge = (age: number): Validation<string[], number> =>
  age > 0 && age % 1 === 0 ? success(age) : failure(['invalid age'])

const A = getApplicative(getArraySemigroup<string>())

const validatePerson = (name: string, age: number): Validation<string[], Person> =>
  A.ap(A.map(validateName(name), person), validateAge(age))

assert.deepStrictEqual(validatePerson('Nicolas Bourbaki', 45), success({ name: 'Nicolas Bourbaki', age: 45 }))
assert.deepStrictEqual(validatePerson('Nicolas Bourbaki', -1), failure(['invalid age']))
assert.deepStrictEqual(validatePerson('', 0), failure(['invalid name', 'invalid age']))

export function getCompactable<L>(ML: Monoid<L>): Compactable2C<URI, L> { ... }

export function getFilterable<L>(ML: Monoid<L>): Filterable2C<URI, L> { ... }

export const getMonad = <L>(S: Semigroup<L>): Monad2C<URI, L> => ...

export const getMonoid = <L, A>(SL: Semigroup<L>, SA: Monoid<A>): Monoid<Validation<L, A>> => ...

export const getSemigroup = <L, A>(SL: Semigroup<L>, SA: Semigroup<A>): Semigroup<Validation<L, A>> => ...

export const getSetoid = <L, A>(SL: Setoid<L>, SA: Setoid<A>): Setoid<Validation<L, A>> => ...

export function getWitherable<L>(ML: Monoid<L>): Witherable2C<URI, L> { ... }

export const isFailure = <L, A>(fa: Validation<L, A>): fa is Failure<L, A> => ...

export const isSuccess = <L, A>(fa: Validation<L, A>): fa is Success<L, A> => ...

export const success = <L, A>(a: A): Validation<L, A> => ...