@yaksok-ts/core@0.1.19

Built and signed on GitHub Actions

Built and signed on GitHub Actions

123456789101112131415161718192021222324252627282930313233343536373839404142434445464748495051525354555657585960616263646566676869707172737475767778798081828384858687888990919293949596979899100101102103104105106107108109110111112113114115116117118119120121122123124125126127128129130131132133134135136137138139140141142143144145146147148149150151152153154155156157158159160161162163164165166167168169170171172173174175176177178179180181182183184185186187188189190191192193194195196197198199200201202203204205206207208209210211212213214215216217218219220221222223224225226227228229230231232233234235236237238239240241242243244245246247248249250251252253254255256257258259260261262263264265266267268269270271272273274275276277278279280281282283284285286287288289290291292293294295296297298299300301302303304305306307308309310311312313314315316317318319320321322323324325326327328329330331332333334335336337338339340341342343344345346347348349350351352353354355356357358359360361362363
import { InvalidTypeForCompareError } from '../error/calculation.ts'
import { InvalidTypeForOperatorError } from '../error/index.ts'
import { Operator, type ValueTypes } from './base.ts'
import {
    BooleanValue,
    NumberValue,
    PrimitiveValue,
    StringValue,
} from './primitive.ts'

export class PlusOperator extends Operator {
    static override friendlyName = '더하기(+)'

    override toPrint(): string {
        return '+'
    }

    override call(...operands: ValueTypes[]): NumberValue | StringValue {
        const [left, right] = operands

        if (left instanceof NumberValue && right instanceof NumberValue) {
            return new NumberValue(left.value + right.value)
        }

        if (left instanceof StringValue && right instanceof StringValue) {
            return new StringValue(left.value + right.value)
        }

        if (left instanceof StringValue && right instanceof NumberValue) {
            return new StringValue(left.value + right.value.toString())
        }

        if (left instanceof NumberValue && right instanceof StringValue) {
            return new StringValue(left.value.toString() + right.value)
        }

        throw new InvalidTypeForOperatorError({
            position: this.position,
            resource: {
                operator: this,
                operands,
            },
        })
    }
}

export class MinusOperator extends Operator {
    static override friendlyName = '빼기(-)'

    override toPrint(): string {
        return '-'
    }

    override call(...operands: ValueTypes[]): NumberValue {
        const [left, right] = operands
        if (left instanceof NumberValue && right instanceof NumberValue) {
            return new NumberValue(left.value - right.value)
        }

        throw new InvalidTypeForOperatorError({
            position: this.position,
            resource: {
                operator: this,
                operands,
            },
        })
    }
}

export class MultiplyOperator extends Operator {
    static override friendlyName = '곱하기(*)'

    override toPrint(): string {
        return '*'
    }

    override call(...operands: ValueTypes[]): NumberValue | StringValue {
        const [left, right] = operands
        if (left instanceof NumberValue && right instanceof NumberValue) {
            return new NumberValue(left.value * right.value)
        }

        if (left instanceof StringValue && right instanceof NumberValue) {
            return new StringValue(left.value.repeat(right.value))
        }

        if (left instanceof NumberValue && right instanceof StringValue) {
            return new StringValue(right.value.repeat(left.value))
        }

        throw new InvalidTypeForOperatorError({
            position: this.position,
            resource: {
                operator: this,
                operands,
            },
        })
    }
}

export class DivideOperator extends Operator {
    static override friendlyName = '나누기(/)'

    override toPrint(): string {
        return '/'
    }

    override call(...operands: ValueTypes[]): NumberValue {
        const [left, right] = operands

        if (left instanceof NumberValue && right instanceof NumberValue) {
            return new NumberValue(left.value / right.value)
        }

        throw new InvalidTypeForOperatorError({
            position: this.position,
            resource: {
                operator: this,
                operands,
            },
        })
    }
}

export class ModularOperator extends Operator {
    static override friendlyName = '나머지(%)'

    override toPrint(): string {
        return '%'
    }

    override call(...operands: ValueTypes[]): NumberValue {
        const [left, right] = operands

        if (left instanceof NumberValue && right instanceof NumberValue) {
            return new NumberValue(left.value % right.value)
        }

        throw new InvalidTypeForOperatorError({
            position: this.position,
            resource: {
                operator: this,
                operands,
            },
        })
    }
}
export class PowerOperator extends Operator {
    static override friendlyName = '제곱(**)'

