mers/mers_lib/src/program/configs/with_iters.rs

use std::{
    fmt::Display,
    sync::{Arc, Mutex},
};

use crate::{
    data::{
        self,
        function::{Function, FunctionT},
        int::{Int, IntT, INT_MAX},
        Data, MersData, MersType, MersTypeWInfo, Type,
    },
    errors::CheckError,
    info::DisplayInfo,
    program::{self, run::CheckInfo},
};

use super::Config;

impl Config {
    /// Adds functions to deal with iterables
    /// `for_each: fn` executes a function once for each element of the iterable
    /// `map: fn` maps each value in the iterable to a new one by applying a transformation function
    /// `filter: fn` filters the iterable by removing all elements where the filter function doesn't return true
    /// `filter_map: fn` combines filter and map. requires that the function returns ()/(t).
    /// `map_while: fn` maps while the map-function returns (d), ends the iterator once () is returned.
    /// `take: fn` takes at most so many elements from the iterator.
    /// `enumerate: fn` transforms an iterator over T into one over (Int, T), where Int is the index of the element
    /// `any: fn` returns true if any element of the iterator are true
    /// `all: fn` returns true if all elements of the iterator are true
    /// `range_inc: fn` returns an iterable `Range` starting at the first argument, counting up to the second one (inclusive).
    /// `range_exc: fn` returns an iterable `Range` starting at the first argument, counting up to the second one (exclusive).
    pub fn with_iters(self) -> Self {
        self
            .add_type("Range".to_owned(), Err(Arc::new(|str, _i| {
                if let Some((val, end)) = str.split_once("..") {
                    if let (Ok(val), Ok(end)) = (val.trim().parse(), end.trim().parse()) {
                        Ok(RangeT(val, end))
                    } else {
                        Err(CheckError::from(format!("bad Range type, got <{str}> but expected <start..end> where start and end are Ints")))
                    }
                } else {
                    Err(CheckError::from(format!("bad Range type, got <{str}> but expected <start..end>")))
                }.map(|v| Arc::new(Type::new(v)))
            })))
            .add_var("range_inc", Function::new_generic(
                |a, i| {
                    let mut o = Type::empty();
                    for a in &a.types {
                        let a = a.as_any().downcast_ref::<data::tuple::TupleT>().ok_or_else(|| CheckError::from(format!("expected 2- or 3-tuple, but found {}", a.with_info(i))))?;
                        if a.0.len() == 2 {
                            let mut min = None;
                            let mut max = None;
                            for v in a.0[0].types.iter().chain(a.0[1].types.iter()) {
                                let v = v.as_any().downcast_ref::<data::int::IntT>().ok_or_else(|| CheckError::from(format!("expected int as first argument, but got {}", v.with_info(i))))?;
                                if min.is_none_or(|min| min > v.0) {
                                    min = Some(v.0);
                                }
                                if max.is_none_or(|max| max < v.1) {
                                    max = Some(v.1);
                                }
                            }
                            if let (Some(min), Some(max)) = (min, max) {
                                o.add(Arc::new(RangeT(min, max)));
                            }
                        } else {
                            return Err(CheckError::from(format!("expected 2-tuple, but found {}", a.with_info(i))));
                        }
                    }
                    Ok(o)
                }, |a, _| {
                    let a = a.get();
                    let a = a.as_any().downcast_ref::<data::tuple::Tuple>().unwrap();
                    let (v, e) = (a.0[0].get(), a.0[1].get());
                    let (v, e) = (v.as_any().downcast_ref::<data::int::Int>().unwrap(), e.as_any().downcast_ref::<data::int::Int>().unwrap());
                    Ok(Data::new(Range(v.0, e.0)))
                }
            ))
            .add_var("range_exc", Function::new_generic(
                |a, i| {
                    let mut o = Type::empty();
                    for a in &a.types {
                        let a = a.as_any().downcast_ref::<data::tuple::TupleT>().ok_or_else(|| CheckError::from(format!("expected 2- or 3-tuple, but found {}", a.with_info(i))))?;
                        if a.0.len() == 2 {
                            let mut min = None;
                            let mut max = None;
                            for v in a.0[0].types.iter().chain(a.0[1].types.iter()) {
                                let v = v.as_any().downcast_ref::<data::int::IntT>().ok_or_else(|| CheckError::from(format!("expected int as first argument, but got {}", v.with_info(i))))?;
                                if min.is_none_or(|min| min > v.0) {
                                    min = Some(v.0);
                                }
                                if max.is_none_or(|max| max < v.1) {
                                    max = Some(v.1);
                                }
                            }
                            if let (Some(min), Some(max)) = (min, max) {
                                if let Some(max) = max.checked_sub(1) {
                                    o.add(Arc::new(RangeT(min, max)));
                                } else {
                                    o.add(Arc::new(RangeT(min.saturating_add(1), max)));
                                }
                            }
                        } else {
                            return Err(CheckError::from(format!("expected 2-tuple, but found {}", a.with_info(i))));
                        }
                    }
                    Ok(o)
                }, |a, _| {
                    let a = a.get();
                    let a = a.as_any().downcast_ref::<data::tuple::Tuple>().unwrap();
                    let (v, e) = (a.0[0].get(), a.0[1].get());
                    let (v, e) = (v.as_any().downcast_ref::<data::int::Int>().unwrap(), e.as_any().downcast_ref::<data::int::Int>().unwrap());
                    if let Some(e) = e.0.checked_sub(1) {
                        Ok(Data::new(Range(v.0, e)))
                    } else {
                        Ok(Data::new(Range(v.0.saturating_add(1), e.0)))
                    }
                }
            ))
            .add_var("any", genfunc_iter_in_val_out("all".to_string(), data::bool::bool_type(), data::bool::bool_type(), |a, i| {
                for v in a.get().iterable(&i.global).unwrap().map(|v| v.map(|v| v.get().as_any().downcast_ref::<data::bool::Bool>().is_some_and(|v| v.0))) {
                    if v? {
                        return Ok(Data::new(data::bool::Bool(true)));
                    }
                }
                Ok(Data::new(data::bool::Bool(false)))
            }))
            .add_var("all", genfunc_iter_in_val_out("all".to_string(), data::bool::bool_type(), data::bool::bool_type(), |a, i| {
                for v in a.get().iterable(&i.global).unwrap().map(|v| v.map(|v| v.get().as_any().downcast_ref::<data::bool::Bool>().is_some_and(|v| v.0))) {
                    if !v? {
                        return Ok(Data::new(data::bool::Bool(false)));
                    }
                }
                Ok(Data::new(data::bool::Bool(true)))
            }))
            .add_var(
            "for_each",
            data::function::Function {
                info: program::run::Info::neverused(),
                info_check: Arc::new(Mutex::new(CheckInfo::neverused())),
                out: Ok(Arc::new(|a, i| {
                    for a in &a.types {
                        if let Some(tuple) = a.as_any().downcast_ref::<data::tuple::TupleT>() {
                            if let (Some(v), Some(f)) = (tuple.0.get(0), tuple.0.get(1)) {
                                if let (Some(iter), Some(f)) = (
                                    v.iterable(),
                                    f.types
                                        .iter()
                                        .map(|t| {
                                            t.executable()
                                        })
                                        .collect::<Option<Vec<_>>>(),
                                ) {
                                    for f in f {
                                        let _ret = f.o(&iter)?;
                                        // if !ret.is_zero_tuple() {
                                        //     return Err(format!("for_each function must return (), not {ret}").into());
                                        // }
                                    }
                                } else {
                                    return Err(format!(
                                        "for_each called on tuple not containing iterable and function: {} is {}",
                                        v.with_info(i),
                                        if v.iterable().is_some() { "iterable" } else { "not iterable" },
                                    ).into());
                                }
                            } else {
                                return Err(format!(
                                    "for_each called on tuple with len < 2"
                                ).into());
                            }
                        } else {
                            return Err(format!("for_each called on non-tuple").into());
                        }
                    }
                    Ok(Type::empty_tuple())
                })),
                run: Arc::new(|a, i| {
                    if let Some(tuple) = a.get().as_any().downcast_ref::<data::tuple::Tuple>() {
                        if let (Some(v), Some(f)) = (tuple.get(0), tuple.get(1)) {
                            if let Some(iter) = v.get().iterable(&i.global) {
                                let f = f.get();
                                for v in iter {
                                    f.execute(v?, &i.global).unwrap()?;
                                }
                                Ok(Data::empty_tuple())
                            } else {
                                return Err(
                                    "for_each called on tuple not containing iterable and function (not an iterable)".into()
                                );
                            }
                        } else {
                            return Err("for_each called on tuple with len < 2".into());
                        }
                    } else {
                        return Err("for_each called on non-tuple".into());
                    }
                }),
                inner_statements: None,
            },
        )
        .add_var(
            "map",
            genfunc_iter_and_func("map", ItersT::Map, Iters::Map)
        )
        .add_var(
            "filter",
            genfunc_iter_and_func("filter", ItersT::Filter, Iters::Filter),
        )
        .add_var(
            "filter_map",
            genfunc_iter_and_func("filter_map", ItersT::FilterMap, Iters::FilterMap),
        )
        .add_var(
            "map_while",
            genfunc_iter_and_func("map_while", ItersT::MapWhile, Iters::MapWhile),
        )
        .add_var("take", genfunc_iter_and_arg("take", |_: &data::int::IntT| ItersT::Take, |v: &data::int::Int| {
            Iters::Take(v.0.max(0).try_into().unwrap_or(usize::MAX))
        }, &data::int::IntT(0, INT_MAX)))
        .add_var(
            "enumerate",
            data::function::Function {
                info: program::run::Info::neverused(),
                info_check: Arc::new(Mutex::new(CheckInfo::neverused())),
                out: Ok(Arc::new(|a, i| {
                    let data = if let Some(a) = a.iterable() {
                        a
                    } else {
                        return Err(format!("cannot call enumerate on non-iterable type {}.", a.with_info(i)).into());
                    };
                    Ok(Type::new(IterT::new(ItersT::Enumerate, data, i)?))
                })),
                run: Arc::new(|a, _i| Ok(Data::new(Iter(Iters::Enumerate, a.clone())))),
                inner_statements: None,
            },
        )
        .add_var(
            "chain",
            data::function::Function {
                info: program::run::Info::neverused(),
                info_check: Arc::new(Mutex::new(CheckInfo::neverused())),
                out: Ok(Arc::new(|a, i| {
                    let data = if let Some(a) = a.iterable() {
                        a
                    } else {
                        return Err(format!("cannot call chain on non-iterable type {}.", a.with_info(i)).into());
                    };
                    Ok(Type::new(IterT::new(ItersT::Chained, data, i)?))
                })),
                run: Arc::new(|a, _i| Ok(Data::new(Iter(Iters::Chained, a.clone())))),
                inner_statements: None,
            },
        )
    }
}

