platform.txt

public class LazyList : IEnumerable<Value>, Value {
		public Value Current { get; set; }
		public Lazy Next { get; set; }

		public IType Type => Prelude.List;

		public Value Clone() {
			throw new NotImplementedException();
		}

		public Int32 CompareTo(Object obj) {
			throw new NotImplementedException();
		}

		public IEnumerator<Value> GetEnumerator() {
			yield return this.Current;

			Lazy next = this.Next;
			while (next.Force() is LazyList ll) {
				yield return ll.Current;
				next = ll.Next;
			}
		}

		public String ToString(Scope e) {
			return "[lazy]";
		}

		public String ToString(String format, IFormatProvider formatProvider) {
			return "[lazy]";
		}

		IEnumerator IEnumerable.GetEnumerator() {
			return this.GetEnumerator();
		}
	}


			if (right is Lazy lazy) {
				Value v = this.result.Eval(e);
				return new LazyList { Current = v, Next = lazy };
				/*LinkedList l = lazy.Force() as LinkedList;
				return new List(new LinkedList(this.result.Eval(e), l));*/
			}

			if (right is LazyList lazylist) {
				Value v = this.result.Eval(e);
				return new LazyList { Current = v, Next = new Lazy(null) { value = lazylist } };
				/*LinkedList l = lazy.Force() as LinkedList;
				return new List(new LinkedList(this.result.Eval(e), l));*/
			}

Lumen.Studio
Lumen.Studio.Interop
Lumen.Studio.Designer
Lumen.Studio.Debugger
Lumen.Lang
Lumen.Lang.Libraries
Lumen.Anatomy
Lumen.Anatomy.Lumex
Lumen.Light
Lumen.Utils.Ldoc

// add to studio debugger
// goto XML
// add to studio logger
// remove cmd?
// add to studio project builder for lumen
// make anatomy
// make ldoc
// make visual
// make system

OnDocumentation
OnMessage
OnWarinig
OnError
OnRefactoring
BeforeDebugStep
OnDebugStep
AfterDebugStep
OnDebugCollection

//////////// Lumen ///////////

// :deprecated
// :added in 0.3.6

// Ñâÿçêà. Íå èçìåíÿåìà â äàííîé îáëàñòè âèäèìîñòè.
// Íåèíèöèàëèçèðîâàííûå çíà÷åíèÿ íå äîïóñêàþòñÿ ñèíòàêñèñîì.
let a = 9

// Èçìåíÿåìàÿ ñâÿçêà. Èçìåíÿåòñÿ îïåðàòîðîì ïðèñâàèâàíèÿ.
// Íåèíèöèàëèçèðîâàííûå çíà÷åíèÿ íå äîïóñêàþòñÿ ñèíòàêñèñîì.
let mut b = 3

// Îáúÿâëåíèÿ ôóíêöèé àíàëîãè÷íû îïåðàòîðàì ñâÿçûâàíèÿ è ïîä÷èíÿþòñÿ èì, ñ íåêîòîðûìè 
// îñîáåííîñòÿìè. Ïîñëå èìåíè ñâÿçêè äîëæåí èäòè õîòÿ áû îäèí øàáëîí ñîïîñòàâëåíèÿ.
let f x = x * x

// Âîçìîæíà ïåðåãðóçêà ñâÿçîê, îäíàêî ýòî íå îçíà÷àåò ÷òî ñâÿçêà îáÿçàíà 
// áûòü èçìåíÿåìîé.
// Åñëè êàêàÿ-òî ôóíêöèÿ óæå ñâÿçàííà ñ äàííûì èìåíåì, òî åù¸ îäíà ïåðåãðóçêà áóäåò 
// äîáàâëåíà ê óæå ñóùåñòâóþùèì.
// Åñëè ñ äàííûì èìåíåì óæå ñâÿçàíî íå ôóíêöèîíàëüíîå çíà÷åíèå, òî áóäåò âûáðîøåíî
// èñêëþ÷åíèå BindingIsAlsoExists
let area (Circle radius) = 3.14*radius^2
let area (Square side) = side^2

// Îïåðàòîð ïðèñâàèâàíèÿ <-. Ïðèñâàèâàåò íîâîå çíà÷åíèå ìóòàáåëüíîé ñâÿçêå.
// Åñëè ïðîèñõîäèò ïîïûòêà ïðèñâàèâàíèÿ íåèçìåíÿåìîé ïåðåìåííîé - âûáðàñûâàåòñÿ
// èñêëþ÷åíèå CanNotToChangeBinding
let mut i = 0
i <- i + 1

// Îïðåäåëåíèå îáëàñòè âèäèìîñòè.
// Îáëàñòü âèäèìîñòè - ýòî:
// 1. Òåëî èëè äåêëàðàöèÿ ôóíêöèè
//	let n = 9
//	let fact n = // ýòà ñâÿçêà íå èìååò íè÷åãî îáùåãî ñ âíåøíåé
//		if n = 0: 
//			1 
//		else: 
//			n * rec (n-1)
// 2. Òåëî îïåðàòîðà, âûäåëåííîå îòñòóïîì
//	let mut i = 10
//	while i > 0:
//		let j = i * i // Ýòà ïåðåìåííàÿ íîâàÿ ñ êàæäûì ïðîõîäîì
//		i <- i + 1
//		print j

