plum

use std::collections::BTreeMap;

#[derive(Debug, Clone, PartialEq)]

pub enum PlumType {

    TInt,

    TFloat,

    TBool,

    TStr,

    TByte,

    /// `[]Byte` — a fixed builtin, not a monomorphized generic. The checker

    /// only ever produces this for the exact source spelling `[]Byte`

    /// (see `plumTypeFromName`); there is no general `[]T` for other `T`.

    TByteSlice,

    TUnit,

    TVar(String),

    TFun(Vec<PlumType>, Box<PlumType>),

    TNamed(String),

    /// The type of a variadic parameter, e.g. `...Int` -> `TVariadic(TInt)`.

    /// Appears in exactly two places: as the trailing entry of a `TFun`'s

    /// param-types list (call-site arity/type checking), and as the type bound

    /// to the param's name inside the function body. Its only legal use inside

    /// a body is as a `for` loop's iterable — no other `unify`/`inferExpr` arm

    /// handles it, so any other use is a type error by construction.

    TVariadic(Box<PlumType>),

}

impl std::fmt::Display for PlumType {

    fn fmt(&self, f: &mut std::fmt::Formatter<'_>) -> std::fmt::Result {

        match self {

            PlumType::TInt => write!(f, "Int"),

            PlumType::TFloat => write!(f, "Float"),

            PlumType::TBool => write!(f, "Bool"),

            PlumType::TStr => write!(f, "Str"),

            PlumType::TByte => write!(f, "Byte"),

            PlumType::TByteSlice => write!(f, "[]Byte"),

            PlumType::TUnit => write!(f, "Unit"),

            PlumType::TVar(n) => write!(f, "{}", n),

            PlumType::TFun(ps, r) => {

                let ps_str: Vec<_> = ps.iter().map(|p| p.to_string()).collect();

                write!(f, "({}) -> {}", ps_str.join(", "), r)

            }

            PlumType::TNamed(n) => write!(f, "{}", n),

            PlumType::TVariadic(inner) => write!(f, "...{}", inner),

        }

    }

}

#[derive(Debug, Clone, PartialEq)]

pub struct TypeScheme {

    pub vars: Vec<String>,

    pub body: Box<PlumType>,

}

impl TypeScheme {

    pub fn mono(t: PlumType) -> Self {

        TypeScheme { vars: vec![], body: Box::new(t) }

    }

}

pub type TypeEnv = BTreeMap<String, TypeScheme>;

pub struct InferState {

    pub counter: u64,

}

impl InferState {

    pub fn new() -> Self {

        InferState { counter: 0 }

    }

    pub fn freshVar(&mut self) -> String {

        let name = format!("a{}", self.counter);

        self.counter += 1;

        name

    }

    pub fn freshType(&mut self) -> PlumType {

        PlumType::TVar(self.freshVar())

    }

}

#[derive(Debug, Clone)]

pub struct CheckError {

    pub message: String,

}

impl std::fmt::Display for CheckError {

    fn fmt(&self, f: &mut std::fmt::Formatter<'_>) -> std::fmt::Result {

        write!(f, "{}", self.message)

    }

}

pub type CheckResult<T> = Result<T, Vec<CheckError>>;