roldak / sfsl Goto Github PK

    type Box = [T] => class {
        value: T;
    }
    type Pair = [A, B] => class {
        first: A;
        second: B;
    }
    def main() => {
        x: Box[Pair[int, Box[Pair[Box[Pair[int, Box[Pair[Box[Pair[int, Box[Pair[Box[int], int]]]], int]]]], int]]]];
        x.value.second.value.first.value.second.value.first.value.second.value.first.value;
        x.value.second.value.first.value.second.value.first.value.second.value.first.value;
        x.value.second.value.first.value.second.value.first.value.second.value.first.value;
        // ... (300 times)
    }

def f(x: int)->unit => {}
...
x :=  (x: int)->int => 2 * x

def f: int->int = (x: int) => 2 * x

type List = [T] => class : Buildable[List, T] { ... }

type List = [T]->* => class : Buildable[List, T] { ... }

type List[T] => class {
    type Node = class {
        x: T;
        xs: List[T];
    }
    type Leaf = class {}
    ...
}

type T = class {}
def main() => {
    x: T;
}

type T = class T {}

type Drawable = trait {
    def draw()->unit
}
type Surface = trait {
    def area()->int
}

type Box = class : Drawable, Surface { ... }

    type Box = [T] => class Box {
        x: T;
    }

    type Buildable = [F[K], T] => class Buildable {
        def builder() => {
            x: F[T];
            x;
        }
    }

    def main() => {
        b: Buildable[Box, int];
        b.builder();
    }

type Drawable = class {
    def draw()->unit
}

type A[T] =>                // Type Constructor A depends on T
        [] =>               // Anonymous Type Constructor depends on T
            class {         // Anonymous Class depends no T

    _val: class {           // Anonymous Class depends on T
        f: T;
        s: int;
    }

    def f[U]() => {         // Function f depends on T and U
        x: class {          // Anonymous Class depends on T and U
            a: T;
            b: U;
        }
    }

    def g[K]() => {}        // Function g depends on K          
}

type Buildable[Col: *->*, T: *] => class {
    def builder()->Builder[Col, T]
}

type Builder[Col: *->*, T: *] => class {
    def append(x: T)->unit
    def get()->Col[T]
}

type List[T] => class : Buildable[List, T] { }

def main1() => {
    x: Buildable[List, int];
    x                       // TCA(TCT(Buildable), [TCT(List), PT(int)])
    x.                      // PT(Buildable, {TCT(Col) => TCT(List), PT(T) => PT(int)})
    x.builder               // MT([], TCA(TCT(Builder), [TCT(List), PT(int)]))
    x.builder()             // TCA(TCT(Builder), [TCT(List), PT(int)])
    x.builder().            // PT(Builder, {TCT(Col) => TCT(List), PT(T) => TP(int)})
    x.builder().append      // MT([PT(int)], unit)
    x.builder().get         // MT([], TCA(TCT(List), [TP(int)])
}

type Apply[F[K /*(will be removed later)*/], T] => F[T]

module sfsl {
    module lang {
        type unit = class {}
        type bool = class {}
        type byte = class {}
        type int  = class {}
        type real = class {}
    }
}

module progam {
    type unit = sfsl.lang.unit
    type bool = sfsl.lang.bool
    type byte = sfsl.lang.byte
    type int  = sfsl.lang.int
    type real = sfsl.lang.real

    type Iterable[T] => class {
        def iterator() => x: Iterator[T]
    }

    type Iterator[T] => class {
        def hasNext() => x: bool
        def next() => x: T
    }

    type Buildable[Col: *->*, T: *] => class : Iterable[T] {
        def builder() => x: Builder[Col, T]

        def map(f: T->T) => {
            b: Builder[Col, T] = builder();
            it: Iterator[T] = iterator();
            if it.hasNext() {
                b.append(f(it.next()));
            }
            b.get();
        }
    }

    type Builder[Col: *->*, T: *] => class {
        def append(x: T) => ()
        def get() => x: Col[T]
    }

    type List[T] => class : Buildable[List, T] {
        redef iterator() => x: ListIterator[T]
        redef builder() => x: ListBuilder[T]
        def push(x: T) => ()
    }

    type ListIterator[T] => class : Iterator[T] {

    }

    type ListBuilder[T] => class : Builder[List, T] {
        inner: List[T];
        redef append(x: T) => inner.push(x)
        redef get() => inner
    }

    def main() => {
        x: List[int];   
        x.map((x: int) => 2).map((x: int) => 3).push(4);
    }
}

module sfsl {
    module lang {
        type unit = class {}
        type bool = class {}
        type byte = class {}
        type int  = class {}
        type real = class {}
        type string = class {}
    }
}

module math {
    using sfsl.lang;

    extern def sin: real->real
    extern def sin: int->int
}

module program {
    using math;

    def main() => {
        x: real; // Illegal: Need sfsl.lang.real (for example "using sfsl.lang;");
        sin(x);
    }
}

    type G = [T] => class G {
        x: class {
            y: T;
        };
    }
    def test() => {
        x: G[int];
        x.x.y; // typechecks to T instead of int
    }

type List[T] => class {
    type Node = class {
        x: T;
    }
}

def main() => {
    x: List[int].Node;
    x.x;
}

module math {
    extern def sin: (real)->real
    extern def pi: real
}

type P = class {
    a: A;
    b: B;
}

type S = union {
    A, B
}

def f() => {
    x: int = 2;
}

def f() => {
    x := 2;
}

def f(x: int) => {...}
def f(x: Array[int]) => {...}
def f(x: int, y: real) => {...}

type Func[R] => class {...}
type Func[A1, R] => class {...}
type Func[A1, A2, R] => class {...}

type Apply = [F[A /*this is useless*/], T] => F[T]

type Box = [T] => class { x: T; }

type A = [Col: *->*] => class {
    def f(x: Col[int]) => ()
}

def main() => {
    x: A[Box];
    x.f(2); // this line is the cause of the crash, because at this point the Col[int] is applied, and Col is an abstracted type constructor
}

def identity[T](x: T) => x

type Tree = [T < Comparable[T]] => class { 
    def foo(...) => {
        if (x < left) { // is legal
            ...
        }
        ...
    }
}

type Apply = [F[A /*useless*/], B] => ...

type Apply = [F: [*]->*, B: *] => ...

type Apply = [F: [*]->*, B] => ...

type List = [T] => class ...