fn genfunc_iter_and_func(
    name: &'static str,
    ft: impl Fn(FunctionT) -> ItersT + Send + Sync + 'static,
    fd: impl Fn(Data) -> Iters + Send + Sync + 'static,
) -> data::function::Function {
    fn iter_out_arg(
        a: &Type,
        i: &mut CheckInfo,
        name: &str,
        func: impl Fn(FunctionT) -> ItersT + Sync + Send,
    ) -> Result<Type, CheckError> {
        let mut out = Type::empty();
        for t in a.types.iter() {
            if let Some(t) = t.as_any().downcast_ref::<data::tuple::TupleT>() {
                if t.0.len() != 2 {
                    return Err(format!("cannot call {name} on tuple where len != 2").into());
                }
                if let Some(v) = t.0[0].iterable() {
                    for f in t.0[1].types.iter() {
                        if let Some(f) = f.executable() {
                            out.add(Arc::new(IterT::new(func(f), v.clone(), i)?));
                        } else {
                            return Err(format!("cannot call {name} on tuple that isn't (_, function): got {} instead of function as part of {}", t.0[1].with_info(i), a.with_info(i)).into());
                        }
                    }
                } else {
                    return Err(format!(
                        "cannot call {name} on non-iterable type {}, which is part of {}.",
                        t.with_info(i),
                        a.with_info(i)
                    )
                    .into());
                }
            }
        }
        Ok(out)
    }
    data::function::Function {
        info: program::run::Info::neverused(),
        info_check: Arc::new(Mutex::new(CheckInfo::neverused())),
        out: Ok(Arc::new(move |a, i| iter_out_arg(a, i, name, |f| ft(f)))),
        run: Arc::new(move |a, _i| {
            if let Some(tuple) = a.get().as_any().downcast_ref::<data::tuple::Tuple>() {
                if let (Some(v), Some(f)) = (tuple.get(0), tuple.get(1)) {
                    Ok(Data::new(Iter(fd(f.clone()), v.clone())))
                } else {
                    return Err("{name} called on tuple with len < 2".into());
                }
            } else {
                return Err("{name} called on non-tuple".into());
            }
        }),
        inner_statements: None,
    }
}
fn genfunc_iter_and_arg<T: MersType, D: MersData>(
    name: &'static str,
    ft: impl Fn(&T) -> ItersT + Send + Sync + 'static,
    fd: impl Fn(&D) -> Iters + Send + Sync + 'static,
    type_sample: &'static T,
) -> data::function::Function {
    fn iter_out_arg<T: MersType>(
        a: &Type,
        i: &mut CheckInfo,
        name: &str,
        func: impl Fn(&T) -> ItersT + Sync + Send,
        type_sample: &T,
    ) -> Result<Type, CheckError> {
        let type_sample = type_sample.with_info(i);
        let mut out = Type::empty();
        for t in a.types.iter() {
            if let Some(t) = t.as_any().downcast_ref::<data::tuple::TupleT>() {
                if t.0.len() != 2 {
                    return Err(format!("cannot call {name} on tuple where len != 2").into());
                }
                if let Some(v) = t.0[0].iterable() {
                    for f in t.0[1].types.iter() {
                        if let Some(f) = f.as_any().downcast_ref::<T>() {
                            out.add(Arc::new(IterT::new(func(f), v.clone(), i)?));
                        } else {
                            return Err(format!("cannot call {name} on tuple that isn't (_, {type_sample}): got {} instead of {type_sample} as part of {}", t.0[1].with_info(i), a.with_info(i)).into());
                        }
                    }
                } else {
                    return Err(format!(
                        "cannot call {name} on non-iterable type {}, which is part of {}.",
                        t.with_info(i),
                        a.with_info(i)
                    )
                    .into());
                }
            }
        }
        Ok(out)
    }
    data::function::Function {
        info: program::run::Info::neverused(),
        info_check: Arc::new(Mutex::new(CheckInfo::neverused())),
        out: Ok(Arc::new(move |a, i| {
            iter_out_arg(a, i, name, |f: &T| ft(f), type_sample)
        })),
        run: Arc::new(move |a, _i| {
            if let Some(tuple) = a.get().as_any().downcast_ref::<data::tuple::Tuple>() {
                if let (Some(v), Some(f)) = (tuple.get(0), tuple.get(1)) {
                    if let Some(f) = f.get().as_any().downcast_ref::<D>() {
                        Ok(Data::new(Iter(fd(f), v.clone())))
                    } else {
                        return Err("{name} called on tuple not containing function".into());
                    }
                } else {
                    return Err("{name} called on tuple with len < 2".into());
                }
            } else {
                return Err("{name} called on non-tuple".into());
            }
        }),
        inner_statements: None,
    }
}

