Oblock/notes/types.ob at master · Dantevg/Oblock · GitHub

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
75
76
77
78
79
80
81
82
83
84
85
86
87
88
89
90
91
92
{
	Eq = {
		"=="(a: `T, b: `T) -> Boolean
	}

	Eq = {
		"==" `T`(a: T, b: T) -> Boolean
	}

	Eq `T` = {
		"=="(a: T, b: T) -> Boolean
	}

	Ord = {
		// :: Eq, Eq -> Boolean
		"<="(a: Eq, b: Eq) -> Boolean
	}

	Eq = {
		@Given("==")
		"!=" that => !(this == that)
	}

	Ord = Eq.clone {
		@Given("<=")
		"<" that => this <= that && this != that
		">" that => !(this <= that)
		">=" that => !(this < that)
	}

	Enum = {
		succ(a: `T) -> `T
		pred(a: `T) -> `T
		to(a: Int) -> `T
		from(a: `T) -> Int
	}

	Enum `T` = {
		succ(a: T) -> T
		pred(a: T) -> T
		to(a: Int) -> T
		from(a: T) -> Int
	}

	Enum = {
		succ`T`(a: T) -> T
		pred`T`(a: T) -> T
		to`T`(a: Int) -> T
		from[T,Y](a: T) -> Int
	}

	add(a: `X, b: `X) -> Int
	add`X`(a: X, b: X) -> Int
	add<X>(a: X, b: X) -> Int
	add[X](a: X, b: X) -> Int
	add::X::(a: X, b: X) -> Int

	add(a: `X, b: `Y) -> Int
	add`X, Y`(a: X, b: Y) -> Int
	add<X, Y>(a: X, b: Y) -> Int
	add[X, Y](a: X, b: Y) -> Int
	add::X, Y::(a: X, b: Y) -> Int

	add(a: Int, b: Int) => {
		return a + b
	}

	add(a::Int, b::Int) => {
		return a + b
	}

	b = Bag ()
	b.add "A"
	b.add "B"
	b.add "A"

	c = Bag ("A", "B", "A")

	x, y from (x = 10, y = 20)
	x, y from (x: 10, y: 20)
	x, y from (x :: 10, y :: 20)
	x, y from ( :x: 10, :y: 20)
	x, y from (10 as x, 20 as y)

	list = [10, 20]
	list = [10, x: 20, :x]
	list = [10, x = 20, =x]

	return (x = 10)
	return x: 10
	return 10 as x
}