type Color = Red | Green | Blue | RGB r g b
// Color - ýòî òèï
// RGB - êîíñòðóêòîð çíà÷åíèÿ
// Red Green è Blue - êîíñòðóêòîðû çíà÷åíèÿ áåç ïàðàìåòðîâ
// Èìåíà òèïîâ è êîíñòðóêòîðîâ ÎÁßÇÀÍÛ íà÷èíàòüñÿ ñ áîëüøîé áóêâû

// Ïàòòåðí ìàò÷èíã
let f None // ñîâïàäàåò ñ None è ()
let f () // Àíàëîãè÷íî òîìó ÷òî âûøå


()
[] 
[x, y, z]
3
_

// Exceptions:
L001 IncorrectNumberLiteral
L002 WaitAnotherToken
L003 UnexceptedToken
L004 UnclosedListLiteral
L005 UnclosedTextLiteral
L006 UnclosedArrayLiteral
L007 UnclosedLambda

L010 IdentifierIsAlreadyExists
L011 BindingIsAlreadyExists
L012 UnknownIdentifier
L013 ModuleDoesNotContainsName

L020 ValueIsNotAFunction
L021 TypeError
L022 ConvertError

L030 TypeDoesNotImpelentTypeClass
L031 FunctionWithSignatureCanNotBeApplied

L100 IndexOutOfRange



	public class Channel : BaseValueImpl {
		public Boolean CanNext { get; private set; } = true;

		private Value data;
		public System.Threading.CancellationTokenSource tokenSource;

		public System.Threading.ManualResetEventSlim RecieveEvent { get; set; } = 
			new System.Threading.ManualResetEventSlim(false);
		public System.Threading.ManualResetEventSlim SendEvent { get; set; } = 
			new System.Threading.ManualResetEventSlim(false);

		public Channel(System.Threading.CancellationTokenSource tokenSource) {
			this.tokenSource = tokenSource;
			this.tokenSource.Token.Register(() => {
				this.SendEvent.Set();
				this.RecieveEvent.Set();
			});
		}

		public override IType Type => Prelude.Number;

		public void Send(Value data) {
			if (this.tokenSource.IsCancellationRequested) {
				this.tokenSource.Token.ThrowIfCancellationRequested();
			}

			if (this.data != null) {
				this.RecieveEvent.Wait();
			}

			if (this.tokenSource.IsCancellationRequested) {
				this.tokenSource.Token.ThrowIfCancellationRequested();
			}

			this.data = data;
			this.SendEvent.Set();
			this.RecieveEvent.Reset();
		}

		public Value Recieve() {
			if (this.tokenSource.IsCancellationRequested) {
				if(this.data != null) {
					Value res = this.data;
					this.data = null;
					this.CanNext = true;
					return res;
				}
				this.CanNext = false;
				throw new OperationCanceledException();
			}

			if (this.data == null) {
				this.SendEvent.Wait();
			}

			if (this.tokenSource.IsCancellationRequested) {
				if (this.data != null) {
					Value res = this.data;
					this.data = null;
					this.CanNext = true;
					return res;
				}

				this.CanNext = false;
				throw new OperationCanceledException();
			}

			Value result = this.data;

			this.data = null;
			this.RecieveEvent.Set();
			this.SendEvent.Reset();
			return result;
		}

		public void Close() {
			this.tokenSource.Cancel();
		}

		public override String ToString(Scope e) {
			return "Channel";
		}
	}

	public class Promise : Value {
		public System.Threading.Tasks.Task<Value> task;

		public Promise(System.Threading.Tasks.Task<Value> task) {
			this.task = task;
		}

		public IType Type => this.task.Result.Type;

		public Value Clone() {
			return this.task.Result.Clone();
		}

		public Int32 CompareTo(Object obj) {
			return this.task.Result.CompareTo(obj);
		}

		public String ToString(Scope e) {
			return this.task.Result.ToString(e);
		}

		public String ToString(String format, IFormatProvider formatProvider) {
			return this.task.Result.ToString(format, formatProvider);
		}

		public override String ToString() {
			return this.task.Result.ToString();
		}
	}


	if (manager.HasYield) {
				v = new LambdaFun((sc, ar) => {
					CancellationTokenSource tokenSource = new CancellationTokenSource();
					CancellationToken ct = tokenSource.Token;

					Channel channel = new Channel(tokenSource);
					sc["$defchan"] = channel;

					ff = ff.Clone() as Fun;
					(ff as UserFun).Body = (ff as UserFun).Body.Closure(new ClosureManager(sc, true));

					Task<Value>.Factory.StartNew(() => {
						Value result = ff.Run(sc, ar);
						channel.Close();
						return result;
					}, ct);

					return new Stream(new YieldGenerator(channel));
				}) {
					Arguments = ff.Arguments,
					IsLazy = ff.IsLazy,
					Name = ff.Name	
				};
			}
class Attributed 'a where
    let getAttribute instance (name: Text)
    let setAttribute instance (name: Text) value

