Skip to content

Commit 6655a6c

Browse files
committed
Use value for Zero in the abstract interface
1 parent 0814a47 commit 6655a6c

File tree

2 files changed

+177
-0
lines changed

2 files changed

+177
-0
lines changed

tests/run/fully-abstract-nat-7.check

Lines changed: 17 additions & 0 deletions
Original file line numberDiff line numberDiff line change
@@ -0,0 +1,17 @@
1+
CaseNums
2+
ok
3+
ok
4+
ok - unchecked error
5+
None
6+
Some((SuccClass(ZeroObj),SuccClass(ZeroObj)))
7+
None
8+
Some((SuccClass(ZeroObj),SuccClass(ZeroObj)))
9+
10+
IntNums
11+
ok
12+
ok
13+
ok - unchecked error
14+
None
15+
Some((1,1))
16+
None
17+
Some((1,1))

tests/run/fully-abstract-nat-7.scala

Lines changed: 160 additions & 0 deletions
Original file line numberDiff line numberDiff line change
@@ -0,0 +1,160 @@
1+
2+
object Test {
3+
def main(args: Array[String]): Unit = {
4+
println("CaseNums")
5+
test(CaseNums)
6+
println()
7+
println("IntNums")
8+
test(IntNums)
9+
}
10+
11+
def test(numbers: Numbers) = {
12+
import numbers._
13+
14+
val zero: Nat = Zero
15+
val one: Nat = Succ(zero)
16+
val two: Nat = Succ(one)
17+
val three: Nat = Succ(two)
18+
19+
zero match {
20+
case Succ(p) => println("error")
21+
case Zero => println("ok") // extra argument removed by language extension
22+
}
23+
24+
one match {
25+
case Zero => println("error") // extra argument removed by language extension
26+
case Succ(p) => println("ok")
27+
}
28+
29+
zero match {
30+
case s: Succ => println("ok - unchecked error")
31+
case z: Zero => println("ok - unchecked no error")
32+
}
33+
34+
def divOpt(a: Nat, b: Nat): Option[(Nat, Nat)] = b match {
35+
case s @ Succ(p) =>
36+
Some(safeDiv(a, s.asInstanceOf[Succ])) // this case will not be needed
37+
case _ => None
38+
}
39+
println(divOpt(one, zero))
40+
println(divOpt(three, two))
41+
42+
def divOptExpanded(a: Nat, b: Nat): Option[(Nat, Nat)] = {
43+
val x0 = Succ.unapply(b)
44+
if (!x0.isEmpty) {
45+
val s = b.asInstanceOf[x0.Refined] // safe unchecked cast inserted by the language extension
46+
val p = x0.get
47+
Some(safeDiv(a, s))
48+
} else {
49+
None
50+
}
51+
}
52+
println(divOptExpanded(one, zero))
53+
println(divOptExpanded(three, two))
54+
}
55+
}
56+
57+
trait Numbers {
58+
59+
type Nat
60+
type Zero <: Nat
61+
type Succ <: Nat
62+
63+
val Zero: Zero
64+
65+
val Succ: SuccExtractor
66+
trait SuccExtractor {
67+
def apply(nat: Nat): Succ
68+
def unapply(nat: Nat): SuccOpt { type Refined <: nat.type } // check that SuccOpt#Refined <: nat.type. Could be forced by the compiler?
69+
}
70+
trait SuccOpt {
71+
type Refined <: Succ // optionally added by language extension
72+
def get: Nat
73+
def isEmpty: Boolean
74+
}
75+
76+
implicit def SuccDeco(succ: Succ): SuccAPI
77+
trait SuccAPI {
78+
def pred: Nat
79+
}
80+
81+
def safeDiv(a: Nat, b: Succ): (Nat, Nat)
82+
}
83+
84+
object CaseNums extends Numbers {
85+
86+
trait NatClass
87+
case object ZeroObj extends NatClass
88+
case class SuccClass(pred: NatClass) extends NatClass with SuccOpt {
89+
type Refined = this.type
90+
def get: NatClass = pred
91+
def isEmpty: Boolean = false
92+
}
93+
94+
class EmptySuccOpt extends SuccOpt {
95+
type Refined = Nothing
96+
def isEmpty: Boolean = true
97+
def get: NatClass = throw new Exception("empty")
98+
}
99+
100+
type Nat = NatClass
101+
type Zero = ZeroObj.type
102+
type Succ = SuccClass
103+
104+
val Zero: Zero = ZeroObj
105+
106+
object Succ extends SuccExtractor {
107+
def apply(nat: Nat): Succ = SuccClass(nat)
108+
def unapply(nat: Nat) = nat match {
109+
case succ: SuccClass => succ.asInstanceOf[nat.type & SuccClass]
110+
case _ => new EmptySuccOpt
111+
}
112+
}
113+
114+
def SuccDeco(succ: Succ): SuccAPI = new SuccAPI {
115+
def pred: Nat = succ.pred
116+
}
117+
118+
def safeDiv(a: Nat, b: Succ): (Nat, Nat) = {
119+
def sdiv(div: Nat, rem: Nat): (Nat, Nat) =
120+
if (lessOrEq(rem, b)) (div, rem)
121+
else sdiv(Succ(div), minus(rem, b))
122+
sdiv(Zero, a)
123+
}
124+
125+
private def lessOrEq(a: Nat, b: Nat): Boolean = (a, b) match {
126+
case (Succ(a1), Succ(b1)) => lessOrEq(a1, b1)
127+
case (Zero, _) => true // extra argument removed by language extension
128+
case _ => false
129+
}
130+
131+
// assumes a >= b
132+
private def minus(a: Nat, b: Nat): Nat = (a, b) match {
133+
case (Succ(a1), Succ(b1)) => minus(a1, b1)
134+
case _ => a
135+
}
136+
137+
}
138+
139+
object IntNums extends Numbers {
140+
type Nat = Int
141+
type Zero = Int // 0
142+
type Succ = Int // n > 0
143+
144+
val Zero = 0
145+
146+
object Succ extends SuccExtractor {
147+
def apply(nat: Nat): Int = nat + 1
148+
def unapply(nat: Nat) = new SuccOpt {
149+
type Refined = nat.type
150+
def isEmpty: Boolean = nat <= 0
151+
def get: Int = nat - 1
152+
}
153+
}
154+
155+
def SuccDeco(succ: Succ): SuccAPI = new SuccAPI {
156+
def pred: Int = succ - 1
157+
}
158+
159+
def safeDiv(a: Nat, b: Succ): (Nat, Nat) = (a / b, a % b)
160+
}

0 commit comments

Comments
 (0)