    override toPrint(): string {
        return '**'
    }

    override call(...operands: ValueTypes[]): NumberValue {
        const [left, right] = operands

        if (left instanceof NumberValue && right instanceof NumberValue) {
            return new NumberValue(left.value ** right.value)
        }

        throw new InvalidTypeForOperatorError({
            position: this.position,
            resource: {
                operator: this,
                operands,
            },
        })
    }
}
export class IntegerDivideOperator extends Operator {
    static override friendlyName = '정수 나누기(//)'

    override toPrint(): string {
        return '//'
    }

    override call(...operands: ValueTypes[]): NumberValue {
        const [left, right] = operands

        if (left instanceof NumberValue && right instanceof NumberValue) {
            return new NumberValue(Math.floor(left.value / right.value))
        }

        throw new InvalidTypeForOperatorError({
            position: this.position,
            resource: {
                operator: this,
                operands,
            },
        })
    }
}

export class EqualOperator extends Operator {
    static override friendlyName = '같다(=)'

    override toPrint(): string {
        return '='
    }

    override call(...operands: ValueTypes[]): BooleanValue {
        const [left, right] = operands

        if (left instanceof PrimitiveValue && right instanceof PrimitiveValue) {
            return new BooleanValue(left.value === right.value)
        }

        throw new Error(
            "Evaluation equality between non-primitive values isn't supported yet.",
        )
    }
}

export class AndOperator extends Operator {
    static override friendlyName = '이고(그리고)'

    override toPrint(): string {
        return '이고(그리고)'
    }

    override call(...operands: ValueTypes[]): BooleanValue {
        const [left, right] = operands

        if (
            !(left instanceof BooleanValue) ||
            !(right instanceof BooleanValue)
        ) {
            throw new InvalidTypeForOperatorError({
                position: this.position,
                resource: {
                    operator: this,
                    operands,
                },
            })
        }

        return new BooleanValue(left.value && right.value)
    }
}

export class OrOperator extends Operator {
    static override friendlyName = '이거나(거나)'

    override toPrint(): string {
        return '이거나(거나)'
    }

    override call(...operands: ValueTypes[]): BooleanValue {
        const [left, right] = operands

        if (
            !(left instanceof BooleanValue) ||
            !(right instanceof BooleanValue)
        ) {
            throw new InvalidTypeForOperatorError({
                position: this.position,
                resource: {
                    operator: this,
                    operands,
                },
            })
        }

        return new BooleanValue(left.value || right.value)
    }
}

export class GreaterThanOperator extends Operator {
    static override friendlyName = '크다(>)'

    override toPrint(): string {
        return '>'
    }

    override call(...operands: ValueTypes[]): BooleanValue {
        const [left, right] = operands

        if (left instanceof NumberValue && right instanceof NumberValue) {
            return new BooleanValue(left.value > right.value)
        }

        throw new InvalidTypeForCompareError({
            position: this.position,
            resource: {
                left,
                right,
            },
        })
    }
}

export class LessThanOperator extends Operator {
    static override friendlyName = '작다(<)'

    override toPrint(): string {
        return '<'
    }

    override call(...operands: ValueTypes[]): BooleanValue {
        const [left, right] = operands

        if (left instanceof NumberValue && right instanceof NumberValue) {
            return new BooleanValue(left.value < right.value)
        }

        throw new InvalidTypeForCompareError({
            position: this.position,
            resource: {
                left,
                right,
            },
        })
    }
}

export class GreaterThanOrEqualOperator extends Operator {
    static override friendlyName = '크거나 같다(>=)'

    override toPrint(): string {
        return '>='
    }

    override call(...operands: ValueTypes[]): BooleanValue {
        const [left, right] = operands

        if (left instanceof NumberValue && right instanceof NumberValue) {
            return new BooleanValue(left.value >= right.value)
        }

        throw new InvalidTypeForCompareError({
            position: this.position,
            resource: {
                left,
                right,
            },
        })
    }
}

export class LessThanOrEqualOperator extends Operator {
    static override friendlyName = '작거나 같다(<=)'

    override toPrint(): string {
        return '<='
    }

    override call(...operands: ValueTypes[]): BooleanValue {
        const [left, right] = operands

        if (left instanceof NumberValue && right instanceof NumberValue) {
            return new BooleanValue(left.value <= right.value)
        }

        throw new InvalidTypeForCompareError({
            position: this.position,
            resource: {
                left,
                right,
            },
        })
    }
}