type Vec = Vec internal attrs where
    deriving Format
    deriving Attributed 
    
    let constructor internal =
        base internal (Map ())
    
    let getAttribute (Vec _ attrs) (name: Text) =
        attrs.[name]
    let setAttribute (Vec _ attrs) (name: Text) value =
        attrs.[name] <- value
    
    let + (Vec internal _) operand = 
        Vec (List.map (_ + operand) internal)
    let - (Vec internal _) operand = 
        Vec (List.map (_ - operand) internal)
    let * (Vec internal _) operand = 
        Vec (List.map (_ * operand) internal)
    let / (Vec internal _) operand = 
        Vec (List.map (_ / operand) internal)
    let toText (Vec internal _) =
        "Vec [\(List.count internal id)] \(internal)"
    let format (Vec internal _) as vec mod =
        if mod = "p" or mod = "pretty":
            let mut result = "Vec "
            let mut resultHelper = "\t"
            let mut index = 0
            for i in internal:
                let modified = " \(i)  "
                result <- result + "[\(index)]" + (" " * (*modified - *"[\(index)]"))
                resultHelper <- resultHelper + modified
                index <- index + 1
            return "\(result)\e\(resultHelper)"
        return Vec.toText vec

let getAttr (some: Attributed) (name: Text) =
    return some.getAttribute name
        
let m = Map [["name", "v"]]
let v = Vec ["Hello!", "how", "are", "u"] m 
print "\(v:pretty)" 
print (getAttr v "name")



public Value this[Int32 index] {
            get {
                Int32 i = index;
                index = index < 0 ? this.value.Count + index : index;

                if (index >= this.value.Count || index < 0) {
                    throw new LumenException("âûõîä çà ïðåäåëû ñïèñêà ïðè ñðåçå âèäà [i]. Òðåáóåìûé èíäåêñ [" + i + "] ïðåâûøàåò äëèíó ñïèñêà [" + this.value.Count + "]");
                }

                return this.value[index];
            }
            set {
                index = index < 0 ? this.value.Count + index : index;

                if (index >= this.value.Count) {
                    for (Int32 j = this.value.Count; j < index; j++) {
                        this.value.Add(Const.UNIT);
                    }

                    this.value.Add(value);

                } else if (index < 0) {
                    this.value.InsertRange(0, new Array(-index - 1).value);
                    this.value.Insert(0, value);
                } else {
                    this.value[index] = value;
                }
            }
        }

        public Value this[Int32 first, Int32 second] {
            get {
                Int32 i = first;
                Int32 j = second;

                if (first < 0) {
                    first = this.value.Count + first;
                }

                if (second < 0) {
                    second = this.value.Count + second;
                }

                if (second != this.value.Count) {
                    second++;
                }

                if (first > this.value.Count || second > this.value.Count || first < 0 || second < 0) {
                    throw new LumenException("âûõîä çà ïðåäåëû ñïèñêà ïðè ñðåçå âèäà [i:j]: ãðàíèöû òðåáóåìîãî äèàïàçîía [" + i + ":" + j + "] ïðåâûøàþò äëèíó ñïèñêà [" + this.value.Count + "]");
                }

                if (first >= second) {
                    return new Array();
                }

                List<Value> val = new List<Value>();

                for (Int32 index = first; index < second; index++) {
                    val.Add(this.value[index]);
                }

                return new Array(val);
            }
            set {
                Int32 i = first;
                Int32 j = second;

                if (first < 0) {
                    first = this.value.Count + first;
                }

                if (second < 0) {
                    second = this.value.Count + second;
                }

                if (i == 0) {
                    if (second != this.value.Count) {
                        second++;
                    }
                }

                if (first > this.value.Count || second > this.value.Count) {
                    throw new LumenException("âûõîä çà ïðåäåëû ñïèñêà ïðè ñðåçå âèäà [i:j]: ãðàíèöû òðåáóåìîãî äèàïàçîía [" + i + ":" + j + "] ïðåâûøàþò äëèíó ñïèñêà [" + this.value.Count + "]");
                }

                this.value.RemoveRange(first, second);

                this.value.Insert(first, value);
            }
        }

            this.SetMember("inc", new LambdaFun((e, args) => {
                String value = e["text"].ToString();
                const String chars = "0123456789ABCDEFGHIJKLMNOPQRSTUVWXYZabcdefghijklmnopqrstuvwxyz";
                Int32 last_char = value.Length - 1;
                while (true) {
                    Int32 index = chars.IndexOf(value[last_char]);
                    if (index == -1) {
                        last_char--;
                        if (last_char == -1) {
                            return new Text(value.Substring(0, value.Length - 1) + (Char)(1 + value[value.Length - 1]));
                        }
                        continue;
                    }
                    while (true) {
                        index = chars.IndexOf(value[last_char]);
                        if (chars[index] == 'Z') {
                            if (last_char == 0) {
                                value = "AA" + value.Substring(1);
                                break;
                            }
                            value = value.Substring(0, last_char) + "A" + value.Substring(last_char + 1);
                            last_char--;
                        } else if (chars[index] == 'z') {
                            if (last_char == 0) {
                                value = "aa" + value.Substring(1);
                                break;
                            }
                            value = value.Substring(0, last_char) + "a" + value.Substring(last_char + 1);
                            last_char--;
                        } else if (chars[index] == '9') {
                            if (last_char == 0) {
                                value = "10" + value.Substring(1);
                                break;
                            }
                            value = value.Substring(0, last_char) + "0" + value.Substring(last_char + 1);
                            last_char--;
                        } else {
                            value = value.Substring(0, last_char) + (Char)(1 + chars[index]) + value.Substring(last_char + 1);
                            break;
                        }
                    }
                    break;
                }
                return new Text(value);
            }) {
                Arguments = new List<IPattern> {
					new NamePattern("text")
				}
            });
