mamba 0.3.6

A transpiler which converts Mamba files to Python 3 files
Documentation 
1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
25
26
27
28
29
30
31
32
33
34
35
36
37
38
39
40
41
42
43
44
45
46
47
48
49
50
51
52
53
54
55
56
57
58
59
60
61
62
63
64
65
66
67
68
69
70
71
72
73
74

from typing import Callable, Optional


class Err1(Exception):
    def __init__(self, msg: str):
        Exception.__init__(self, msg)


class Err2(Exception):
    def __init__(self, msg: str):
        Exception.__init__(self, msg)


class MyType:
    def __init__(self, super_field: str):
        self.super_field = super_field


class MyClass2(MyType):
    z_modified: str = "asdf"
    other_field: int = 10

    def __init__(self, other_field: int, z: int):
        MyType.__init__(self, "the quick brown fox jumped over the slow donkey")

        if z > 10:
            raise Err1("Something is wrong!")
        self.z_modified = "fdsa"

        a, b = (10, 20)
        a, b = (30, 40)
        (a, b) = (0, 10)

        my_bool: bool = True

        a: int = None
        try:
            a: int = self.error_function()
        except Err1 as err1:
            print(err1)
            a = -1
        except Err2 as err2:
            print(err2)
            a = -2

    def error_function(self) -> int:
        return 200

    def connect(self):
        self.other_field = 200

    def _fun_b(self):
        print("this function is private!")

    def factorial(self, x: int = 0) -> int:
        return x * self.factorial(x - 1)

    def factorial_infinite(self, x: int) -> int:
        return x * self.factorial(x)

    def a(self) -> int:
        return self.b(10)

    def b(self, c: int) -> int:
        return self.a()

    def c(self, d: int) -> int:
        return self.b(self.c(20))

    def some_higher_order(self, fun: Callable[[int], int]) -> Optional[int]:
        return fun(10)

    def fancy(self) -> Optional[int]:
        return self.some_higher_order(lambda x: x * 2)