input.txt

# 1. trait definition
# the following trait definition says that
# typename 'self' should support .append(x) and .pop() operation
# and __len__ method

trait any(self):
    pass

trait StackLike(self):
    fn:
        append(self, any) -> [self or None]
        pop(self) -> [self or None]
        popop(self) -> [self or (None and None)]

    fn:
        __len__(self) -> int


# the following trait definition says that
# the instance of the class 'self' should have 'x', 'y' member variables

trait PointLike(self):
    var:
        x: int
        y: int


trait AnyRandom(self):
    var:
        x: int
        y: int
        z
    fn:
        __init__(self, =int, =int, =any) -> None

    cls_fn:
        foo(cls, int) -> str
        foo(cls, float)

    cls_var:
        xxx
        yyy: int

    static_fn:
        bar() -> None

printinfo trait_of(AnyRandom.x)


t_random = any_random


trait decl_var_with_comma(self):
    var:
        [x, y, z]: int


# 2. traits with 2 or more parameters.

trait Addable(self, T):
    fn:
        __add__(self, T) -> self

trait Multipliable(self, T):
    fn:
        __mul__(self, T) -> self


# 3. trait(type) expression is evaluated as a boolean.

printinfo StackLike(int) # -> False
printinfo StackLike(list) # -> True

printinfo Addable(str, int) # -> False
printinfo Multipliable(str, int) # -> True, since "str" * 3 is a valid expression


# 4. If you want to bind some arguments to a trait, use trait[]() expression.

printinfo Addable[int](str) # -> False, exactly same meaning with Addable(str, int)


# 6. trait extensions.

trait AddableSubable(self, T) extends Addable[T]:
    fn:
        __sub__(self, T)


# 7. printinfo operator.

trait Fooable(self):
    fn:
        foo(self, any)

printinfo Fooable

# possible output:
# """
# trait Fooable supports:
# member function .foo(any)
# """

# 8. trait and/or/not operator.

trait FooBarable(self):
    fn:
        foo(self, any)
        bar(self, any)

trait BarBazable(self):
    fn:
        bar(self, any)
        baz(self, any)

printinfo [FooBarable and BarBazable]

# possible output:
# """
# trait (unnamed @ line 88) supports:
# member function .foo(any)
# member function .bar(any)
# member function .baz(any)
# """

printinfo [FooBarable or BarBazable]

# possible output:
# """
# trait (unnamed @ line 98) supports:
# member function .bar(any)
# """


# 11. generate operator.

generate Fooo
generate FooBarable


# 12. implies operator.

printinfo [FooBarable and BarBazable] implies [FooBarable or BarBazable] # -> True

# 13. assignments.

a, b = b, a

# 14. default arguments.

trait DefaultArgsExample(self, arg_a, arg_b, arg_c=[Addable and Subable], arg_d=float):
    pass

trait TraitWithAllOptionalArgs(self, arg_a=int, arg_b=str):
    fn:
        whatever(self, int, int, =int, =int, *, a:=int, b:int)


# 15. traits with generic type variable.
trait GenericTrait(self):
    fn:
        foo[T](self, T) -> T


trait vector7D(self) extends vector[vector[vector[vector[vector[vector[vector[int]]]]]]]:
    fn:
        begin(self) -> iterator[vector[any] or vector[vector[any] or any] or vector[vector[vector[any]]]]
        end(self) -> iterator[int or [trait_of(vector.a)] and trait_of([None or vector5D[v[u], v[u]]].y)]
        front(self, =[int or (str and not float or vector[int])])

printinfo (trait_of(x.z) implies trait_of(y.z)) and (True == False or False != int(int))