swift 遗忘语言的标准库进展

Posted 2021-05-19

//main value type for Oblivion language
enum OblLst {
    
    case int(Int)
    case str(String)
    case bool(Bool)
    indirect case lst([OblLst])
    case null
    
    //integer initializer
    init(val:Int) {
        self = .int(val)
    }
    
    //string initializer
    init(val:String){
        self = .str(val)
    }
    
    //bool initializer
    init(val:Bool){
        self = .bool(val)
    }
    //computed variable access for swift values
    var int:Int {
        switch self {
        case .int(let int):
            return int
        default:
            return 0
        }
    }
    var str:String {
        switch self {
        case .str(let str):
            return str
        default:
            return ""
        }
    }
    var bool:Bool {
        switch self {
        case .bool(let bool):
            return bool
        default:
            return false
        }
    }
    var lst:[OblLst] {
        switch self {
        case .lst(let lst):
            return lst
        default:
            return [OblLst]()
        }
    }
    
    subscript (index:OblLst) -> OblLst {
        get {
            switch index {
            case .int(let i):
                switch self {
                case .lst(let list):
                    if i > 0 && i < list.count {
                        return list[i]
                    }
                    else {
                        return OblLst.null
                    }
                default:
                    return OblLst.null
                }
            default:
                return OblLst.null
            }
        }
    }
    
}

//standard library of functons in the Oblivion language
struct stdlib {
    
    static func add(a:OblLst, b:OblLst) -> OblLst {
        return OblLst.int(a.int + b.int)
    }
    
    static func sub(a:OblLst, b:OblLst) -> OblLst {
        return OblLst.int(a.int - b.int)
    }
    
    static func mul(a:OblLst, b:OblLst) -> OblLst {
        return OblLst.int(a.int * b.int)
    }
    
    static func div(a:OblLst, b:OblLst) -> OblLst {
        return OblLst.int(a.int / b.int)
    }
    
    static func rem(a:OblLst, b:OblLst) -> OblLst {
        return OblLst.int(a.int % b.int)
    }
    
    static func cat(a:OblLst, b:OblLst) -> OblLst {
        return OblLst.str(a.str + b.str)
    }
    
    static func ext(a:OblLst, b:OblLst) -> OblLst {
        return OblLst.lst(a.lst + b.lst)
    }
    //gets last element of lst
    static func pop(a:OblLst) -> OblLst {
        if let popped = a.lst.last {
            return popped
        }
        else {
            return OblLst.null
        }
    }
}