/*using System;
using System.Linq;
using System.Text;
using System.Numerics;
namespace Lumen.Lang {
	[Serializable]
	public class BigFloat : IComparable, IComparable<BigFloat>, IEquatable<BigFloat> {
		private BigInteger numerator;
		private BigInteger denominator;

		public static readonly BigFloat One = new BigFloat(1);
		public static readonly BigFloat Zero = new BigFloat(0);
		public static readonly BigFloat MinusOne = new BigFloat(-1);
		public static readonly BigFloat OneHalf = new BigFloat(1, 2);

		public Int32 Sign {
			get {
				switch (this.numerator.Sign + this.denominator.Sign) {
					case 2:
					case -2:
						return 1;
					case 0:
						return -1;
					default:
						return 0;
				}
			}
		}

		//constructors
		public BigFloat() {
			this.numerator = BigInteger.Zero;
			this.denominator = BigInteger.One;
		}

		public BigFloat(string value) {
			BigFloat bf = Parse(value);
			this.numerator = bf.numerator;
			this.denominator = bf.denominator;
		}

		public BigFloat(BigInteger numerator, BigInteger denominator) {
			this.numerator = numerator;
			if (denominator == 0)
				throw new ArgumentException("denominator equals 0");
			this.denominator = BigInteger.Abs(denominator);
		}

		public BigFloat(BigInteger value) {
			this.numerator = value;
			this.denominator = BigInteger.One;
		}

		public BigFloat(BigFloat value) {
			if (BigFloat.Equals(value, null)) {
				this.numerator = BigInteger.Zero;
				this.denominator = BigInteger.One;
			}
			else {

				this.numerator = value.numerator;
				this.denominator = value.denominator;
			}
		}

		public BigFloat(ulong value) {
			this.numerator = new BigInteger(value);
			this.denominator = BigInteger.One;
		}

		public BigFloat(long value) {
			this.numerator = new BigInteger(value);
			this.denominator = BigInteger.One;
		}

		public BigFloat(uint value) {
			this.numerator = new BigInteger(value);
			this.denominator = BigInteger.One;
		}

		public BigFloat(int value) {
			this.numerator = new BigInteger(value);
			this.denominator = BigInteger.One;
		}

		public BigFloat(float value) : this(value.ToString("N99")) {
		}

		public BigFloat(double value) : this(value.ToString("N99", System.Globalization.CultureInfo.InvariantCulture.NumberFormat)) {

		}

		public BigFloat(decimal value) : this(value.ToString("N99")) {
		}

		//non-static methods
		public BigFloat Add(BigFloat other) {
			if (BigFloat.Equals(other, null)) {
				throw new ArgumentNullException("other");
			}

			this.numerator = this.numerator * other.denominator + other.numerator * this.denominator;
			this.denominator *= other.denominator;
			return this;
		}

		public BigFloat Subtract(BigFloat other) {
			if (BigFloat.Equals(other, null)) {
				throw new ArgumentNullException("other");
			}

			this.numerator = this.numerator * other.denominator - other.numerator * this.denominator;
			this.denominator *= other.denominator;
			return this;
		}

		public BigFloat Multiply(BigFloat other) {
			if (BigFloat.Equals(other, null))
				throw new ArgumentNullException("other");

			this.numerator *= other.numerator;
			this.denominator *= other.denominator;
			return this;
		}

		public BigFloat Divide(BigFloat other) {
			if (BigInteger.Equals(other, null))
				throw new ArgumentNullException("other");
			if (other.numerator == 0)
				throw new System.DivideByZeroException("other");

			this.numerator *= other.denominator;
			this.denominator *= other.numerator;
			return this;
		}

		public BigFloat Remainder(BigFloat other) {
			if (BigInteger.Equals(other, null))
				throw new ArgumentNullException("other");

			//b = a mod n
			//remainder = a - floor(a/n) * n

			BigFloat result = this - Floor(this / other) * other;

			this.numerator = result.numerator;
			this.denominator = result.denominator;


			return this;
		}

		public BigFloat DivideRemainder(BigFloat other, out BigFloat remainder) {
			this.Divide(other);

			remainder = BigFloat.Remainder(this, other);

			return this;
		}

		public BigFloat Pow(int exponent) {
			if (this.numerator.IsZero) {
				// Nothing to do
			}
			else if (exponent < 0) {
				BigInteger savedNumerator = this.numerator;
				this.numerator = BigInteger.Pow(this.denominator, -exponent);
				this.denominator = BigInteger.Pow(savedNumerator, -exponent);
			}
			else {
				this.numerator = BigInteger.Pow(this.numerator, exponent);
				this.denominator = BigInteger.Pow(this.denominator, exponent);
			}

			return this;
		}

		public BigFloat Abs() {
			this.numerator = BigInteger.Abs(this.numerator);
			return this;
		}

		public BigFloat Negate() {
			this.numerator = BigInteger.Negate(this.numerator);
			return this;
		}

		public BigFloat Inverse() {
			BigInteger temp = this.numerator;
			this.numerator = this.denominator;
			this.denominator = temp;
			return this;
		}

		public BigFloat Increment() {
			this.numerator += this.denominator;
			return this;
		}

		public BigFloat Decrement() {
			this.numerator -= this.denominator;
			return this;
		}

		public BigFloat Ceil() {
			if (this.numerator < 0)
				this.numerator -= BigInteger.Remainder(this.numerator, this.denominator);
			else
				this.numerator += this.denominator - BigInteger.Remainder(this.numerator, this.denominator);

			this.Factor();
			return this;
		}

		public BigFloat Floor() {
			if (this.numerator < 0)
				this.numerator += this.denominator - BigInteger.Remainder(this.numerator, this.denominator);
			else
				this.numerator -= BigInteger.Remainder(this.numerator, this.denominator);

			this.Factor();
			return this;
		}

		public BigFloat Round() {
			//get remainder. Over divisor see if it is > new BigFloat(0.5)
			BigFloat value = BigFloat.Decimals(this);

			if (value.CompareTo(OneHalf) >= 0)
				this.Ceil();
			else
				this.Floor();

			return this;
		}

		public BigFloat Truncate() {
			this.numerator -= BigInteger.Remainder(this.numerator, this.denominator);
			this.Factor();
			return this;
		}

		public BigFloat Decimals() {
			BigInteger result = BigInteger.Remainder(this.numerator, this.denominator);

			return new BigFloat(result, this.denominator);
		}

		public BigFloat ShiftDecimalLeft(int shift) {
			if (shift < 0)
				return this.ShiftDecimalRight(-shift);

			this.numerator *= BigInteger.Pow(10, shift);
			return this;
		}

		public BigFloat ShiftDecimalRight(int shift) {
			if (shift < 0)
				return this.ShiftDecimalLeft(-shift);
			this.denominator *= BigInteger.Pow(10, shift);
			return this;
		}

		public double Sqrt() {
			return Math.Pow(10, BigInteger.Log10(this.numerator) / 2) / Math.Pow(10, BigInteger.Log10(this.denominator) / 2);
		}

		public double Log10() {
			return BigInteger.Log10(this.numerator) - BigInteger.Log10(this.denominator);
		}

		public double Log(double baseValue) {
			return BigInteger.Log(this.numerator, baseValue) - BigInteger.Log(this.numerator, baseValue);
		}

		public override string ToString() {
			//default precision = 100
			return this.ToString(100);
		}

		public string ToString(int precision, bool trailingZeros = false) {
			this.Factor();

			BigInteger remainder;
			BigInteger result = BigInteger.DivRem(this.numerator, this.denominator, out remainder);

			if (remainder == 0 && trailingZeros)
				return result + ".0";
			else if (remainder == 0)
				return result.ToString();


			BigInteger decimals = (this.numerator * BigInteger.Pow(10, precision)) / this.denominator;

			if (decimals == 0 && trailingZeros)
				return result + ".0";
			else if (decimals == 0)
				return result.ToString();

			StringBuilder sb = new StringBuilder();

			while (precision-- > 0 && decimals > 0) {
				sb.Append(decimals % 10);
				decimals /= 10;
			}

			if (trailingZeros)
				return result + "." + new string(sb.ToString().Reverse().ToArray());
			else
				return result + "." + new string(sb.ToString().Reverse().ToArray()).TrimEnd(new char[] { '0' });


		}

		public string ToMixString() {
			this.Factor();

			BigInteger remainder;
			BigInteger result = BigInteger.DivRem(this.numerator, this.denominator, out remainder);

			if (remainder == 0)
				return result.ToString();
			else
				return result + ", " + remainder + "/" + this.denominator;
		}

		public string ToRationalString() {
			this.Factor();

			return this.numerator + "/" + this.denominator;
		}

		public Int32 CompareTo(BigFloat other) {
			if (BigFloat.Equals(other, null)) {
				throw new ArgumentNullException("other");
			}

			//Make copies
			BigInteger one = this.numerator;
			BigInteger two = other.numerator;

			//cross multiply
			one *= other.denominator;
			two *= this.denominator;

			//test
			return BigInteger.Compare(one, two);
		}

		public int CompareTo(object other) {
			if (other == null)
				throw new ArgumentNullException("other");

			if (!(other is BigFloat))
				throw new System.ArgumentException("other is not a BigFloat");

			return this.CompareTo((BigFloat)other);
		}

		public override bool Equals(object other) {
			if (other == null || this.GetType() != other.GetType()) {
				return false;
			}

			return this.numerator == ((BigFloat)other).numerator && this.denominator == ((BigFloat)other).denominator;
		}

		public bool Equals(BigFloat other) {
			return (other.numerator == this.numerator && other.denominator == this.denominator);
		}

		public override int GetHashCode() {
			return this.numerator.GetHashCode() | this.denominator.GetHashCode();
			//return base.GetHashCode();
		}

		//static methods
		public static bool Equals(object left, object right) {
			if (left == null && right == null)
				return true;
			else if (left == null || right == null)
				return false;
			else if (left.GetType() != right.GetType())
				return false;
			else
				return (((BigInteger)left).Equals((BigInteger)right));
		}

		public static string ToString(BigFloat value) {
			return value.ToString();
		}

		public static BigFloat Inverse(BigFloat value) {
			return (new BigFloat(value)).Inverse();
		}

		public static BigFloat Decrement(BigFloat value) {
			return (new BigFloat(value)).Decrement();
		}

		public static BigFloat Negate(BigFloat value) {
			return (new BigFloat(value)).Negate();
		}

		public static BigFloat Increment(BigFloat value) {
			return (new BigFloat(value)).Increment();
		}

		public static BigFloat Abs(BigFloat value) {
			return (new BigFloat(value)).Abs();
		}

		public static BigFloat Add(BigFloat left, BigFloat right) {
			return (new BigFloat(left)).Add(right);
		}

		public static BigFloat Subtract(BigFloat left, BigFloat right) {
			return (new BigFloat(left)).Subtract(right);
		}

		public static BigFloat Multiply(BigFloat left, BigFloat right) {
			return (new BigFloat(left)).Multiply(right);
		}

		public static BigFloat Divide(BigFloat left, BigFloat right) {
			return (new BigFloat(left)).Divide(right);
		}

		public static BigFloat Pow(BigFloat value, int exponent) {
			return (new BigFloat(value)).Pow(exponent);
		}

		public static BigFloat Remainder(BigFloat left, BigFloat right) {
			return (new BigFloat(left)).Remainder(right);
		}

		public static BigFloat DivideRemainder(BigFloat left, BigFloat right, out BigFloat remainder) {
			return (new BigFloat(left)).DivideRemainder(right, out remainder);
		}

		public static BigFloat Decimals(BigFloat value) {
			return value.Decimals();
		}

		public static BigFloat Truncate(BigFloat value) {
			return (new BigFloat(value)).Truncate();
		}

		public static BigFloat Ceil(BigFloat value) {
			return (new BigFloat(value)).Ceil();
		}

		public static BigFloat Floor(BigFloat value) {
			return (new BigFloat(value)).Floor();
		}

		public static BigFloat Round(BigFloat value) {
			return (new BigFloat(value)).Round();
		}

		public static BigFloat Parse(string value) {
			if (value == null)
				throw new ArgumentNullException("value");

			value.Trim();
			value = value.Replace(",", "");
			int pos = value.IndexOf('.');
			value = value.Replace(".", "");

			if (pos < 0) {
				//no decimal point
				BigInteger numerator = BigInteger.Parse(value);
				return (new BigFloat(numerator)).Factor();
			}
			else {
				//decimal point (length - pos - 1)
				BigInteger numerator = BigInteger.Parse(value);
				BigInteger denominator = BigInteger.Pow(10, value.Length - pos);

				return (new BigFloat(numerator, denominator)).Factor();
			}
		}

		public static BigFloat ShiftDecimalLeft(BigFloat value, int shift) {
			return (new BigFloat(value)).ShiftDecimalLeft(shift);
		}

		public static BigFloat ShiftDecimalRight(BigFloat value, int shift) {
			return (new BigFloat(value)).ShiftDecimalRight(shift);
		}
		public static bool TryParse(string value, out BigFloat result) {
			try {
				result = BigFloat.Parse(value);
				return true;
			}
			catch (ArgumentNullException) {
				result = null;
				return false;
			}
			catch (FormatException) {
				result = null;
				return false;
			}
		}
		public static int Compare(BigFloat left, BigFloat right) {
			if (BigFloat.Equals(left, null))
				throw new ArgumentNullException("left");
			if (BigFloat.Equals(right, null))
				throw new ArgumentNullException("right");

			return (new BigFloat(left)).CompareTo(right);
		}
		public static double Log10(BigFloat value) {
			return (new BigFloat(value)).Log10();
		}
		public static double Log(BigFloat value, double baseValue) {
			return (new BigFloat(value)).Log(baseValue);
		}
		public static double Sqrt(BigFloat value) {
			return (new BigFloat(value)).Sqrt();
		}

		public static BigFloat operator -(BigFloat value) {
			return (new BigFloat(value)).Negate();
		}
		public static BigFloat operator -(BigFloat left, BigFloat right) {
			return (new BigFloat(left)).Subtract(right);
		}
		public static BigFloat operator --(BigFloat value) {
			return value.Decrement();
		}
		public static BigFloat operator +(BigFloat left, BigFloat right) {
			return (new BigFloat(left)).Add(right);
		}
		public static BigFloat operator +(BigFloat value) {
			return (new BigFloat(value)).Abs();
		}
		public static BigFloat operator ++(BigFloat value) {
			return value.Increment();
		}
		public static BigFloat operator %(BigFloat left, BigFloat right) {
			return (new BigFloat(left)).Remainder(right);
		}
		public static BigFloat operator *(BigFloat left, BigFloat right) {
			return (new BigFloat(left)).Multiply(right);
		}
		public static BigFloat operator /(BigFloat left, BigFloat right) {
			return (new BigFloat(left)).Divide(right);
		}
		public static BigFloat operator >>(BigFloat value, int shift) {
			return (new BigFloat(value)).ShiftDecimalRight(shift);
		}
		public static BigFloat operator <<(BigFloat value, int shift) {
			return (new BigFloat(value)).ShiftDecimalLeft(shift);
		}
		public static BigFloat operator ^(BigFloat left, int right) {
			return (new BigFloat(left)).Pow(right);
		}
		public static BigFloat operator ~(BigFloat value) {
			return (new BigFloat(value)).Inverse();
		}

		public static bool operator !=(BigFloat left, BigFloat right) {
			return Compare(left, right) != 0;
		}
		public static bool operator ==(BigFloat left, BigFloat right) {
			return Compare(left, right) == 0;
		}
		public static bool operator <(BigFloat left, BigFloat right) {
			return Compare(left, right) < 0;
		}
		public static bool operator <=(BigFloat left, BigFloat right) {
			return Compare(left, right) <= 0;
		}
		public static bool operator >(BigFloat left, BigFloat right) {
			return Compare(left, right) > 0;
		}
		public static bool operator >=(BigFloat left, BigFloat right) {
			return Compare(left, right) >= 0;
		}

		public static bool operator true(BigFloat value) {
			return value != 0;
		}
		public static bool operator false(BigFloat value) {
			return value == 0;
		}

		public static explicit operator decimal(BigFloat value) {
			if (decimal.MinValue > value)
				throw new System.OverflowException("value is less than System.decimal.MinValue.");
			if (decimal.MaxValue < value)
				throw new System.OverflowException("value is greater than System.decimal.MaxValue.");

			return (decimal)value.numerator / (decimal)value.denominator;
		}
		public static explicit operator double(BigFloat value) {
			if (double.MinValue > value)
				throw new System.OverflowException("value is less than System.double.MinValue.");
			if (double.MaxValue < value)
				throw new System.OverflowException("value is greater than System.double.MaxValue.");

			return (double)value.numerator / (double)value.denominator;
		}
		public static explicit operator float(BigFloat value) {
			if (float.MinValue > value)
				throw new System.OverflowException("value is less than System.float.MinValue.");
			if (float.MaxValue < value)
				throw new System.OverflowException("value is greater than System.float.MaxValue.");

			return (float)value.numerator / (float)value.denominator;
		}

		//byte, sbyte, 
		public static implicit operator BigFloat(byte value) {
			return new BigFloat((uint)value);
		}
		public static implicit operator BigFloat(sbyte value) {
			return new BigFloat((int)value);
		}
		public static implicit operator BigFloat(short value) {
			return new BigFloat((int)value);
		}
		public static implicit operator BigFloat(ushort value) {
			return new BigFloat((uint)value);
		}
		public static implicit operator BigFloat(int value) {
			return new BigFloat(value);
		}
		public static implicit operator BigFloat(long value) {
			return new BigFloat(value);
		}
		public static implicit operator BigFloat(uint value) {
			return new BigFloat(value);
		}
		public static implicit operator BigFloat(ulong value) {
			return new BigFloat(value);
		}
		public static implicit operator BigFloat(decimal value) {
			return new BigFloat(value);
		}
		public static implicit operator BigFloat(double value) {
			return new BigFloat(value);
		}
		public static implicit operator BigFloat(float value) {
			return new BigFloat(value);
		}
		public static implicit operator BigFloat(BigInteger value) {
			return new BigFloat(value);
		}
		public static explicit operator BigFloat(string value) {
			return new BigFloat(value);
		}

		private BigFloat Factor() {
			//factoring can be very slow. So use only when neccessary (ToString, and comparisons)

			if (this.denominator == 1)
				return this;

			//factor numerator and denominator
			BigInteger factor = BigInteger.GreatestCommonDivisor(this.numerator, this.denominator);

			this.numerator /= factor;
			this.denominator /= factor;

			return this;
		}

	}
}*/


