walkzzz/moon2dart/ast does not have a README file

    ImplMethod

    pub(all) struct ImplMethod {
    name : String
    params : Array[(String, MoonType)]
    ret_type : MoonType
    body : MoonExpr
    } derive(Compare, Eq,
    Debug
    )

    impl 方法实现 — 方法名 + 参数列表 + 返回类型 + 方法体。

    ImplMethod::compare

    fn ImplMethod::compare(ImplMethod, ImplMethod) -> Int

    ImplMethod::equal

    fn ImplMethod::equal(ImplMethod, ImplMethod) -> Bool

    ImplMethod::not_equal

    fn ImplMethod::not_equal(x : ImplMethod, y : ImplMethod) -> Bool

    ImplMethod::op_ge

    fn ImplMethod::op_ge(x : ImplMethod, y : ImplMethod) -> Bool

    ImplMethod::op_gt

    fn ImplMethod::op_gt(x : ImplMethod, y : ImplMethod) -> Bool

    ImplMethod::op_le

    fn ImplMethod::op_le(x : ImplMethod, y : ImplMethod) -> Bool

    ImplMethod::op_lt

    fn ImplMethod::op_lt(x : ImplMethod, y : ImplMethod) -> Bool

    MoonDecl

    pub(all) enum MoonDecl {
    DFn(String, Array[String], Array[(String, MoonType)], MoonType, MoonExpr)
    DAsyncFn(String, Array[String], Array[(String, MoonType)], MoonType, MoonExpr)
    DStruct(String, Array[String], Array[(String, MoonType)], Array[String])
    DEnum(String, Array[String])
    DTrait(String, Array[TraitMethod])
    DImpl(String, String, Array[ImplMethod])
    DExternFn(String, Array[(String, MoonType)], MoonType, String)
    } derive(Compare, Eq,
    Debug
    )

    MoonBit 声明节点。

    MoonDecl::compare

    fn MoonDecl::compare(MoonDecl, MoonDecl) -> Int

    MoonDecl::equal

    fn MoonDecl::equal(MoonDecl, MoonDecl) -> Bool

    MoonDecl::not_equal

    fn MoonDecl::not_equal(x : MoonDecl, y : MoonDecl) -> Bool

    MoonDecl::op_ge

    fn MoonDecl::op_ge(x : MoonDecl, y : MoonDecl) -> Bool

    MoonDecl::op_gt

    fn MoonDecl::op_gt(x : MoonDecl, y : MoonDecl) -> Bool

    MoonDecl::op_le

    fn MoonDecl::op_le(x : MoonDecl, y : MoonDecl) -> Bool

    MoonDecl::op_lt

    fn MoonDecl::op_lt(x : MoonDecl, y : MoonDecl) -> Bool

    MoonDecl::to_repr

    MoonExpr

    pub(all) enum MoonExpr {
    EInt(Int)
    EDouble(Double)
    EBool(Bool)
    EString(String)
    EVar(String)
    ECall(String, Array[MoonExpr])
    EBinOp(String, MoonExpr, MoonExpr)
    EIf(MoonExpr, MoonExpr, MoonExpr)
    EMatch(MoonExpr, Array[(MoonPattern, MoonExpr)])
    EAwait(MoonExpr)
    ELambda(Array[(String, MoonType)], MoonExpr)
    } derive(Compare, Eq,
    Debug
    )

    MoonBit 表达式节点(v0.1.0 子集)。

    MoonExpr::compare

    fn MoonExpr::compare(MoonExpr, MoonExpr) -> Int

    MoonExpr::equal

    fn MoonExpr::equal(MoonExpr, MoonExpr) -> Bool

    MoonExpr::not_equal

    fn MoonExpr::not_equal(x : MoonExpr, y : MoonExpr) -> Bool

    MoonExpr::op_ge

    fn MoonExpr::op_ge(x : MoonExpr, y : MoonExpr) -> Bool

    MoonExpr::op_gt

    fn MoonExpr::op_gt(x : MoonExpr, y : MoonExpr) -> Bool

    MoonExpr::op_le

    fn MoonExpr::op_le(x : MoonExpr, y : MoonExpr) -> Bool

    MoonExpr::op_lt

    fn MoonExpr::op_lt(x : MoonExpr, y : MoonExpr) -> Bool

    MoonExpr::to_repr

    MoonPattern

    pub(all) enum MoonPattern {
    PVar(String)
    PInt(Int)
    PString(String)
    PWild
    PCtor(String, Array[MoonPattern])
    } derive(Compare, Eq,
    Debug
    )

    MoonBit 模式匹配节点。

    MoonPattern::compare

    fn MoonPattern::compare(MoonPattern, MoonPattern) -> Int

    MoonPattern::equal

    fn MoonPattern::equal(MoonPattern, MoonPattern) -> Bool

    MoonPattern::not_equal

    fn MoonPattern::not_equal(x : MoonPattern, y : MoonPattern) -> Bool

    MoonPattern::op_ge

    fn MoonPattern::op_ge(x : MoonPattern, y : MoonPattern) -> Bool

    MoonPattern::op_gt

    fn MoonPattern::op_gt(x : MoonPattern, y : MoonPattern) -> Bool

    MoonPattern::op_le

    fn MoonPattern::op_le(x : MoonPattern, y : MoonPattern) -> Bool

    MoonPattern::op_lt

    fn MoonPattern::op_lt(x : MoonPattern, y : MoonPattern) -> Bool

    MoonType

    pub(all) enum MoonType {
    MInt
    MUInt
    MInt64
    MUInt64
    MDouble
    MFloat
    MBool
    MString
    MChar
    MUnit
    MArray(MoonType)
    MMap(MoonType, MoonType)
    MSet(MoonType)
    MOption(MoonType)
    MResult(MoonType, MoonType)
    MFuture(MoonType)
    MTypeVar(String)
    MCustom(String)
    } derive(Compare, Eq,
    Debug
    )

    MoonBit 类型节点 — 表示 MoonBit 源码中的类型。

    MoonType::compare

    fn MoonType::compare(MoonType, MoonType) -> Int

    MoonType::equal

    fn MoonType::equal(MoonType, MoonType) -> Bool

    MoonType::not_equal

    fn MoonType::not_equal(x : MoonType, y : MoonType) -> Bool

    MoonType::op_ge

    fn MoonType::op_ge(x : MoonType, y : MoonType) -> Bool

    MoonType::op_gt

    fn MoonType::op_gt(x : MoonType, y : MoonType) -> Bool

    MoonType::op_le

    fn MoonType::op_le(x : MoonType, y : MoonType) -> Bool

    MoonType::op_lt

    fn MoonType::op_lt(x : MoonType, y : MoonType) -> Bool

    MoonType::to_repr

    TraitMethod

    pub(all) struct TraitMethod {
    name : String
    params : Array[(String, MoonType)]
    ret_type : MoonType
    } derive(Compare, Eq,
    Debug
    )

    Trait 方法签名 — 方法名 + 参数列表 + 返回类型。

    TraitMethod::compare

    fn TraitMethod::compare(TraitMethod, TraitMethod) -> Int

    TraitMethod::equal

    fn TraitMethod::equal(TraitMethod, TraitMethod) -> Bool

    TraitMethod::not_equal

    fn TraitMethod::not_equal(x : TraitMethod, y : TraitMethod) -> Bool

    TraitMethod::op_ge

    fn TraitMethod::op_ge(x : TraitMethod, y : TraitMethod) -> Bool

    TraitMethod::op_gt

    fn TraitMethod::op_gt(x : TraitMethod, y : TraitMethod) -> Bool

    TraitMethod::op_le

    fn TraitMethod::op_le(x : TraitMethod, y : TraitMethod) -> Bool

    TraitMethod::op_lt

    fn TraitMethod::op_lt(x : TraitMethod, y : TraitMethod) -> Bool

    Source Files