#$ We shouldnt be getting tvars from instances in digThroughVar.
# 77307048000
# 1

class IntoIter
	into-iter (self _) -> itershit

class Iter
	next (self Ptr _) -> Maybe item

Range
	from I64
	to I64

RangeIter
	og Range
	cur I64

inst IntoIter Range
	into-iter (self Range) -> RangeIter
		return RangeIter { og: self, cur: self.from }

inst IntoIter RangeIter
	into-iter (self RangeIter) -> RangeIter
		return self

inst Iter RangeIter
	next (self Ptr RangeIter) -> Maybe I64
		r = self&.og
		if self&.cur > r.to
			return None

		x = Just(self&.cur)
		self <&.cur= self&.cur + 1
		return x

Map it from to
	og it
	fun from -> to

inst IntoIter Map
	into-iter (self Map it from to) -> Map it from to
		return self

inst Iter Map
	next (self Ptr (Map og from to)) -> Maybe to <= Iter og
		case next(&self&.og)
			None
				return None
			Just(x)
				return Just(self&.fun(x))

fn map (iterable it, fun from -> to) -> Map it' from to <= IntoIter it
	it = into-iter(iterable)
	return Map { og: it, fun: fun }


Filter it item
	og it
	fun item -> Bool

fn filter (iterable it, fun from -> Bool) -> Filter it' from <= IntoIter it
	it = into-iter(iterable)
	return Filter { og: it, fun: fun }

inst IntoIter Filter
	into-iter (self Filter it from) -> Filter it from
		return self

inst Iter Filter
	next (self Ptr (Filter it item)) -> Maybe item <= Iter it
		while True
			case next(&self&.og)
				None
					return None
				Just(x)
					if self&.fun(x)
						return Just(x)

fn reduce (iterable it, base a, fun (item, a) -> a) -> a <= IntoIter it
	x = base
	it = into-iter(iterable)
	while True
		case next(&it)
			None
				return x
			Just(res)
				x <= fun(res, x)
	return unreachable()


fn sum (iterable it) <= IntoIter it
	return reduce(iterable, 0, fn (x, y): x + y)

fn multiply (iterable it) <= IntoIter it
	return reduce(iterable, 1, fn (x, y): x * y)

fn for-each-print (iterable it) <= IntoIter it
	it = into-iter(iterable)
	while True
		case next(&it)
			None
				return

			Just(x)
				println(x)


fn range (from, to)
	return Range { from: from, to: to }

fn bool-to-int (x Bool) -> I64
	if x
		return 1
	else
		return 0

BoolRange
	cur I64

inst IntoIter BoolRange
	into-iter (self BoolRange) -> BoolRange
		return self

inst Iter BoolRange
	next (self Ptr BoolRange) -> Maybe Bool
		if self&.cur == 0
			self <&.cur= 1
			return Just(False)

		if self&.cur == 1
			self <&.cur= 2
			return Just(True)

		return None

fn bool-range () -> BoolRange
	return BoolRange { cur: 0 }


const = 3
r = map(filter(map(range(12, 20), fn x: x + const), fn x: x /= 18), fn x: x + 4)
println(multiply(r))

println(sum(map(bool-range(), bool-to-int)))