using System;
using System.Collections.Generic;

namespace Lumen.Lang {
	public class BigNumber : Value {
		internal BigFloat value;

		public IType Type => Prelude.Number;

		public BigNumber(Double value) {
			this.value = value;
		}

		public BigNumber(BigFloat value) {
			this.value = value;
		}

		public static implicit operator BigNumber(Double value) {
			return new BigNumber(value);
		}

		public static implicit operator BigNumber(Int32 value) {
			return new BigNumber(value);
		}

		public static BigNumber operator -(BigNumber one) {
			return new BigNumber(-one.value);
		}

		public Value Clone() {
			return this;
		}

		public override Boolean Equals(Object obj) => obj switch
		{
			Number numb => this.value == numb.value,
			BigNumber num => this.value == num.value,
			_ => false
		};

		public Int32 CompareTo(Object obj) => obj switch
		{
			Number numb => this.value.CompareTo(new BigNumber(numb.value)),
			BigNumber num => this.value.CompareTo(num.value),
			Value value => throw new LumenException(Exceptions.TYPE_ERROR.F(this.Type, value.Type)),
			_ => throw new LumenException(Exceptions.TYPE_ERROR.F(this.Type, obj.GetType()))
		};

		public override Int32 GetHashCode() {
			Int32 hashCode = 1927925191;
			hashCode = hashCode * -1521134295 + this.value.GetHashCode();
			hashCode = hashCode * -1521134295 + EqualityComparer<IType>.Default.GetHashCode(this.Type);
			return hashCode;
		}

