waalge
/
aiken
1
0
Fork 0
Code Issues Pull Requests Packages Projects Releases Wiki Activity

Fix and re-apply formatter on all acceptance tests 

Less noise, pretty tuples. Everyone's happy.
This commit is contained in:
KtorZ 2023-01-14 11:45:34 +01:00
parent 5b7147fc43
commit 8c19d4ec08
No known key found for this signature in database
GPG Key ID: 33173CB6F77F4277
16 changed files with 152 additions and 107 deletions
Show Stats Download Patch File Download Diff File Expand all files Collapse all files

2
examples/acceptance_tests/006/lib/tests.ak
View File

@ -1,3 +1,3 @@
test foo() {
#(1, []) == #(1, [])
(1, []) == (1, [])
}

10
examples/acceptance_tests/007/lib/tests.ak
View File

@ -1,9 +1,9 @@
pub fn unzip(xs: List<#(a, b)>) -> #(List<a>, List<b>) {
pub fn unzip(xs: List<(a, b)>) -> (List<a>, List<b>) {
when xs is {
[] -> #([], [])
[#(a, b), ..rest] -> {
let #(a_tail, b_tail) = unzip(rest)
#([a, ..a_tail], [b, ..b_tail])
[] -> ([], [])
[(a, b), ..rest] -> {
let (a_tail, b_tail) = unzip(rest)
([a, ..a_tail], [b, ..b_tail])
}
}
}

12
examples/acceptance_tests/013/lib/tests.ak
View File

@ -1,13 +1,13 @@
pub fn unzip(xs: List<#(a, b)>) -> #(List<a>, List<b>) {
pub fn unzip(xs: List<(a, b)>) -> (List<a>, List<b>) {
when xs is {
[] -> #([], [])
[#(a, b), ..rest] -> {
let #(a_tail, b_tail) = unzip(rest)
#([a, ..a_tail], [b, ..b_tail])
[] -> ([], [])
[(a, b), ..rest] -> {
let (a_tail, b_tail) = unzip(rest)
([a, ..a_tail], [b, ..b_tail])
}
}
}
test unzip_1() {
unzip([#(1, "a"), #(2, "b")]) == #([1, 2], ["a", "b"])
unzip([(1, "a"), (2, "b")]) == ([1, 2], ["a", "b"])
}

2
examples/acceptance_tests/015/lib/tests.ak
View File

@ -1,5 +1,5 @@
pub opaque type Map<key, value> {
inner: List<#(key, value)>,
inner: List<(key, value)>,
}
pub fn new() {

1
examples/acceptance_tests/016/lib/tests.ak
View File

@ -16,4 +16,3 @@ test drop_1() {
let x = #[1, 2, 3, 4, 5, 6, 7]
drop(x, 2) == #[3, 4, 5, 6, 7]
}

18
examples/acceptance_tests/023/lib/tests.ak
View File

@ -1,12 +1,12 @@
pub opaque type AssocList<key, value> {
inner: List<#(key, value)>,
inner: List<(key, value)>,
}
pub fn new() -> AssocList<key, value> {
AssocList { inner: [] }
}
pub fn to_list(m: AssocList<key, value>) -> List<#(key, value)> {
pub fn to_list(m: AssocList<key, value>) -> List<(key, value)> {
m.inner
}
@ -19,17 +19,17 @@ pub fn insert(
}
fn do_insert(
elems: List<#(key, value)>,
elems: List<(key, value)>,
k: key,
v: value,
) -> List<#(key, value)> {
) -> List<(key, value)> {
when elems is {
[] -> [#(k, v)]
[#(k2, v2), ..rest] ->
[] -> [(k, v)]
[(k2, v2), ..rest] ->
if k == k2 {
[#(k, v), ..rest]
[(k, v), ..rest]
} else {
[#(k2, v2), ..do_insert(rest, k, v)]
[(k2, v2), ..do_insert(rest, k, v)]
}
}
}
@ -41,5 +41,5 @@ fn fixture_1() {
}
test to_list_2() {
to_list(fixture_1()) == [#("foo", 42), #("bar", 14)]
to_list(fixture_1()) == [("foo", 42), ("bar", 14)]
}

2
examples/acceptance_tests/024/lib/tests.ak
View File

@ -14,5 +14,5 @@ pub fn map2(
}
test map2_3() {
map2(Some(14), Some(42), fn(a, b) { #(a, b) }) == Some(#(14, 42))
map2(Some(14), Some(42), fn(a, b) { (a, b) }) == Some((14, 42))
}

2
examples/acceptance_tests/027/lib/tests.ak
View File

@ -1,4 +1,4 @@
pub fn foo(_a : a) -> Bool {
pub fn foo(_a: a) -> Bool {
True
}

32
examples/acceptance_tests/029/lib/tests.ak
View File

@ -1,19 +1,19 @@
pub opaque type AssocList<key, value> {
inner: List<#(key, value)>,
inner: List<(key, value)>,
}
pub fn new() -> AssocList<key, value> {
AssocList { inner: [] }
}
pub fn from_list(xs: List<#(key, value)>) -> AssocList<key, value> {
pub fn from_list(xs: List<(key, value)>) -> AssocList<key, value> {
AssocList { inner: do_from_list(xs) }
}
fn do_from_list(xs: List<#(key, value)>) -> List<#(key, value)> {
fn do_from_list(xs: List<(key, value)>) -> List<(key, value)> {
when xs is {
[] -> []
[#(k, v), ..rest] -> do_insert(do_from_list(rest), k, v)
[(k, v), ..rest] -> do_insert(do_from_list(rest), k, v)
}
}
@ -26,35 +26,35 @@ pub fn insert(
}
fn do_insert(
elems: List<#(key, value)>,
elems: List<(key, value)>,
k: key,
v: value,
) -> List<#(key, value)> {
) -> List<(key, value)> {
when elems is {
[] -> [#(k, v)]
[#(k2, v2), ..rest] ->
[] -> [(k, v)]
[(k2, v2), ..rest] ->
if k == k2 {
[#(k, v), ..rest]
[(k, v), ..rest]
} else {
[#(k2, v2), ..do_insert(rest, k, v)]
[(k2, v2), ..do_insert(rest, k, v)]
}
}
}
pub fn union(
left left: AssocList<key, value>,
right right: AssocList<key, value>,
left: AssocList<key, value>,
right: AssocList<key, value>,
) -> AssocList<key, value> {
AssocList { inner: do_union(left.inner, right.inner) }
}
fn do_union(
left: List<#(key, value)>,
right: List<#(key, value)>,
) -> List<#(key, value)> {
left: List<(key, value)>,
right: List<(key, value)>,
) -> List<(key, value)> {
when left is {
[] -> right
[#(k, v), ..rest] -> do_union(rest, do_insert(right, k, v))
[(k, v), ..rest] -> do_union(rest, do_insert(right, k, v))
}
}

6
examples/acceptance_tests/032/lib/tests.ak
View File

@ -1,12 +1,10 @@
fn is_negative(i: Int) -> Bool {
if i < 0 {
trace("is negative")
True
True
} else {
trace("is non-negative")
False
False
}
}

2
examples/acceptance_tests/033/lib/tests.ak
View File

@ -1,4 +1,4 @@
test tuple_1() {
let coordinates = #(14, 42)
let coordinates = (14, 42)
coordinates.1st == 14 && coordinates.2nd == 42
}

26
examples/acceptance_tests/035/lib/aiken/dict.ak
View File

@ -1,10 +1,10 @@
/// An opaque `Dict`. The type is opaque because the module maintains some
/// invariant, namely: there's only one occurence of a given key in the dictionnary.
pub opaque type Dict<key, value> {
inner: List<#(ByteArray, value)>,
inner: List<(ByteArray, value)>,
}
pub fn toList(self: Dict<ByteArray, value>){
pub fn toList(self: Dict<ByteArray, value>) {
self.inner
}
@ -20,7 +20,7 @@ pub fn insert(
) -> Dict<key, value> {
Dict {
inner: do_insert_with(self.inner, k, v, fn(_, left, _right) { Some(left) })}
}
pub fn union_with(
@ -32,33 +32,33 @@ pub fn union_with(
}
fn do_union_with(
left: List<#(ByteArray, value)>,
right: List<#(ByteArray, value)>,
left: List<(ByteArray, value)>,
right: List<(ByteArray, value)>,
with: fn(ByteArray, value, value) -> Option<value>,
) -> List<#(ByteArray, value)> {
) -> List<(ByteArray, value)> {
when left is {
[] -> right
[#(k, v), ..rest] ->
[(k, v), ..rest] ->
do_union_with(rest, do_insert_with(right, k, v, with), with)
}
}
fn do_insert_with(
self: List<#(ByteArray, value)>,
self: List<(ByteArray, value)>,
key k: ByteArray,
value v: value,
with: fn(ByteArray, value, value) -> Option<value>,
) -> List<#(ByteArray, value)> {
) -> List<(ByteArray, value)> {
when self is {
[] -> [#(k, v)]
[#(k2, v2), ..rest] ->
[] -> [(k, v)]
[(k2, v2), ..rest] ->
if k == k2 {
when with(k, v, v2) is {
Some(combined) -> [#(k, combined), ..rest]
Some(combined) -> [(k, combined), ..rest]
None -> rest
}
} else {
[#(k2, v2), ..do_insert_with(rest, k, v, with)]
[(k2, v2), ..do_insert_with(rest, k, v, with)]
}
}
}

25
examples/acceptance_tests/035/lib/tests.ak
View File

@ -30,18 +30,19 @@ pub fn add(left v0: Value, right v1: Value) -> Value {
v0,
v1,
fn(_, a0, a1) {
let asset = dict.union_with(
a0,
a1,
fn(_, q0, q1) {
let q = q0 + q1
if q == 0 {
None
} else {
Some(q)
}
},
)
let asset =
dict.union_with(
a0,
a1,
fn(_, q0, q1) {
let q = q0 + q1
if q == 0 {
None
} else {
Some(q)
}
},
)
when dict.toList(asset) is {
[] -> None

4
examples/acceptance_tests/036/aiken.lock
View File

@ -3,11 +3,11 @@
[[requirements]]
name = "aiken-lang/stdlib"
version = "6b482fa00ec37fe936c93155e8c670f32288a686"
version = "1cedbe85b7c7e9c4036d63d45cad4ced27b0d50b"
source = "github"
[[packages]]
name = "aiken-lang/stdlib"
version = "6b482fa00ec37fe936c93155e8c670f32288a686"
version = "1cedbe85b7c7e9c4036d63d45cad4ced27b0d50b"
requirements = []
source = "github"

2
examples/acceptance_tests/036/aiken.toml
View File

@ -2,5 +2,5 @@ name = "aiken-lang/acceptance_test_036"
version = "0.0.0"
dependencies = [
{ name = "aiken-lang/stdlib", version = "6b482fa00ec37fe936c93155e8c670f32288a686", source = "github" },
{ name = "aiken-lang/stdlib", version = "1cedbe85b7c7e9c4036d63d45cad4ced27b0d50b", source = "github" },
]

113
examples/acceptance_tests/039/lib/tests.ak
View File

@ -1,60 +1,107 @@
pub type Door{
pub type Door {
locked: Bool,
hinge_angle: Int
hinge_angle: Int,
}
pub type Car{
pub type Car {
owner: ByteArray,
wheels: Int,
door: Door,
vin: ByteArray,
}
pub fn update_owner(new_owner: ByteArray, car: Car){
Car{..car, owner: new_owner}
pub fn update_owner(new_owner: ByteArray, car: Car) {
Car { ..car, owner: new_owner }
}
pub fn update_vin(new_vin: ByteArray, car: Car){
Car{..car, vin: new_vin}
pub fn update_vin(new_vin: ByteArray, car: Car) {
Car { ..car, vin: new_vin }
}
pub fn update_door_angle(new_hinge_angle: Int, car: Car){
Car{..car, door: Door{..car.door, hinge_angle: new_hinge_angle}}
pub fn update_door_angle(new_hinge_angle: Int, car: Car) {
Car { ..car, door: Door { ..car.door, hinge_angle: new_hinge_angle } }
}
pub fn update_door_locked_and_wheels(new_locked: Bool, new_wheels: Int, car: Car){
Car{..car, door: Door{..car.door, locked: new_locked}, wheels: new_wheels}
pub fn update_door_locked_and_wheels(
new_locked: Bool,
new_wheels: Int,
car: Car,
) {
Car {
..car,
door: Door { ..car.door, locked: new_locked },
wheels: new_wheels,
}
}
test update_owner1(){
let initial_car = Car{owner: #[], wheels: 4, vin: #[1,1,1,1,1,1,1], door: Door{locked: False, hinge_angle: 45}}
let final_car = Car{owner: #[244, 244, 244, 244], wheels: 4, vin: #[1,1,1,1,1,1,1], door: Door{locked: False, hinge_angle: 45}}
test update_owner1() {
let initial_car =
Car {
owner: #[],
wheels: 4,
vin: #[1, 1, 1, 1, 1, 1, 1],
door: Door { locked: False, hinge_angle: 45 },
}
let final_car =
Car {
owner: #[244, 244, 244, 244],
wheels: 4,
vin: #[1, 1, 1, 1, 1, 1, 1],
door: Door { locked: False, hinge_angle: 45 },
}
update_owner(#[244, 244, 244, 244], initial_car) == final_car
}
test update_vin1(){
let initial_car = Car{owner: #[], wheels: 4, vin: #[1,1,1,1,1,1,1], door: Door{locked: False, hinge_angle: 45}}
let final_car = Car{owner: #[], wheels: 4, vin: #[2,2,2,2,2,2,2,2,2], door: Door{locked: False, hinge_angle: 45}}
update_vin(#[2,2,2,2,2,2,2,2,2], initial_car) == final_car
test update_vin1() {
let initial_car =
Car {
owner: #[],
wheels: 4,
vin: #[1, 1, 1, 1, 1, 1, 1],
door: Door { locked: False, hinge_angle: 45 },
}
let final_car =
Car {
owner: #[],
wheels: 4,
vin: #[2, 2, 2, 2, 2, 2, 2, 2, 2],
door: Door { locked: False, hinge_angle: 45 },
}
update_vin(#[2, 2, 2, 2, 2, 2, 2, 2, 2], initial_car) == final_car
}
test update_door_angle1(){
let initial_car = Car{owner: #[], wheels: 4, vin: #[1,1,1,1,1,1,1], door: Door{locked: False, hinge_angle: 45}}
let final_car = Car{owner: #[], wheels: 4, vin: #[1,1,1,1,1,1,1], door: Door{locked: False, hinge_angle: 90}}
test update_door_angle1() {
let initial_car =
Car {
owner: #[],
wheels: 4,
vin: #[1, 1, 1, 1, 1, 1, 1],
door: Door { locked: False, hinge_angle: 45 },
}
let final_car =
Car {
owner: #[],
wheels: 4,
vin: #[1, 1, 1, 1, 1, 1, 1],
door: Door { locked: False, hinge_angle: 90 },
}
update_door_angle(90, initial_car) == final_car
}
test update_door_locked_and_wheels1(){
let initial_car = Car{owner: #[], wheels: 4, vin: #[1,1,1,1,1,1,1], door: Door{locked: False, hinge_angle: 45}}
let final_car = Car{owner: #[], wheels: 5, vin: #[1,1,1,1,1,1,1], door: Door{locked: True, hinge_angle: 45}}
test update_door_locked_and_wheels1() {
let initial_car =
Car {
owner: #[],
wheels: 4,
vin: #[1, 1, 1, 1, 1, 1, 1],
door: Door { locked: False, hinge_angle: 45 },
}
let final_car =
Car {
owner: #[],
wheels: 5,
vin: #[1, 1, 1, 1, 1, 1, 1],
door: Door { locked: True, hinge_angle: 45 },
}
update_door_locked_and_wheels(True, 5, initial_car) == final_car
}