import { Variant, variant } from "variant-ts";

type Connection =
  | Variant<"IPV4", [number, number, number, number]>
  | Variant<"IPV6", string>;

let ip = variant<Connection>("IPV4", [127, 0, 0, 1]);

import { Variant, variant, pattern } from "variant-ts";
import { match } form "ts-pattern";

type State = {
    name: string,
    age: number,
    messages: string[]
}

type Action =
    Variant<"ChangeName", string>
    | Variant<"ChangeAge", number>
    | Variant<"AddMessage", string>

function reducer(state: State, action: Action): State {
    return match(action)
        .with(pattern("ChangeName"), res => { return { name: res.val, ...state } })
        .with(pattern("ChangeAge"), res => { return { age: res.val, ...state } })
        .with(pattern("AddMessage"), res => { return { messages: [...state.messages, res.val], ...state } })
        .exhaustive()
}

let initial_state = {
    name: "John Doe",
    age: 24,
    messages: ["Hey, how are you?", "See you"]
}

let new_state = reducer(initial_state, variant<Action>("AddMessage", "Variants are awesome"))

import { none, some } from "variant-ts";

const one = some("foo");
const two = none();

const three = one.map((x) => x.concat("bar"));
const four = two.map((x) => x.concat("bar"));

expect(three.val).to.equal("foobar");
expect(four.val).to.equal(undefined);

import { err, ok } from "variant-ts";

const one = ok("foo");
const two = err("error");

const three = one.map((x) => x.concat("bar"));
const four = two.map((x) => x.concat("bar"));

expect(three.val).to.equal("foobar");
expect(four.val).to.equal("error");