Пример #1
0
#         X = map(name:10 2:14)
#         case X
#         of map(name:A 3:B) then
#             Y=10
#         else
#             case X
#             of map(name:C 2:D) then Y=20
#             else Y=30
#             end
#         end
#     end
# end

ast = [
    "var",
    Ident("x"),
    [
        "var",
        Ident("y"),
        [
            [
                "bind",
                Ident("x"),
                [
                    "record",
                    Literal("map"),
                    [
                        [Literal("name"), Literal(10)],
                        [Literal(2), Literal(14)],
                    ],
                ],
Пример #2
0
"""Testcase for arithmetic."""
from ozi import Ident, Literal

ast = [
    "var",
    Ident("x"),
    [
        [
            "thread",
            [
                ["nop"],
                ["nop"],
                ["bind", Ident("x"), ["sum", Literal(1),
                                      Literal(2)]],
            ],
        ],
        [
            "var",
            Ident("y"),
            ["bind", Ident("y"), ["product", Ident("x"),
                                  Literal(3)]],
        ],
    ],
]
Пример #3
0
#                 local W in
#                     W=true
#                     {P2 W}
#                 end
#             end
#         end
#         X=10
#         local X in
#             {P1 X}
#         end
#     end
# end

ast = ([
    "var",
    Ident("x"),
    [
        "var",
        Ident("p1"),
        [
            [
                "bind",
                Ident("p1"),
                [
                    "proc",
                    [Ident("y")],
                    [
                        "var",
                        Ident("p2"),
                        [
                            [
Пример #4
0
"""Testcase for Oz conditionals."""
from ozi import Ident, Literal

ast = [
    "var",
    Ident("x"),
    [
        "var",
        Ident("y"),
        [
            ["bind", Ident("x"), Literal(True)],
            [
                "conditional",
                Ident("x"),
                ["bind", Ident("y"), Literal("True")],
                ["nop"],
            ],
        ],
    ],
]
Пример #5
0
#             X=proc{$ K A}
#                 if K then A=Y else A=D end
#             end
#         end
#     end
#     local Y in
#         local B in
#             Y=true
#             {X Y B}
#         end
#     end
# end

ast = [[
    "var",
    Ident("x"),
    [
        [
            "var",
            Ident("y"),
            [
                "var",
                Ident("d"),
                [
                    ["bind", Ident("y"), Literal(2)],
                    ["bind", Ident("d"), Literal(3)],
                    [
                        "bind",
                        Ident("x"),
                        [
                            "proc",
Пример #6
0
"""Testcase for arithmetic."""
from ozi import Ident, Literal

ast = [
    "var",
    Ident("x"),
    [
        "var",
        Ident("y"),
        [
            ["thread", ["bind",
                        Ident("y"), ["sum", Ident("y"),
                                     Literal(0)]]],
            ["thread", [["nop"], ["nop"], ["bind",
                                           Ident("x"),
                                           Literal(5)]]],
            ["bind", Ident("y"), ["product", Ident("x"),
                                  Literal(3)]],
        ],
    ],
]
Пример #7
0
"""Testcase for arithmetic."""
from ozi import Ident, Literal

ast = [
    "var",
    Ident("x"),
    [
        "var",
        Ident("y"),
        [
            [
                "thread",
                [
                    ["nop"],
                    ["nop"],
                    ["bind", Ident("x"), ["sum", Ident("y"), Literal(2)]],
                ],
            ],
            ["bind", Ident("y"), ["product", Ident("x"), Literal(3)]],
        ],
    ],
]
Пример #8
0
"""Testcase for infinitely-recursive Oz records."""
from ozi import Ident, Literal

ast = [
    [
        "var",
        Ident("x"),
        [
            "var",
            Ident("y"),
            [
                "var",
                Ident("z"),
                [
                    [
                        "bind",
                        Ident("x"),
                        (
                            "record",
                            Literal("|"),
                            [
                                (Literal("1"), Literal(1)),
                                (Literal("2"), Ident("y")),
                            ],
                        ),
                    ],
                    [
                        "bind",
                        Ident("y"),
                        (
                            "record",
Пример #9
0
"""Testcase for Oz pattern matching."""
from ozi import Ident, Literal

ast = [
    "var",
    Ident("x"),
    [
        [
            "bind",
            Ident("x"),
            (
                "record",
                Literal("|"),
                [(Literal("1"), Literal("1")), (Literal("2"), Ident("x"))],
            ),
        ],
        [
            "match",
            Ident("x"),
            (
                "record",
                Literal("|"),
                [(Literal("1"), Ident("a")), (Literal("2"), Ident("b"))],
            ),
            ["bind", Ident("x"), Ident("b")],
            ["nop"],
        ],
    ],
]
Пример #10
0
"""Another testcase for Oz conditionals."""
from ozi import Ident, Literal

ast = [
    "var",
    Ident("x"),
    [
        "var",
        Ident("c"),
        [
            "var",
            Ident("y"),
            [
                ["bind", Ident("c"), Literal(False)],
                ["bind", Ident("x"), Literal(10)],
                [
                    "conditional",
                    Ident("c"),
                    ["bind", Ident("y"), Literal(30)],
                    ["bind", Ident("y"), Literal(40)],
                ],
            ],
        ],
    ],
]
Пример #11
0
"""Testcase for arithmetic."""
from ozi import Ident, Literal

ast = [
    "var",
    Ident("x"),
    [
        ["bind", Ident("x"), Literal(1)],
        [
            "var",
            Ident("y"),
            [
                ["bind", Ident("y"), ["sum", Literal(2),
                                      Ident("x")]],
                ["bind", Ident("y"), ["sum", Literal(3),
                                      Literal(0)]],
                [
                    "var",
                    Ident("z"),
                    ["bind",
                     Ident("z"), ["product", Ident("y"),
                                  Ident("x")]],
                ],
            ],
        ],
    ],
]