main.rs

use canrun::
{
	collections::lvec::
	{
		LVec,
		lvec,
		member,
	},
	var, LVar, Goal, unify, all,
};

canrun::domain! {
    pub Collections {
		usize,
		char,
        LVec<char>,
        LVec<LVec<char>>,
    }
}

fn main()
{
	let a: LVar<char> = var();
	let b: LVar<char> = var();
	let c: LVar<char> = var();
	let d: LVar<char> = var();
	let e: LVar<char> = var();
	let f: LVar<char> = var();
	let g: LVar<char> = var();
	let n0: LVec<char> = lvec![a,b,c,e,f,g];
	let n1: LVec<char> = lvec![c,f];
	let n2: LVec<char> = lvec![a,c,d,e,g];
	let n3: LVec<char> = lvec![a,c,d,f,g];
	let n4: LVec<char> = lvec![b,c,d,f];
	let n5: LVec<char> = lvec![a,b,d,f,g];
	let n6: LVec<char> = lvec![a,b,d,e,f,g];
	let n7: LVec<char> = lvec![a,c,f];
	let n8: LVec<char> = lvec![a,b,c,d,e,f,g];
	let n9: LVec<char> = lvec![a,b,c,d,f,g];

	let input = "acedgfb cdfbe gcdfa fbcad dab cefabd cdfgeb eafb cagedb ab"; // | fdgacbe cefdb cefbgd gcbe

	let mut numbers: LVec<LVec<char>> = lvec![];

	let bindings = input.split_whitespace()
		.map(|word|
		{
			let number = var();
			let all = canrun::goals::Goal::all(word.chars()
				.map(|ch|
				{
					let character = var();
					all!
					[
						unify(ch, character),
						member(character, number),
					]
				})
				.collect::<Vec<_>>());
			numbers.push(number);
			all
		})
		.collect::<Vec<_>>();
		//.map(|vec| member(vec, lvec![n0, n1, n2, n3, n4, n5, n6, n7, n8, n9]))
		//.unzip();

	let goal: Goal<Collections> = all!
	[
		canrun::goals::Goal::all([a,b,c,e,f,g].iter().map(|seg| member(seg, &n0)).collect::<Vec<_>>()),
		canrun::goals::Goal::all([c,f].iter().map(|seg| member(seg, &n1)).collect::<Vec<_>>()),
		canrun::goals::Goal::all([a,c,d,e,g].iter().map(|seg| member(seg, &n2)).collect::<Vec<_>>()),
		canrun::goals::Goal::all([a,c,d,f,g].iter().map(|seg| member(seg, &n3)).collect::<Vec<_>>()),
		canrun::goals::Goal::all([b,c,d,f].iter().map(|seg| member(seg, &n4)).collect::<Vec<_>>()),
		canrun::goals::Goal::all([a,b,d,f,g].iter().map(|seg| member(seg, &n5)).collect::<Vec<_>>()),
		canrun::goals::Goal::all([a,b,d,e,f,g].iter().map(|seg| member(seg, &n6)).collect::<Vec<_>>()),
		canrun::goals::Goal::all([a,c,f].iter().map(|seg| member(seg, &n7)).collect::<Vec<_>>()),
		canrun::goals::Goal::all([a,b,c,d,e,f,g].iter().map(|seg| member(seg, &n8)).collect::<Vec<_>>()),
		canrun::goals::Goal::all([a,b,c,d,f,g].iter().map(|seg| member(seg, &n9)).collect::<Vec<_>>()),
		member(&n0, &numbers),
		member(&n1, &numbers),
		member(&n2, &numbers),
		member(&n3, &numbers),
		member(&n4, &numbers),
		member(&n5, &numbers),
		member(&n6, &numbers),
		member(&n7, &numbers),
		member(&n8, &numbers),
		member(&n9, &numbers),
		member(a, LVec::from(['a','b','c','d','e','f','g'])),
		member(b, LVec::from(['a','b','c','d','e','f','g'])),
		member(c, LVec::from(['a','b','c','d','e','f','g'])),
		member(d, LVec::from(['a','b','c','d','e','f','g'])),
		member(e, LVec::from(['a','b','c','d','e','f','g'])),
		member(f, LVec::from(['a','b','c','d','e','f','g'])),
		member(g, LVec::from(['a','b','c','d','e','f','g'])),
		canrun::goals::Goal::all(bindings),
	];

	let mut results: Vec<_> = goal.query(n0).collect();
	results.dedup();
	println!("{:?}", results);
}