pub fn model_from_json(str: &str, context: Arc<RwLock<Context<'static>>>) -> Result<Model> {

    let mut m = Model::new(context);

    let v: JsonValue = serde_json::from_str(str)?;

    let statements = v["mStatements"]

        .as_array()

        .ok_or(error!("mStatements is not an array"))?;

    for statement in statements {

        let entry = statement

            .as_object()

            .ok_or(error!("mStatements contains a non-object"))?

            .ok_or(error!("mStatements contains an empty object"))?;

        match entry.0.as_str() {

                let decl = entry

                    .1

                    .as_object()

                    .ok_or(error!("Declaration is not an object".to_owned()))?;

                let mut valid_decl: bool = false;

                let scope = m.symbols_ptr_unchecked().clone();

                let model = &mut m;

                for (kind, value) in decl {

                    match kind.as_str() {

                            parse_variable(value, &mut model.symbols_mut())?;

                            valid_decl = true;

                            break;

                            parse_letting(value, &scope)?;

                            valid_decl = true;

                            break;

                if !valid_decl {

                }

                let constraints_arr = match entry.1.as_array() {

                    Some(x) => x,

                let constraints: Vec<Expression> = constraints_arr

                    .iter()

                    .map(|x| parse_expression(x, m.symbols_ptr_unchecked()))

                m.add_constraints(constraints);

    Ok(m)

}

fn parse_variable(v: &JsonValue, symtab: &mut SymbolTable) -> Result<()> {

    let arr = v.as_array().ok_or(error!("FindOrGiven is not an array"))?;

    let variable_type = arr[0]

        .as_str()

        .ok_or(error!("FindOrGiven[0] is not a string"))?;

    let name = parse_name(&arr[1])?;

    let domain = arr[2]

        .as_object()

        .ok_or(error!("FindOrGiven[2] is not an object"))?

        .ok_or(error!("FindOrGiven[2] is an empty object"))?;

    let domain = parse_domain(domain.0, domain.1, symtab)?;

    let decl = match variable_type {

        "Find" => DeclarationPtr::new_find(name.clone(), domain),

        "Given" => DeclarationPtr::new_given(name.clone(), domain),

    symtab.insert(decl).ok_or(Error::Parse(format!(

        "Could not add {name} to symbol table as it already exists"

    )))

}

fn parse_letting(v: &JsonValue, scope: &SymbolTablePtr) -> Result<()> {

    let arr = v.as_array().ok_or(error!("Letting is not an array"))?;

    let name = parse_name(&arr[0])?;

    match parse_expression(&arr[1], scope) {

            let mut symtab = scope.write();

            symtab

                .insert(DeclarationPtr::new_value_letting(name.clone(), value))

                .ok_or(Error::Parse(format!(

                    "Could not add {name} to symbol table as it already exists"

                )))

            let domain = arr[1]

                .as_object()

                .and_then(|value| value.get("Domain"))

                .ok_or(expression_error)?

                .ok_or(error!("Letting[1].Domain is not an object"))?

                .ok_or(error!("Letting[1].Domain is an empty object"))?;

            let mut symtab = scope.write();

            let domain = parse_domain(domain.0, domain.1, &mut symtab)?;

            symtab

                .insert(DeclarationPtr::new_domain_letting(name.clone(), domain))

                .ok_or(Error::Parse(format!(

                    "Could not add {name} to symbol table as it already exists"

                )))

}

fn parse_reference(v: &JsonValue, scope: &SymbolTablePtr) -> Result<Reference> {

    let array = v

        .as_object()

        .ok_or(error!("Value is not an object"))?

        .get("Reference")

        .ok_or(error!("Reference does not exist"))?

        .ok_or(error!("Reference is not an array"))?;

    let name_value = array

        .first()

        .ok_or(error!("Reference does not contain name"))?;

    let name = parse_name(name_value)?;

    let decl = scope

        .read()

        .lookup(&name)

        .ok_or(error!(format!("Symbol table does not contain '{name}'")))?;

    Ok(Reference::new(decl))

}

fn parse_domain(

    domain_name: &str,

    domain_value: &JsonValue,

    symbols: &mut SymbolTable,

) -> Result<DomainPtr> {

    match domain_name {

        "DomainInt" => Ok(parse_int_domain(domain_value, symbols)?),

        "DomainBool" => Ok(Domain::bool()),

            let arr = domain_value

                .as_array()

                .ok_or(error!("DomainReference is not an array"))?;

            let name = parse_name(&arr[0])?;

            let ptr = symbols

                .lookup(&name)

                .ok_or(error!(format!("Name {name} not found")))?;

                Domain::reference(ptr).ok_or(error!("Could not construct reference domain"))?;

            Ok(dom)

            let dom = domain_value.get(2).and_then(|v| v.as_object());

            let domain_obj = dom.ok_or(error!("DomainSet is missing domain object"))?;

            let domain = domain_obj

                .iter()

                .next()

                .ok_or(Error::Parse("DomainSet is an empty object".to_owned()))?;

            let domain = parse_domain(domain.0.as_str(), domain.1, symbols)?;

            let size = domain_value

                .get(1)

                .and_then(|v| v.as_object())

                .ok_or(error!("Set size attributes is not an object"))?;

            let size = parse_size_attr(size, symbols)?;

            let attr: SetAttr<IntVal> = SetAttr::new(size);

            Ok(Domain::set(attr, domain))

            let dom = domain_value

                .get(2)

                .and_then(|v| v.as_object())

                .expect("domain object exists");

            let domain = dom

                .iter()

                .next()

                .ok_or(Error::Parse("DomainMSet is an empty object".to_owned()))?;

            let domain = parse_domain(domain.0.as_str(), domain.1, symbols)?;

            let attributes = domain_value

                .get(1)

                .and_then(|v| v.as_array())

                .ok_or(error!("MSet attributes is not a json array"))?;

            let size = attributes

                .first()

                .and_then(|v| v.as_object())

                .ok_or(error!("MSet size attributes is not an object"))?;

            let size = parse_size_attr(size, symbols)?;

            let occurrence = attributes

                .get(1)

                .and_then(|v| v.as_object())

                .ok_or(error!("MSet occurrence attributes is not an object"))?;

            let occurrence = parse_occur_attr(occurrence, symbols)?;

            let attr: MSetAttr<IntVal> = MSetAttr {

                size,

                occurrence,

                representation: None,

            };

            Ok(Domain::mset(attr, domain))

            let dom = domain_value

                .get(2)

                .and_then(|v| v.as_object())

                .expect("domain object exists");

            let domain = dom.iter().next().ok_or(Error::Parse(

                "DomainPartition is an empty object".to_owned(),

            ))?;

            let domain = parse_domain(domain.0.as_str(), domain.1, symbols)?;

            let attributes = domain_value

                .get(1)

                .and_then(|v| v.as_object())

                .ok_or(error!("Partition attributes is not an object"))?;

            let mut num_parts = Range::Unbounded;

            let mut part_len = Range::Unbounded;

            let mut is_regular = false;

            if let Some(val) = attributes.get("partsNum") {

                let attr_map = val.as_object().expect("numParts should be an object");

                num_parts = parse_size_attr(attr_map, symbols)?;

            if let Some(val) = attributes.get("partsSize") {

                let attr_map = val.as_object().expect("partsSize should be an object");

                part_len = parse_size_attr(attr_map, symbols)?;

            if let Some(val) = attributes.get("isRegular").and_then(|v| v.as_bool()) {

                is_regular = val;

            let attr: PartitionAttr<IntVal> = PartitionAttr {

                num_parts,

                part_len,

                is_regular,

                representation: None,

            };

            Ok(Domain::partition(attr, domain))

            let domain_value = domain_value

                .as_array()

                .ok_or(error!("Domain matrix is not an array"))?;

            let indexed_by_domain = domain_value[0].clone();

            let (index_domain_name, index_domain_value) = indexed_by_domain

                .as_object()

                .ok_or(error!("DomainMatrix[0] is not an object"))?

                .ok_or(error!(""))?;

            let (value_domain_name, value_domain_value) = domain_value[1]

                .as_object()

                .ok_or(error!(""))?

                .ok_or(error!(""))?;

            let mut index_domains: Vec<DomainPtr> = vec![];

            index_domains.push(parse_domain(

                index_domain_name,

                index_domain_value,

                symbols,

            )?);

            let mut value_domain = parse_domain(value_domain_name, value_domain_value, symbols)?;

            while let Some((new_value_domain, mut indices)) = value_domain.as_matrix() {

                index_domains.append(&mut indices);

                value_domain = new_value_domain.clone()

            Ok(Domain::matrix(value_domain, index_domains))

            let dom = domain_value

                .get(2)

                .and_then(|v| v.as_object())

                .expect("domain object exists");

            let domain = dom

                .iter()

                .next()

                .ok_or(Error::Parse("DomainSequence is an empty object".to_owned()))?;

            let domain = parse_domain(domain.0.as_str(), domain.1, symbols)?;

            let attributes = domain_value

                .get(1)

                .and_then(|v| v.as_array())

                .ok_or(error!("Sequence attributes is not a json array"))?;

            let size = attributes

                .first()

                .and_then(|v| v.as_object())

                .ok_or(error!("Sequence size attributes is not an object"))?;

            let size = parse_size_attr(size, symbols)?;

            let jectivity = attributes

                .get(1)

                .and_then(|v| v.as_str())

                .ok_or(error!("jectivity is not a string"))?;

            let jectivity = match jectivity {

                "JectivityAttr_Injective" => Some(JectivityAttr::Injective),

                "JectivityAttr_Surjective" => Some(JectivityAttr::Surjective),

                "JectivityAttr_Bijective" => Some(JectivityAttr::Bijective),

                "JectivityAttr_None" => Some(JectivityAttr::None),

                jectivity.ok_or(Error::Parse("Jectivity is an unknown type".to_owned()))?;

            let attr: SequenceAttr<IntVal> = SequenceAttr {

                size,

                jectivity,

                representation: None,

            };

            match attr.size {

                Range::Unbounded | Range::UnboundedR(_) => Err(Error::Parse(

                    "Sequence must have size or maxSize attribute".to_string(),

                )),

                _ => Ok(Domain::sequence(attr, domain)),

            let domain_value = domain_value

                .as_array()

                .ok_or(error!("Domain tuple is not an array"))?;

            let domain = domain_value

                .iter()

                .map(|x| {

                    let domain = x

                        .as_object()

                        .ok_or(error!("DomainTuple[0] is not an object"))?

                        .ok_or(error!("DomainTuple[0] is an empty object"))?;

                    parse_domain(domain.0, domain.1, symbols)

                })

            Ok(Domain::tuple(domain))

            let is_record = domain_name == "DomainRecord";

            let domain_string = match is_record {

                true => "Record",

                false => "Variant",

            let domain_value = domain_value.as_array().ok_or(error!(&format!(

                "Domain {domain_string} is not a json array"

            )))?;

            let mut entries = vec![];

            for item in domain_value {

                let name = parse_name(&item[0])?;

                let domain = item[1]

                    .as_object()

                    .ok_or(error!("FindOrGiven[2] is not an object"))?

                    .ok_or(error!("FindOrGiven[2] is an empty object"))?;

                    name,

                    value: parse_domain(domain.0, domain.1, symbols)?,

                entries.push(rec);

            if is_record {

                Ok(Domain::record(entries))

                Ok(Domain::variant(entries))

            let domain = domain_value

                .get(2)

                .and_then(|v| v.as_object())

                .ok_or(error!("Function domain is not an object"))?;

            let domain = domain

                .iter()

                .next()

                .ok_or(Error::Parse("DomainSet is an empty object".to_owned()))?;

            let domain = parse_domain(domain.0.as_str(), domain.1, symbols)?;

            let codomain = domain_value

                .get(3)

                .and_then(|v| v.as_object())

                .ok_or(error!("Function codomain is not an object"))?;

            let codomain = codomain

                .iter()

                .next()

                .ok_or(Error::Parse("DomainSet is an empty object".to_owned()))?;

            let codomain = parse_domain(codomain.0.as_str(), codomain.1, symbols)?;

            let attributes = domain_value

                .get(1)

                .and_then(|v| v.as_array())

                .ok_or(error!("Function attributes is not a json array"))?;

            let size = attributes

                .first()

                .and_then(|v| v.as_object())

                .ok_or(error!("Function size attributes is not an object"))?;

            let size = parse_size_attr(size, symbols)?;

            let partiality = attributes

                .get(1)

                .and_then(|v| v.as_str())

                .ok_or(error!("Function partiality is not a string"))?;

            let partiality = match partiality {

                "PartialityAttr_Partial" => Some(PartialityAttr::Partial),

                "PartialityAttr_Total" => Some(PartialityAttr::Total),

                partiality.ok_or(Error::Parse("Partiality is an unknown type".to_owned()))?;

            let jectivity = attributes

                .get(2)

                .and_then(|v| v.as_str())

                .ok_or(error!("Function jectivity is not a string"))?;

            let jectivity = match jectivity {

                "JectivityAttr_Injective" => Some(JectivityAttr::Injective),

                "JectivityAttr_Surjective" => Some(JectivityAttr::Surjective),

                "JectivityAttr_Bijective" => Some(JectivityAttr::Bijective),

                "JectivityAttr_None" => Some(JectivityAttr::None),

                jectivity.ok_or(Error::Parse("Jectivity is an unknown type".to_owned()))?;

            let attr: FuncAttr<IntVal> = FuncAttr {

                size,

                partiality,

                jectivity,

                representation: None,

            };

            Ok(Domain::function(attr, domain, codomain))

            let domains = domain_value

                .get(2)

                .and_then(|v| v.as_array())

                .ok_or(Error::Parse(

                    "Relation domains are not a json array".to_owned(),

                ))?;

            let domains = domains

                .iter()

                .map(|x| {

                    let domain = x

                        .as_object()

                        .ok_or(Error::Parse("Relation domain is not an object".to_owned()))?

                        .ok_or(Error::Parse(

                            "Relation domain is an empty object".to_owned(),

                        ))?;

                    parse_domain(domain.0, domain.1, symbols)

                })

            let attributes = domain_value

                .get(1)

                .and_then(|v| v.as_array())

                .ok_or(Error::Parse(

                    "Relation attributes are not a json array".to_owned(),

                ))?;

            let size = attributes

                .first()

                .and_then(|v| v.as_object())

                .ok_or(Error::Parse(

                    "Relation size attributes are not an object".to_owned(),

                ))?;

            let size = parse_size_attr(size, symbols)?;

            let binary = attributes

                .get(1)

                .and_then(|v| v.as_array())

                .ok_or(Error::Parse(

                    "Relation binary attributes are not a json array".to_owned(),

                ))?;

            let binary = binary

                .iter()

                .map(|x| {

                    let attr = x.as_str().ok_or(Error::Parse(

                        "Relation binary attribute is not a string".to_owned(),

                    ))?;

                    match attr {

                        "BinRelAttr_Reflexive" => Ok(BinaryAttr::Reflexive),

                        "BinRelAttr_Irreflexive" => Ok(BinaryAttr::Irreflexive),

                        "BinRelAttr_Coreflexive" => Ok(BinaryAttr::Coreflexive),

                        "BinRelAttr_Symmetric" => Ok(BinaryAttr::Symmetric),

                        "BinRelAttr_AntiSymmetric" => Ok(BinaryAttr::AntiSymmetric),

                        "BinRelAttr_ASymmetric" => Ok(BinaryAttr::ASymmetric),

                        "BinRelAttr_Transitive" => Ok(BinaryAttr::Transitive),

                        "BinRelAttr_Total" => Ok(BinaryAttr::Total),

                        "BinRelAttr_Connex" => Ok(BinaryAttr::Connex),

                        "BinRelAttr_Euclidean" => Ok(BinaryAttr::Euclidean),

                        "BinRelAttr_Serial" => Ok(BinaryAttr::Serial),

                        "BinRelAttr_Equivalence" => Ok(BinaryAttr::Equivalence),

                        "BinRelAttr_PartialOrder" => Ok(BinaryAttr::PartialOrder),

                })

            let attr: RelAttr<IntVal> = RelAttr {

                size,

                binary,

                representation: None,

            };

            Ok(Domain::relation(attr, domains))

}

fn parse_name(v: &JsonValue) -> Result<Name> {

    let name = v

        .as_object()

        .ok_or(error!("Value is not an object"))?

        .get("Name")

        .ok_or(error!("Name does not exist"))?

        .ok_or(error!("Name is not a string"))?;

    Ok(Name::User(Ustr::from(name)))

}

fn parse_size_attr(

    attr_map: &JsonMap<String, JsonValue>,

    symbols: &mut SymbolTable,

) -> Result<Range<IntVal>> {

    let scope = SymbolTablePtr::new();

    *scope.write() = symbols.clone();

    let attr_obj = attr_map

        .iter()

        .next()

        .ok_or(Error::Parse("SizeAttr is an empty object".to_owned()))?;

    match attr_obj.0.as_str() {

        "SizeAttr_None" => Ok(Range::Unbounded),

            let size = parse_expression_to_int_val(attr_obj.1, &scope)?;

            Ok(Range::UnboundedR(size))

            let size = parse_expression_to_int_val(attr_obj.1, &scope)?;

            Ok(Range::UnboundedL(size))

            let min_max = attr_obj

                .1

                .as_array()

                .ok_or(error!("SizeAttr MinMaxSize is not a json array"))?;

            let min = min_max

                .first()

                .ok_or(error!("SizeAttr Min is not present"))?;

            let min_int = parse_expression_to_int_val(min, &scope)?;

            let max = min_max

                .get(1)

                .ok_or(error!("SizeAttr Max is not present"))?;

            let max_int = parse_expression_to_int_val(max, &scope)?;

            Ok(Range::Bounded(min_int, max_int))

            let size = parse_expression_to_int_val(attr_obj.1, &scope)?;

            Ok(Range::Single(size))

}

fn parse_occur_attr(

    attr_map: &JsonMap<String, JsonValue>,

    symbols: &mut SymbolTable,

) -> Result<Range<IntVal>> {

    let scope = SymbolTablePtr::new();

    *scope.write() = symbols.clone();

    let attr_obj = attr_map

        .iter()

        .next()

        .ok_or(Error::Parse("OccurAttr is an empty object".to_owned()))?;

    match attr_obj.0.as_str() {

        "OccurAttr_None" => Ok(Range::Unbounded),

            let size_int = parse_expression_to_int_val(attr_obj.1, &scope)?;

            Ok(Range::UnboundedR(size_int))

            let size_int = parse_expression_to_int_val(attr_obj.1, &scope)?;

            Ok(Range::UnboundedL(size_int))

            let min_max = attr_obj

                .1

                .as_array()

                .ok_or(error!("OccurAttr MinMaxOccur is not a json array"))?;

            let min = min_max

                .first()

                .ok_or(error!("OccurAttr Min is not present"))?;

            let min_int = parse_expression_to_int_val(min, &scope)?;

            let max = min_max

                .get(1)

                .ok_or(error!("OccurAttr Max is not present"))?;

            let max_int = parse_expression_to_int_val(max, &scope)?;

            Ok(Range::Bounded(min_int, max_int))

}

fn parse_int_domain(v: &JsonValue, symbols: &SymbolTable) -> Result<DomainPtr> {

    let scope = SymbolTablePtr::new();

    *scope.write() = symbols.clone();

    let range_values = &v

        .as_array()

        .ok_or(Error::Parse("DomainInt[1] is not an array".to_owned()))?[1];

    if range_values.as_array().is_some_and(Vec::is_empty) {

        return Ok(Domain::int_ground(vec![Range::Unbounded]));

    }

    let ranges = parse_range_list(range_values, |v| parse_expression_to_int_val(v, &scope))?;

    Ok(Domain::int(ranges))

}

fn parse_range<T: Clone>(

    v: &JsonValue,

    parser: &impl Fn(&JsonValue) -> Result<T>,

) -> Result<Range<T>> {

    let range = v

        .as_object()

        .ok_or(error!("Range is not an bject"))?

        .ok_or(error!("Range is an empty object"))?;

    match range.0.as_str() {

            let arr = range

                .1

                .as_array()

                .ok_or(error!("RangeBounded is not an array".to_owned()))?;

            let mut nums = Vec::new();

            for item in arr.iter() {

                let num = parser(item)?;

                nums.push(num);

            let lower = nums

                .first()

                .cloned()

                .ok_or(error!("RangeBounded lower bound missing"))?;

            let upper = nums

                .get(1)

                .cloned()

                .ok_or(error!("RangeBounded upper bound missing"))?;

            Ok(Range::Bounded(lower, upper))

            let num = parser(range.1)?;

            Ok(Range::Single(num))

        _ => throw_error!("DomainInt[1] contains an unknown object"),

}

fn parse_range_list<T: Clone>(

    v: &JsonValue,

    parser: impl Fn(&JsonValue) -> Result<T>,

) -> Result<Vec<Range<T>>> {

    v.as_array()

        .ok_or(error!("Value is not an array".to_owned()))?

        .map(|r| parse_range(r, &parser))

}

fn parse_expression_to_int_val(obj: &JsonValue, scope: &SymbolTablePtr) -> Result<IntVal> {

    parser_trace!("trying to parse domain value as expression: {}", obj);

    let expr = parse_expression(obj, scope)?;

    if let Some(Literal::Int(i)) = expr.clone().into_literal() {

        return Ok(IntVal::Const(i as i64));

    }

    if let Expression::Atomic(_, Atom::Reference(reference)) = &expr

        && let Ok(reference_val) = IntVal::new_ref(reference)

        return Ok(reference_val);

    }

    IntVal::new_expr(Moo::new(expr))

}

fn binary_operator(op_name: &str) -> Option<BinOp> {

    match op_name {

        "MkOpIn" => Some(Expression::In),

        "MkOpUnion" => Some(Expression::Union),

        "MkOpEq" => Some(Expression::Eq),

        "MkOpNeq" => Some(Expression::Neq),

        "MkOpGeq" => Some(Expression::Geq),

        "MkOpLeq" => Some(Expression::Leq),

        "MkOpGt" => Some(Expression::Gt),

        "MkOpLt" => Some(Expression::Lt),

        "MkOpLexLt" => Some(Expression::LexLt),

        "MkOpMinus" => Some(Expression::Minus),

        "MkOpImply" => Some(Expression::Imply),

        "MkOpIff" => Some(Expression::Iff),

        "MkOpPow" => Some(Expression::UnsafePow),

        "MkOpImage" => Some(Expression::Image),

        "MkOpImageSet" => Some(Expression::ImageSet),

        "MkOpPreImage" => Some(Expression::PreImage),

        "MkOpInverse" => Some(Expression::Inverse),

        "MkOpRestrict" => Some(Expression::Restrict),

        "MkOpApart" => Some(Expression::Apart),

        "MkOpTogether" => Some(Expression::Together),

        "MkOpParty" => Some(Expression::Party),

        "MkOpSubstring" => Some(Expression::Substring),

        _ => None,

}

fn unary_operator(op_name: &str, inner: Option<&Expression>) -> Option<UnaryOp> {

    match op_name {

        "MkOpNot" => Some(Expression::Not),

        "MkOpNegate" => Some(Expression::Neg),

            if let Some(inner) = inner {

                match inner.return_type() {

                    ReturnType::Int => Some(Expression::Abs),

                    | ReturnType::Relation(_) => Some(Expression::Card),

                Some(Expression::Abs)

        "MkOpAnd" => Some(Expression::And),

        "MkOpSum" => Some(Expression::Sum),

        "MkOpProduct" => Some(Expression::Product),

        "MkOpOr" => Some(Expression::Or),

        "MkOpMax" => Some(Expression::Max),

        "MkOpAllDiff" => Some(Expression::AllDiff),

        "MkOpToInt" => Some(Expression::ToInt),

        "MkOpDefined" => Some(Expression::Defined),

        "MkOpRange" => Some(Expression::Range),

        "MkOpToMSet" => Some(Expression::ToMSet),

        "MkOpToRelation" => Some(Expression::ToRelation),

        "MkOpParticipants" => Some(Expression::Participants),

        "MkOpParts" => Some(Expression::Parts),

}

fn parse_reference_name(obj: &JsonValue) -> Result<Name> {

    if let Some(name) = obj.get("Name").and_then(|x| x.as_str()) {

        return Ok(Name::User(Ustr::from(name)));

    }

    let ref_arr = obj["Reference"]

        .as_array()

    let ref_obj = ref_arr

        .first()

        .and_then(|x| x.as_object())

    let name = ref_obj

        .get("Name")

        .and_then(|x| x.as_str())

    Ok(Name::User(Ustr::from(name)))

}

pub fn parse_expression(obj: &JsonValue, scope: &SymbolTablePtr) -> Result<Expression> {

    let fail = |stage: &str| -> Error {

        Error::Parse(format!(

            "Could not parse expression at stage `{stage}` for json `{obj}`"

        ))

    };

    match obj {

        Value::Object(op) if op.contains_key("Op") => {

            let op_obj = op

                .get("Op")

                .and_then(Value::as_object)

            let (op_name, _) = op_obj.iter().next().ok_or_else(|| fail("Op.iter().next"))?;

            if op_obj.contains_key("MkOpFlatten") {

                parse_flatten_op(op_obj, scope)

            } else if op_obj.contains_key("MkOpTable") {

            } else if op_obj.contains_key("MkOpIndexing") || op_obj.contains_key("MkOpSlicing") {

                parse_indexing_slicing_op(op_obj, scope)

            } else if op_obj.contains_key("MkOpActive") {

                parse_active_op(op_obj, scope)

            } else if op_obj.contains_key("MkOpRelationProj") {

                parse_relation_projection(op_obj, scope)

            } else if op_obj.contains_key("MkOpToSet") {

                parse_to_set(op_obj, scope)

            } else if binary_operator(op_name).is_some() {

                parse_bin_op(op_obj, scope)

            } else if unary_operator(op_name, None).is_some() {

                parse_unary_op(op_obj, scope)

        Value::Object(comprehension) if comprehension.contains_key("Comprehension") => {

            parse_comprehension(comprehension, scope.clone())

        Value::Object(refe) if refe.contains_key("Reference") => {

            let reference = parse_reference(obj, scope)?;

            Ok(Expression::Atomic(

                Metadata::new(),

                Atom::Reference(reference),

            ))

        Value::Object(refe) if refe.contains_key("Name") => {

        Value::Object(abslit) if abslit.contains_key("AbstractLiteral") => {

            let abstract_literal = abslit["AbstractLiteral"]

                .as_object()

            if abstract_literal.contains_key("AbsLitSet") {

            } else if abstract_literal.contains_key("AbsLitFunction") {

                parse_abs_function(&abslit["AbstractLiteral"]["AbsLitFunction"], scope)

            } else if abstract_literal.contains_key("AbsLitMSet") {

            } else if abstract_literal.contains_key("AbsLitVariant") {

                parse_abs_variant(&abslit["AbstractLiteral"]["AbsLitVariant"], scope)

            } else if abstract_literal.contains_key("AbsLitRelation") {

            } else if abstract_literal.contains_key("AbsLitPartition") {

                parse_abs_partition(&abslit["AbstractLiteral"]["AbsLitPartition"], scope)

            } else if abstract_literal.contains_key("AbsLitPermutation") {

            } else if abstract_literal.contains_key("AbsLitSequence") {

                parse_abstract_matrix_as_expr(obj, scope)

        Value::Object(constant) if constant.contains_key("Constant") => {

            parse_constant(constant, scope).or_else(|_| parse_abstract_matrix_as_expr(obj, scope))

        Value::Object(constant) if constant.contains_key("ConstantAbstract") => {

            let literal = constant

                .get("ConstantAbstract")

                .and_then(Value::as_object)

            if literal.contains_key("AbsLitMatrix") {

                parse_abstract_matrix_as_expr(obj, scope)

                parse_constant_abstract(literal, scope)

        Value::Object(constant) if constant.contains_key("ConstantInt") => {

            parse_constant(constant, scope)

        Value::Object(constant) if constant.contains_key("ConstantBool") => {

            parse_constant(constant, scope)

        _ => Err(fail("no_match")),

}

fn parse_abs_lit(abs_set: &Value, scope: &SymbolTablePtr) -> Result<Expression> {

    let values = abs_set

        .as_array()

        .ok_or(error!("AbsLitSet is not an array"))?;

    let expressions = values

        .iter()

        .map(|values| parse_expression(values, scope))

    Ok(Expression::AbstractLiteral(

        Metadata::new(),

        AbstractLiteral::Set(expressions),

    ))

}

fn parse_constant_abstract(

    literal: &serde_json::Map<String, Value>,

    scope: &SymbolTablePtr,

) -> Result<Expression> {

    if let Some(value) = literal.get("AbsLitSet") {

        parse_abs_lit(value, scope)

}

fn parse_abs_mset(abs_mset: &Value, scope: &SymbolTablePtr) -> Result<Expression> {

    let values = abs_mset

        .as_array()

        .ok_or(error!("AbsLitMSet is not an array"))?;

    let expressions = values

        .iter()

        .map(|values| parse_expression(values, scope))

    Ok(Expression::AbstractLiteral(

        Metadata::new(),

        AbstractLiteral::MSet(expressions),

    ))

}

fn parse_abs_partition(abs_partition: &Value, scope: &SymbolTablePtr) -> Result<Expression> {

    let parts = abs_partition

        .as_array()

        .ok_or(error!("AbsLitPartition is not an array"))?;

    let mut partition: Vec<Vec<_>> = Vec::new();

    for part in parts {

        let vals = part

            .as_array()

            .ok_or(error!("Part in AbsLitPartition is not an array"))?;

        let exprs = vals

            .iter()

            .map(|values| parse_expression(values, scope))

        partition.push(exprs);

    Ok(Expression::AbstractLiteral(

        Metadata::new(),

        AbstractLiteral::Partition(partition),

    ))

}

fn parse_abs_sequence(abs_seq: &Value, scope: &SymbolTablePtr) -> Result<Expression> {

    let values = abs_seq

        .as_array()

        .ok_or(error!("AbsLitSequence is not an array"))?;

    let expressions = values

        .iter()

        .map(|values| parse_expression(values, scope))

    Ok(Expression::AbstractLiteral(

        Metadata::new(),

        AbstractLiteral::Sequence(expressions),

    ))

}

fn parse_abs_tuple(abs_tuple: &Value, scope: &SymbolTablePtr) -> Result<Expression> {

    let values = abs_tuple

        .as_array()

        .ok_or(error!("AbsLitTuple is not an array"))?;

    let expressions = values

        .iter()

        .map(|values| parse_expression(values, scope))

    Ok(Expression::AbstractLiteral(

        Metadata::new(),

        AbstractLiteral::Tuple(expressions),

    ))

}

fn parse_abs_record(abs_record: &Value, scope: &SymbolTablePtr) -> Result<Expression> {

    let entries = abs_record

        .as_array()

        .ok_or(error!("AbsLitRecord is not an array"))?;

    let mut rec = vec![];

    for entry in entries {

        let entry = entry

            .as_array()

            .ok_or(error!("AbsLitRecord entry is not an array"))?;

        let name = parse_name(&entry[0])?;

        let value = parse_expression(&entry[1], scope)?;

        let rec_entry = Field {

            name: name.clone(),

            value,

        };

        rec.push(rec_entry);

    Ok(Expression::AbstractLiteral(

        Metadata::new(),

        AbstractLiteral::Record(rec),

    ))

}

fn parse_abs_variant(abs_variant: &Value, scope: &SymbolTablePtr) -> Result<Expression> {

    let entry = abs_variant

        .as_array()

        .ok_or(error!("AbsLitVariant is not an array"))?;

    let name = entry[1]

        .as_object()

        .ok_or(error!("AbsLitVariant field name is not an object"))?["Name"]

        .ok_or(error!("AbsLitVariant field name is not a string"))?;

    let value = parse_expression(&entry[2], scope)?;

    let name = Name::User(Ustr::from(name));

    let rec_entry = Field { name, value };

    Ok(Expression::AbstractLiteral(