core

var (

	// True is a true value.
	True = &trueStruct

	// False is a false value.
	False = &falseStruct
)

var Add = newCommutativeOperator(0, func(n, m NumberType) NumberType { return n + m })

var Assign = NewLazyFunction(
	NewSignature([]string{"collection"}, "keyValuePairs", nil, ""),
	func(vs ...Value) (result Value) {
		c, err := evalCollection(vs[0])

		if err != nil {
			return err
		}

		l, err := EvalList(vs[1])

		if err != nil {
			return err
		}

		for !l.Empty() {
			k := l.First()

			if l, err = EvalList(l.Rest()); err != nil {
				return err
			}

			c, err = evalCollection(c.assign(EvalPure(k), l.First()))

			if err != nil {
				return err
			}

			if l, err = EvalList(l.Rest()); err != nil {
				return err
			}
		}

		return c
	})

var Catch = NewLazyFunction(
	NewSignature([]string{"error"}, "", nil, ""),
	func(vs ...Value) Value {
		err, ok := EvalPure(vs[0]).(*ErrorType)

		if !ok {
			return Nil
		}

		return NewDictionary([]KeyValue{
			{NewString("name"), NewString(err.name)},
			{NewString("message"), NewString(err.message)},
		})
	})

var Compare = NewStrictFunction(
	NewSignature([]string{"left", "right"}, "", nil, ""),
	compareAsOrdered)

var Delete = NewStrictFunction(
	NewSignature([]string{"collection", "elem"}, "", nil, ""),
	func(vs ...Value) Value {
		c, err := evalCollection(vs[0])

		if err != nil {
			return err
		}

		return c.delete(EvalPure(vs[1]))
	})

var Div = newInverseOperator(func(n, m NumberType) NumberType { return n / m })

var DummyError = NewError("DummyError", "DummyMessage")

var Dump = NewLazyFunction(
	NewSignature([]string{"arg"}, "", nil, ""),
	func(vs ...Value) Value {
		s, err := StrictDump(vs[0])

		if err != nil {
			return err
		}

		return s
	})

var (

	// EmptyDictionary is a thunk of an empty dictionary.
	EmptyDictionary = &emtpyDictionary
)

var (

	// EmptyList is a thunk of an empty list.
	EmptyList = &emptyList
)

var Equal = NewLazyFunction(
	NewSignature(nil, "args", nil, ""),
	func(vs ...Value) (v Value) {
		defer func() {
			if r := recover(); r != nil {
				v = r.(Value)
			}
		}()

		l, err := EvalList(vs[0])

		if err != nil {
			return err
		} else if l.Empty() {
			return True
		}

		e := EvalPure(l.First())

		for {
			l, err = EvalList(l.Rest())

			if err != nil {
				return err
			} else if l.Empty() {
				return True
			}

			if compare(e, EvalPure(l.First())) != 0 {
				return False
			}
		}
	})

var Error = NewLazyFunction(
	NewSignature([]string{"name", "messasge"}, "", nil, ""),
	func(vs ...Value) Value {
		n, err := EvalString(vs[0])

		if err != nil {
			return err
		}

		m, err := EvalString(vs[1])

		if err != nil {
			return err
		}

		return &ErrorType{string(n), string(m), []*debug.Info{debug.NewGoInfo(1)}}
	})

var FloorDiv = newInverseOperator(func(n, m NumberType) NumberType {
	return NumberType(math.Floor(float64(n / m)))
})

var If = NewLazyFunction(
	NewSignature(nil, "args", nil, ""),
	func(vs ...Value) Value {
		v := vs[0]

		for {
			l, err := EvalList(v)

			if err != nil {
				return err
			}

			ll, err := EvalList(l.Rest())

			if err != nil {
				return err
			} else if ll.Empty() {
				return l.First()
			}

			b, err := EvalBoolean(l.First())

			if err != nil {
				return err
			} else if b {
				return ll.First()
			}

			v = ll.Rest()
		}
	})

var Include = NewStrictFunction(
	NewSignature([]string{"collection", "elem"}, "", nil, ""),
	func(vs ...Value) Value {
		c, err := evalCollection(vs[0])

		if err != nil {
			return err
		}

		return c.include(EvalPure(vs[1]))
	})

var Index = NewStrictFunction(
	NewSignature([]string{"collection", "key"}, "keys", nil, ""),
	func(vs ...Value) Value {
		v := vs[0]
		l := cons(vs[1], vs[2])

		for !l.Empty() {
			c, err := evalCollection(v)

			if err != nil {
				return err
			}

			v = c.index(EvalPure(l.First()))

			if l, err = EvalList(l.Rest()); err != nil {
				return err
			}
		}

		return v
	})

var IsOrdered = NewLazyFunction(
	NewSignature([]string{"arg"}, "", nil, ""),
	isOrdered)

var Mod = newBinaryOperator(math.Mod)

var Mul = newCommutativeOperator(1, func(n, m NumberType) NumberType { return n * m })

var Nil = NilType{}

var Partial = FunctionType(func(vars Arguments) Value {
	return NewRawFunction(func(args Arguments) Value {
		vars := vars
		v := EvalPure(vars.nextPositional())
		f, ok := v.(FunctionType)

		if !ok {
			return NotFunctionError(v)
		}

		return f.call(vars.Merge(args))
	})
})

var Pow = newBinaryOperator(math.Pow)

var Prepend = NewLazyFunction(
	NewSignature(nil, "elemsAndList", nil, ""),
	prepend)

var Pure = NewLazyFunction(
	NewSignature([]string{"arg"}, "", nil, ""),
	func(vs ...Value) Value {
		return EvalImpure(vs[0])
	})

var Size = newUnaryCollectionFunction(func(c collection) Value { return c.size() })

var Sub = newInverseOperator(func(n, m NumberType) NumberType { return n - m })

var ToList = newUnaryCollectionFunction(func(c collection) Value { return c.toList() })

var ToString = NewLazyFunction(
	NewSignature([]string{"arg"}, "", nil, ""),
	func(vs ...Value) Value {
		v := EvalPure(vs[0])
		s, ok := v.(stringable)

		if !ok {
			return TypeError(v, "stringable")
		}

		return s.string()
	})

var TypeOf = NewLazyFunction(
	NewSignature([]string{"arg"}, "", nil, ""),
	typeOf)