#[derive(Clone, Debug)]
pub enum Iters {
    Map(Data),
    Filter(Data),
    FilterMap(Data),
    MapWhile(Data),
    Take(usize),
    Enumerate,
    Chained,
}
#[derive(Clone, Debug)]
pub enum ItersT {
    Map(data::function::FunctionT),
    Filter(data::function::FunctionT),
    FilterMap(data::function::FunctionT),
    MapWhile(data::function::FunctionT),
    Take,
    Enumerate,
    Chained,
}
#[derive(Clone, Debug)]
pub struct Iter(pub Iters, pub Data);
#[derive(Clone, Debug)]
pub struct IterT(pub ItersT, pub Type, pub Type);
impl MersData for Iter {
    fn display(&self, _info: &DisplayInfo<'_>, f: &mut std::fmt::Formatter) -> std::fmt::Result {
        write!(f, "{self}")
    }
    fn is_eq(&self, _other: &dyn MersData) -> bool {
        false
    }
    fn iterable(
        &self,
        gi: &crate::program::run::RunLocalGlobalInfo,
    ) -> Option<Box<dyn Iterator<Item = Result<Data, CheckError>>>> {
        let gi = gi.clone();
        Some(match &self.0 {
            Iters::Map(f) => {
                let f = Clone::clone(f);
                Box::new(self.1.get().iterable(&gi)?.map(move |v| {
                    f.get()
                        .execute(v?, &gi)
                        .ok_or_else(|| CheckError::from("called map with non-function argument"))?
                }))
            }
            Iters::Filter(f) => {
                let f = Clone::clone(f);
                Box::new(self.1.get().iterable(&gi)?.filter_map(move |v| {
                    match v {
                        Ok(v) => match f.get().execute(v.clone(), &gi) {
                            Some(Ok(f)) => {
                                if f.get()
                                    .as_any()
                                    .downcast_ref::<data::bool::Bool>()
                                    .is_some_and(|b| b.0)
                                {
                                    Some(Ok(v))
                                } else {
                                    None
                                }
                            }
                            Some(Err(e)) => Some(Err(e)),
                            None => Some(Err(CheckError::from(
                                "called filter with non-function argument",
                            ))),
                        },
                        Err(e) => Some(Err(e)),
                    }
                }))
            }
            Iters::FilterMap(f) => {
                let f = Clone::clone(f);
                Box::new(self.1.get().iterable(&gi)?.filter_map(move |v| match v {
                    Ok(v) => match f.get().execute(v, &gi) {
                        Some(Ok(r)) => Some(Ok(r.one_tuple_content()?)),
                        Some(Err(e)) => Some(Err(e)),
                        None => Some(Err(CheckError::from(
                            "called filter_map with non-function argument",
                        ))),
                    },
                    Err(e) => Some(Err(e)),
                }))
            }
            Iters::MapWhile(f) => {
                let f = Clone::clone(f);
                Box::new(self.1.get().iterable(&gi)?.map_while(move |v| match v {
                    Ok(v) => match f.get().execute(v, &gi) {
                        Some(Ok(r)) => Some(Ok(r.one_tuple_content()?)),
                        Some(Err(e)) => Some(Err(e)),
                        None => Some(Err(CheckError::from(
                            "called map_while with non-function argument",
                        ))),
                    },
                    Err(e) => Some(Err(e)),
                }))
            }
            Iters::Take(limit) => Box::new(self.1.get().iterable(&gi)?.take(*limit)),
            Iters::Enumerate => {
                Box::new(
                    self.1
                        .get()
                        .iterable(&gi)?
                        .enumerate()
                        .map(|(i, v)| match v {
                            Ok(v) => Ok(Data::new(data::tuple::Tuple(vec![
                                Data::new(data::int::Int(i as _)),
                                v,
                            ]))),
                            Err(e) => Err(e),
                        }),
                )
            }
            Iters::Chained => {
                match self
                    .1
                    .get()
                    .iterable(&gi)?
                    .map(move |v| Ok(v?.get().iterable(&gi)))
                    .collect::<Result<Option<Vec<_>>, CheckError>>()
                {
                    Ok(Some(iters)) => Box::new(iters.into_iter().flatten()),
                    Ok(None) => return None,
                    Err(e) => Box::new([Err(e)].into_iter()),
                }
            }
        })
    }
    fn clone(&self) -> Box<dyn MersData> {
        Box::new(Clone::clone(self))
    }
    fn as_type(&self) -> data::Type {
        Type::new(
            IterT::new(
                self.0.as_type(),
                self.1.get().as_type(),
                &crate::info::Info::neverused(),
            )
            .unwrap(),
        )
    }
    fn as_any(&self) -> &dyn std::any::Any {
        self
    }
    fn mut_any(&mut self) -> &mut dyn std::any::Any {
        self
    }
    fn to_any(self) -> Box<dyn std::any::Any> {
        Box::new(self)
    }
}
impl IterT {
    /// `i` is only used for errors (this is important for `as_type()`)
    pub fn new(iter: ItersT, data: Type, i: &CheckInfo) -> Result<Self, CheckError> {
        let t = match &iter {
            ItersT::Map(f) => f.o(&data)?,
            ItersT::Filter(f) => {
                if f.o(&data)?.is_included_in(&data::bool::bool_type()) {
                    data.clone()
                } else {
                    return Err(format!(
                        "Iter:Filter, but function doesn't return bool for argument {}.",
                        data.with_info(&i)
                    )
                    .into());
                }
            }
            ItersT::FilterMap(f) => {
                if let Some(v) = f.o(&data)?.one_tuple_possible_content() {
                    v
                } else {
                    return Err(
                        format!("Iter:FilterMap, but function doesn't return ()/(t).").into(),
                    );
                }
            }
            ItersT::MapWhile(f) => {
                if let Some(t) = f.o(&data)?.one_tuple_possible_content() {
                    t
                } else {
                    return Err(
                        format!("Iter:MapWhile, but function doesn't return ()/(t).").into(),
                    );
                }
            }
            ItersT::Take => data.clone(),
            ItersT::Enumerate => Type::new(data::tuple::TupleT(vec![
                Type::new(data::int::IntT(0, INT_MAX)),
                data.clone(),
            ])),
            ItersT::Chained => {
                if let Some(out) = data.iterable() {
                    out
                } else {
                    return Err(format!(
                        "Cannot create a chain from an iterator over the non-iterator type {}.",
                        data.with_info(i)
                    )
                    .into());
                }
            }
        };
        Ok(Self(iter, data, t))
    }
}
impl MersType for IterT {
    fn display(
        &self,
        info: &crate::info::DisplayInfo<'_>,
        f: &mut std::fmt::Formatter,
    ) -> std::fmt::Result {
        write!(f, "<Iter: {}>", self.2.with_display(info))
    }
    fn is_same_type_as(&self, other: &dyn MersType) -> bool {
        if let Some(other) = other.as_any().downcast_ref::<Self>() {
            self.2.is_same_type_as(&other.2)
        } else {
            false
        }
    }
    fn is_included_in(&self, target: &dyn MersType) -> bool {
        if let Some(target) = target.as_any().downcast_ref::<Self>() {
            self.2.is_included_in(&target.2)
        } else {
            false
        }
    }
    fn iterable(&self) -> Option<Type> {
        Some(self.2.clone())
    }
    fn subtypes(&self, acc: &mut Type) {
        // NOTE: This might not be good enough
        acc.add(Arc::new(self.clone()));
    }
    fn as_any(&self) -> &dyn std::any::Any {
        self
    }
    fn mut_any(&mut self) -> &mut dyn std::any::Any {
        self
    }
    fn to_any(self) -> Box<dyn std::any::Any> {
        Box::new(self)
    }
}
impl Display for Iter {
    fn fmt(&self, f: &mut std::fmt::Formatter<'_>) -> std::fmt::Result {
        write!(f, "<Iter>")
    }
}
impl Iters {
    fn as_type(&self) -> ItersT {
        match self {
            Self::Map(f) => ItersT::Map(f.get().executable().unwrap()),
            Self::Filter(f) => ItersT::Filter(f.get().executable().unwrap()),
            Self::FilterMap(f) => ItersT::FilterMap(f.get().executable().unwrap()),
            Self::MapWhile(f) => ItersT::MapWhile(f.get().executable().unwrap()),
            Self::Take(_) => ItersT::Take,
            Self::Enumerate => ItersT::Enumerate,
            Self::Chained => ItersT::Chained,
        }
    }
}