		public override String ToString() {
			return this.value.ToString();
		}

		public String ToString(Scope e) {
			return this.ToString();
		}

		public String ToString(String format, IFormatProvider formatProvider) {
			return this.value.ToString();
		}
	}
}


      #region HEnumerable
        /*
		public Value this[Int32 first, Int32 second, Boolean flatten] {
			get {
				int i = first;
				int j = second;

				if (first < 0)
					first = value.Length + first;

				if (second < 0)
					second = value.Length + second;

				if (second != value.Length)
					second++;

				if (first > value.Length || second > value.Length || first < 0 || second < 0)
					throw new HException("âûõîä çà ïðåäåëû ñòðîêè ïðè ñðåçå âèäà [i:j]: ãðàíèöû òðåáóåìîãî äèàïàçîía [" + i + ":" + j + "] ïðåâûøàþò äëèíó ñòðîêè [" + value.Length + "]", "IndexException");

				if (first >= second)
					return new KString("");

				return new KString(value.SubString(first, second - first + 1));
			}
			set {
				int i = first;
				int j = second;

				if (first < 0)
					first = this.value.Length + first;

				if (second < 0)
					second = this.value.Length + second;

				if (i == 0)
					if (second != this.value.Length)
						second++;

				if (first > this.value.Length || second > this.value.Length)
					throw new HException("âûõîä çà ïðåäåëû ñïèñêà ïðè ñðåçå âèäà [i:j]: ãðàíèöû òðåáóåìîãî äèàïàçîía [" + i + ":" + j + "] ïðåâûøàþò äëèíó ñïèñêà [" + this.value.Length + "]", "IndexException");

				if (second + 1 > this.value.Length)
					this.value = this.value.SubString(0, first) + value.ToString();
				else
					this.value = this.value.SubString(0, first) + value.ToString() +
						this.value.SubString(second + 1, this.value.Length - second - 1);
			}
		}

		public Value this[Int32 index, Boolean flatten] {
			get {
				int i = index;
				index = index < 0 ? value.Length + index : index;

				if (index >= value.Length || index < 0)
					throw new HException("âûõîä çà ïðåäåëû ñòðîêè ïðè ñðåçå âèäà [i]. Òðåáóåìûé èíäåêñ [" + i + "] ïðåâûøàåò äëèíó ñòðîêè [" + value.Length + "]", "IndexException");

				return new KString(value[index].ToString());
			}
			set {
				int i = index;
				index = index < 0 ? this.value.Length + index : index;

				if (index == this.value.Length)
					this.value = this.value + value.ToString();
				else if (index == -1)
					this.value = value.ToString() + this.value;
				else if (index < this.value.Length && index > 0)
					this.value = this.value.SubString(0, index) + value.ToString() + this.value.SubString(index + 1, this.value.Length - index - 1);
				else
					throw new HException("âûõîä çà ïðåäåëû ñòðîêè ïðè óñòàíîâêå âèäà [i]. Òðåáóåìûé èíäåêñ [" + i + "] ïðåâûøàåò äëèíó ñòðîêè [" + this.value.Length + "]", "IndexException");

			}
		}

		/// <summary> Èçìåíÿåò ñèìâîë íà ïîçèöèè index ïîäñòðîêîé. </summary> <param name="index"> Ïîçèöèÿ ñèìâîëà. </param> <returns> Çíà÷åíèå òèïà String. </returns>
		public KString this[Int32 index] {
			get {
				index = index < 0 ? value.Length + index : index;

				if (index >= value.Length || index < 0)
					throw new Exception("âûõîä çà ïðåäåëû ñïèñêà ïðè ñðåçå âèäà [i]: òðåáóåìûé èíäåêñ [" + (index < 0 ? index + value.Length : index) + "] ïðåâûøàåò äëèíó ñïèñêà [" + value.Length + "]");

				return new KString(value[index].ToString());
			}

			set {
				index = index < 0 ? this.value.Length + index : index;

				if (index > this.value.Length)
					throw new Exception("âûõîä çà ïðåäåëû ñïèñêà ïðè ñðåçå âèäà [i]: òðåáóåìûé èíäåêñ [" + index + "] ïðåâûøàåò äëèíó ñïèñêà [" + this.value.Length + "]");

				if (index == this.value.Length) {
					this.value = this.value + value;
					return;
				}

				StringBuilder a = new StringBuilder();

				a.Append(this.value.SubString(0, index));
				a.Append(value);
				a.Append(this.value.SubString(index + 1, this.value.Length - index - 1));

				this.value = a.ToString();
			}
		}

		public Value this[String what] {
			get => new Fix(value.IndexOf(what));

			set {
				if (what == "")
					this.value = String.Join("", this.value.Select(x => x.ToString() + value));
				else
					this.value = this.value.Replace(what, value.ToString());
			}
		}
		*/
        #endregion