fn genfunc_iter_in_val_out(
    name: String,
    iter_type: Type,
    out_type: Type,
    run: impl Fn(Data, &mut crate::info::Info<program::run::RunLocal>) -> Result<Data, CheckError>
        + Send
        + Sync
        + 'static,
) -> Function {
    Function {
        info: crate::info::Info::neverused(),
        info_check: Arc::new(Mutex::new(crate::info::Info::neverused())),
        out: Ok(Arc::new(move |a, i| {
            if let Some(iter_over) = a.iterable() {
                if iter_over.is_included_in(&iter_type) {
                    Ok(out_type.clone())
                } else {
                    Err(format!(
                        "Cannot call function {name} on iterator over type {}, which isn't {}.",
                        a.with_info(i),
                        iter_type.with_info(i)
                    )
                    .into())
                }
            } else {
                Err(format!(
                    "Cannot call function {name} on non-iterable type {}.",
                    a.with_info(i)
                )
                .into())
            }
        })),
        run: Arc::new(run),
        inner_statements: None,
    }
}

#[derive(Clone, Debug, PartialEq)]
pub struct Range(isize, isize);
#[derive(Clone, Debug, PartialEq)]
pub struct RangeT(isize, isize);
impl MersData for Range {
    fn display(&self, _info: &DisplayInfo, f: &mut std::fmt::Formatter) -> std::fmt::Result {
        write!(f, "{}.range_inc({})", self.0, self.1)
    }
    fn iterable(
        &self,
        _gi: &crate::program::run::RunLocalGlobalInfo,
    ) -> Option<Box<dyn Iterator<Item = Result<Data, CheckError>>>> {
        Some(Box::new(
            RangeInt(self.0, self.1, false).map(|v| Ok(Data::new(Int(v)))),
        ))
    }
    fn clone(&self) -> Box<dyn MersData> {
        Box::new(Clone::clone(self))
    }
    fn is_eq(&self, other: &dyn MersData) -> bool {
        other
            .as_any()
            .downcast_ref::<Self>()
            .is_some_and(|other| other == self)
    }
    fn as_type(&self) -> Type {
        Type::new(RangeT(self.0, self.1))
    }
    fn as_any(&self) -> &dyn std::any::Any {
        self
    }
    fn mut_any(&mut self) -> &mut dyn std::any::Any {
        self
    }
    fn to_any(self) -> Box<dyn std::any::Any> {
        Box::new(self)
    }
}
impl MersType for RangeT {
    fn display(
        &self,
        _info: &crate::info::DisplayInfo<'_>,
        f: &mut std::fmt::Formatter,
    ) -> std::fmt::Result {
        write!(f, "Range<{}..{}>", self.0, self.1)
    }
    fn iterable(&self) -> Option<Type> {
        Some(if self.is_empty() {
            Type::empty()
        } else {
            Type::new(IntT(self.0, self.1))
        })
    }
    fn is_same_type_as(&self, other: &dyn MersType) -> bool {
        other
            .as_any()
            .downcast_ref::<Self>()
            .is_some_and(|other| *self == *other)
    }
    fn is_included_in(&self, target: &dyn MersType) -> bool {
        target
            .as_any()
            .downcast_ref::<Self>()
            .is_some_and(|target| {
                // prolly good
                self.is_empty() || (!target.is_empty() && self.0 >= target.0 && self.1 <= target.1)
            })
    }
    fn subtypes(&self, acc: &mut Type) {
        acc.add(Arc::new(Clone::clone(self)))
    }
    fn as_any(&self) -> &dyn std::any::Any {
        self
    }
    fn mut_any(&mut self) -> &mut dyn std::any::Any {
        self
    }
    fn to_any(self) -> Box<dyn std::any::Any> {
        Box::new(self)
    }
}
impl RangeT {
    pub fn is_empty(&self) -> bool {
        self.1 < self.0
    }
}

struct RangeInt(isize, isize, bool);
impl Iterator for RangeInt {
    type Item = isize;
    fn next(&mut self) -> Option<Self::Item> {
        if !self.2 && self.0 <= self.1 {
            let o = self.0;
            if self.0 < self.1 {
                self.0 += 1;
            } else {
                self.2 = true;
            }
            Some(o)
        } else {
            None
        }
    }
}