mirror of
https://github.com/roc-lang/roc.git
synced 2025-09-26 21:39:07 +00:00
Merge branch 'main' into str-withprefix
This commit is contained in:
Prajwal S N
commit
aef15ac1e8
57 changed files with 1388 additions and 631 deletions
145
Cargo.lock
generated
145
Cargo.lock
generated
|
|
@ -75,15 +75,6 @@ dependencies = [
|
|||
"pkg-config",
|
||||
]
|
||||
|
||||
[[package]]
|
||||
name = "ansi_term"
|
||||
version = "0.12.1"
|
||||
source = "registry+https://github.com/rust-lang/crates.io-index"
|
||||
checksum = "d52a9bb7ec0cf484c551830a7ce27bd20d67eac647e1befb56b0be4ee39a55d2"
|
||||
dependencies = [
|
||||
"winapi",
|
||||
]
|
||||
|
||||
[[package]]
|
||||
name = "approx"
|
||||
version = "0.4.0"
|
||||
|
|
@ -253,34 +244,13 @@ version = "0.1.6"
|
|||
source = "registry+https://github.com/rust-lang/crates.io-index"
|
||||
checksum = "0d8c1fef690941d3e7788d328517591fecc684c084084702d6ff1641e993699a"
|
||||
|
||||
[[package]]
|
||||
name = "block-buffer"
|
||||
version = "0.7.3"
|
||||
source = "registry+https://github.com/rust-lang/crates.io-index"
|
||||
checksum = "c0940dc441f31689269e10ac70eb1002a3a1d3ad1390e030043662eb7fe4688b"
|
||||
dependencies = [
|
||||
"block-padding",
|
||||
"byte-tools",
|
||||
"byteorder",
|
||||
"generic-array 0.12.4",
|
||||
]
|
||||
|
||||
[[package]]
|
||||
name = "block-buffer"
|
||||
version = "0.10.2"
|
||||
source = "registry+https://github.com/rust-lang/crates.io-index"
|
||||
checksum = "0bf7fe51849ea569fd452f37822f606a5cabb684dc918707a0193fd4664ff324"
|
||||
dependencies = [
|
||||
"generic-array 0.14.5",
|
||||
]
|
||||
|
||||
[[package]]
|
||||
name = "block-padding"
|
||||
version = "0.1.5"
|
||||
source = "registry+https://github.com/rust-lang/crates.io-index"
|
||||
checksum = "fa79dedbb091f449f1f39e53edf88d5dbe95f895dae6135a8d7b881fb5af73f5"
|
||||
dependencies = [
|
||||
"byte-tools",
|
||||
"generic-array",
|
||||
]
|
||||
|
||||
[[package]]
|
||||
|
|
@ -301,12 +271,6 @@ version = "3.11.0"
|
|||
source = "registry+https://github.com/rust-lang/crates.io-index"
|
||||
checksum = "c1ad822118d20d2c234f427000d5acc36eabe1e29a348c89b63dd60b13f28e5d"
|
||||
|
||||
[[package]]
|
||||
name = "byte-tools"
|
||||
version = "0.3.1"
|
||||
source = "registry+https://github.com/rust-lang/crates.io-index"
|
||||
checksum = "e3b5ca7a04898ad4bcd41c90c5285445ff5b791899bb1b0abdd2a2aa791211d7"
|
||||
|
||||
[[package]]
|
||||
name = "bytecheck"
|
||||
version = "0.6.8"
|
||||
|
|
@ -1023,7 +987,7 @@ version = "0.1.5"
|
|||
source = "registry+https://github.com/rust-lang/crates.io-index"
|
||||
checksum = "2ccfd8c0ee4cce11e45b3fd6f9d5e69e0cc62912aa6a0cb1bf4617b0eba5a12f"
|
||||
dependencies = [
|
||||
"generic-array 0.14.5",
|
||||
"generic-array",
|
||||
"typenum",
|
||||
]
|
||||
|
||||
|
|
@ -1129,22 +1093,13 @@ version = "0.1.13"
|
|||
source = "registry+https://github.com/rust-lang/crates.io-index"
|
||||
checksum = "56254986775e3233ffa9c4d7d3faaf6d36a2c09d30b20687e9f88bc8bafc16c8"
|
||||
|
||||
[[package]]
|
||||
name = "digest"
|
||||
version = "0.8.1"
|
||||
source = "registry+https://github.com/rust-lang/crates.io-index"
|
||||
checksum = "f3d0c8c8752312f9713efd397ff63acb9f85585afbf179282e720e7704954dd5"
|
||||
dependencies = [
|
||||
"generic-array 0.12.4",
|
||||
]
|
||||
|
||||
[[package]]
|
||||
name = "digest"
|
||||
version = "0.10.3"
|
||||
source = "registry+https://github.com/rust-lang/crates.io-index"
|
||||
checksum = "f2fb860ca6fafa5552fb6d0e816a69c8e49f0908bf524e30a90d97c85892d506"
|
||||
dependencies = [
|
||||
"block-buffer 0.10.2",
|
||||
"block-buffer",
|
||||
"crypto-common",
|
||||
]
|
||||
|
||||
|
|
@ -1242,9 +1197,9 @@ checksum = "9ea835d29036a4087793836fa931b08837ad5e957da9e23886b29586fb9b6650"
|
|||
|
||||
[[package]]
|
||||
name = "dunce"
|
||||
version = "1.0.2"
|
||||
version = "1.0.3"
|
||||
source = "registry+https://github.com/rust-lang/crates.io-index"
|
||||
checksum = "453440c271cf5577fd2a40e4942540cb7d0d2f85e27c8d07dd0023c925a67541"
|
||||
checksum = "0bd4b30a6560bbd9b4620f4de34c3f14f60848e58a9b7216801afcb4c7b31c3c"
|
||||
|
||||
[[package]]
|
||||
name = "dynasm"
|
||||
|
|
@ -1378,12 +1333,6 @@ dependencies = [
|
|||
"str-buf",
|
||||
]
|
||||
|
||||
[[package]]
|
||||
name = "fake-simd"
|
||||
version = "0.1.2"
|
||||
source = "registry+https://github.com/rust-lang/crates.io-index"
|
||||
checksum = "e88a8acf291dafb59c2d96e8f59828f3838bb1a70398823ade51a84de6a6deed"
|
||||
|
||||
[[package]]
|
||||
name = "fallible-iterator"
|
||||
version = "0.2.0"
|
||||
|
|
@ -1575,15 +1524,6 @@ dependencies = [
|
|||
"cfg-if 0.1.10",
|
||||
]
|
||||
|
||||
[[package]]
|
||||
name = "generic-array"
|
||||
version = "0.12.4"
|
||||
source = "registry+https://github.com/rust-lang/crates.io-index"
|
||||
checksum = "ffdf9f34f1447443d37393cc6c2b8313aebddcd96906caf34e54c68d8e57d7bd"
|
||||
dependencies = [
|
||||
"typenum",
|
||||
]
|
||||
|
||||
[[package]]
|
||||
name = "generic-array"
|
||||
version = "0.14.5"
|
||||
|
|
@ -2449,6 +2389,16 @@ version = "0.8.0"
|
|||
source = "registry+https://github.com/rust-lang/crates.io-index"
|
||||
checksum = "09f1f8e5676e1a1f2ee8b21f38238e1243c827531c9435624c7bfb305102cee4"
|
||||
|
||||
[[package]]
|
||||
name = "nu-ansi-term"
|
||||
version = "0.46.0"
|
||||
source = "registry+https://github.com/rust-lang/crates.io-index"
|
||||
checksum = "77a8165726e8236064dbb45459242600304b42a5ea24ee2948e18e023bf7ba84"
|
||||
dependencies = [
|
||||
"overload",
|
||||
"winapi",
|
||||
]
|
||||
|
||||
[[package]]
|
||||
name = "num-derive"
|
||||
version = "0.3.3"
|
||||
|
|
@ -2617,12 +2567,6 @@ version = "11.1.3"
|
|||
source = "registry+https://github.com/rust-lang/crates.io-index"
|
||||
checksum = "0ab1bc2a289d34bd04a330323ac98a1b4bc82c9d9fcb1e66b63caa84da26b575"
|
||||
|
||||
[[package]]
|
||||
name = "opaque-debug"
|
||||
version = "0.2.3"
|
||||
source = "registry+https://github.com/rust-lang/crates.io-index"
|
||||
checksum = "2839e79665f131bdb5782e51f2c6c9599c133c6098982a54c794358bf432529c"
|
||||
|
||||
[[package]]
|
||||
name = "ordered-float"
|
||||
version = "3.0.0"
|
||||
|
|
@ -2647,6 +2591,12 @@ dependencies = [
|
|||
"winapi",
|
||||
]
|
||||
|
||||
[[package]]
|
||||
name = "overload"
|
||||
version = "0.1.1"
|
||||
source = "registry+https://github.com/rust-lang/crates.io-index"
|
||||
checksum = "b15813163c1d831bf4a13c3610c05c0d03b39feb07f7e09fa234dac9b15aaf39"
|
||||
|
||||
[[package]]
|
||||
name = "owned_ttf_parser"
|
||||
version = "0.15.0"
|
||||
|
|
@ -2811,9 +2761,9 @@ dependencies = [
|
|||
|
||||
[[package]]
|
||||
name = "pest_derive"
|
||||
version = "2.1.0"
|
||||
version = "2.3.1"
|
||||
source = "registry+https://github.com/rust-lang/crates.io-index"
|
||||
checksum = "833d1ae558dc601e9a60366421196a8d94bc0ac980476d0b67e1d0988d72b2d0"
|
||||
checksum = "502b62a6d0245378b04ffe0a7fb4f4419a4815fce813bd8a0ec89a56e07d67b1"
|
||||
dependencies = [
|
||||
"pest",
|
||||
"pest_generator",
|
||||
|
|
@ -2821,9 +2771,9 @@ dependencies = [
|
|||
|
||||
[[package]]
|
||||
name = "pest_generator"
|
||||
version = "2.1.3"
|
||||
version = "2.3.1"
|
||||
source = "registry+https://github.com/rust-lang/crates.io-index"
|
||||
checksum = "99b8db626e31e5b81787b9783425769681b347011cc59471e33ea46d2ea0cf55"
|
||||
checksum = "451e629bf49b750254da26132f1a5a9d11fd8a95a3df51d15c4abd1ba154cb6c"
|
||||
dependencies = [
|
||||
"pest",
|
||||
"pest_meta",
|
||||
|
|
@ -2834,13 +2784,13 @@ dependencies = [
|
|||
|
||||
[[package]]
|
||||
name = "pest_meta"
|
||||
version = "2.1.3"
|
||||
version = "2.3.1"
|
||||
source = "registry+https://github.com/rust-lang/crates.io-index"
|
||||
checksum = "54be6e404f5317079812fc8f9f5279de376d8856929e21c184ecf6bbd692a11d"
|
||||
checksum = "bcec162c71c45e269dfc3fc2916eaeb97feab22993a21bcce4721d08cd7801a6"
|
||||
dependencies = [
|
||||
"maplit",
|
||||
"once_cell",
|
||||
"pest",
|
||||
"sha-1",
|
||||
"sha1 0.10.4",
|
||||
]
|
||||
|
||||
[[package]]
|
||||
|
|
@ -4458,18 +4408,6 @@ dependencies = [
|
|||
"syn",
|
||||
]
|
||||
|
||||
[[package]]
|
||||
name = "sha-1"
|
||||
version = "0.8.2"
|
||||
source = "registry+https://github.com/rust-lang/crates.io-index"
|
||||
checksum = "f7d94d0bede923b3cea61f3f1ff57ff8cdfd77b400fb8f9998949e0cf04163df"
|
||||
dependencies = [
|
||||
"block-buffer 0.7.3",
|
||||
"digest 0.8.1",
|
||||
"fake-simd",
|
||||
"opaque-debug",
|
||||
]
|
||||
|
||||
[[package]]
|
||||
name = "sha1"
|
||||
version = "0.6.1"
|
||||
|
|
@ -4479,6 +4417,17 @@ dependencies = [
|
|||
"sha1_smol",
|
||||
]
|
||||
|
||||
[[package]]
|
||||
name = "sha1"
|
||||
version = "0.10.4"
|
||||
source = "registry+https://github.com/rust-lang/crates.io-index"
|
||||
checksum = "006769ba83e921b3085caa8334186b00cf92b4cb1a6cf4632fbccc8eff5c7549"
|
||||
dependencies = [
|
||||
"cfg-if 1.0.0",
|
||||
"cpufeatures",
|
||||
"digest",
|
||||
]
|
||||
|
||||
[[package]]
|
||||
name = "sha1_smol"
|
||||
version = "1.0.0"
|
||||
|
|
@ -4493,7 +4442,7 @@ checksum = "55deaec60f81eefe3cce0dc50bda92d6d8e88f2a27df7c5033b42afeb1ed2676"
|
|||
dependencies = [
|
||||
"cfg-if 1.0.0",
|
||||
"cpufeatures",
|
||||
"digest 0.10.3",
|
||||
"digest",
|
||||
]
|
||||
|
||||
[[package]]
|
||||
|
|
@ -4736,7 +4685,7 @@ dependencies = [
|
|||
"serde",
|
||||
"serde_derive",
|
||||
"serde_json",
|
||||
"sha1",
|
||||
"sha1 0.6.1",
|
||||
"syn",
|
||||
]
|
||||
|
||||
|
|
@ -5114,9 +5063,9 @@ dependencies = [
|
|||
|
||||
[[package]]
|
||||
name = "tracing-core"
|
||||
version = "0.1.29"
|
||||
version = "0.1.30"
|
||||
source = "registry+https://github.com/rust-lang/crates.io-index"
|
||||
checksum = "5aeea4303076558a00714b823f9ad67d58a3bbda1df83d8827d21193156e22f7"
|
||||
checksum = "24eb03ba0eab1fd845050058ce5e616558e8f8d8fca633e6b163fe25c797213a"
|
||||
dependencies = [
|
||||
"once_cell",
|
||||
"valuable",
|
||||
|
|
@ -5135,12 +5084,12 @@ dependencies = [
|
|||
|
||||
[[package]]
|
||||
name = "tracing-subscriber"
|
||||
version = "0.3.15"
|
||||
version = "0.3.16"
|
||||
source = "registry+https://github.com/rust-lang/crates.io-index"
|
||||
checksum = "60db860322da191b40952ad9affe65ea23e7dd6a5c442c2c42865810c6ab8e6b"
|
||||
checksum = "a6176eae26dd70d0c919749377897b54a9276bd7061339665dd68777926b5a70"
|
||||
dependencies = [
|
||||
"ansi_term",
|
||||
"matchers",
|
||||
"nu-ansi-term",
|
||||
"once_cell",
|
||||
"regex",
|
||||
"sharded-slab",
|
||||
|
|
|
|||
|
|
@ -15,7 +15,7 @@ lazy_static = "1.4.0"
|
|||
|
||||
[build-dependencies]
|
||||
# dunce can be removed once ziglang/zig#5109 is fixed
|
||||
dunce = "1.0.2"
|
||||
dunce = "1.0.3"
|
||||
|
||||
[target.'cfg(target_os = "macos")'.build-dependencies]
|
||||
tempfile = "3.2.0"
|
||||
|
|
|
|||
|
|
@ -93,20 +93,6 @@ pub const RocList = extern struct {
|
|||
return (ptr - 1)[0] == utils.REFCOUNT_ONE;
|
||||
}
|
||||
|
||||
pub fn allocate(
|
||||
alignment: u32,
|
||||
length: usize,
|
||||
element_size: usize,
|
||||
) RocList {
|
||||
const data_bytes = length * element_size;
|
||||
|
||||
return RocList{
|
||||
.bytes = utils.allocateWithRefcount(data_bytes, alignment),
|
||||
.length = length,
|
||||
.capacity = length,
|
||||
};
|
||||
}
|
||||
|
||||
pub fn makeUniqueExtra(self: RocList, alignment: u32, element_width: usize, update_mode: UpdateMode) RocList {
|
||||
if (update_mode == .InPlace) {
|
||||
return self;
|
||||
|
|
@ -140,11 +126,117 @@ pub const RocList = extern struct {
|
|||
return new_list;
|
||||
}
|
||||
|
||||
// We follow roughly the [fbvector](https://github.com/facebook/folly/blob/main/folly/docs/FBVector.md) when it comes to growing a RocList.
|
||||
// Here is [their growth strategy](https://github.com/facebook/folly/blob/3e0525988fd444201b19b76b390a5927c15cb697/folly/FBVector.h#L1128) for push_back:
|
||||
//
|
||||
// (1) initial size
|
||||
// Instead of growing to size 1 from empty, fbvector allocates at least
|
||||
// 64 bytes. You may still use reserve to reserve a lesser amount of
|
||||
// memory.
|
||||
// (2) 1.5x
|
||||
// For medium-sized vectors, the growth strategy is 1.5x. See the docs
|
||||
// for details.
|
||||
// This does not apply to very small or very large fbvectors. This is a
|
||||
// heuristic.
|
||||
//
|
||||
// In our case, we exposed allocate and reallocate, which will use a smart growth stategy.
|
||||
// We also expose allocateExact and reallocateExact for case where a specific number of elements is requested.
|
||||
|
||||
// calculateCapacity should only be called in cases the list will be growing.
|
||||
// requested_length should always be greater than old_capacity.
|
||||
inline fn calculateCapacity(
|
||||
old_capacity: usize,
|
||||
requested_length: usize,
|
||||
element_width: usize,
|
||||
) usize {
|
||||
// TODO: there are two adjustments that would likely lead to better results for Roc.
|
||||
// 1. Deal with the fact we allocate an extra u64 for refcount.
|
||||
// This may lead to allocating page size + 8 bytes.
|
||||
// That could mean allocating an entire page for 8 bytes of data which isn't great.
|
||||
// 2. Deal with the fact that we can request more than 1 element at a time.
|
||||
// fbvector assumes just appending 1 element at a time when using this algorithm.
|
||||
// As such, they will generally grow in a way that should better match certain memory multiple.
|
||||
// This is also the normal case for roc, but we could also grow by a much larger amount.
|
||||
// We may want to round to multiples of 2 or something similar.
|
||||
var new_capacity: usize = 0;
|
||||
if (element_width == 0) {
|
||||
return requested_length;
|
||||
} else if (old_capacity == 0) {
|
||||
new_capacity = 64 / element_width;
|
||||
} else if (old_capacity < 4096 / element_width) {
|
||||
new_capacity = old_capacity * 2;
|
||||
} else if (old_capacity > 4096 * 32 / element_width) {
|
||||
new_capacity = old_capacity * 2;
|
||||
} else {
|
||||
new_capacity = (old_capacity * 3 + 1) / 2;
|
||||
}
|
||||
return @maximum(new_capacity, requested_length);
|
||||
}
|
||||
|
||||
pub fn allocate(
|
||||
alignment: u32,
|
||||
length: usize,
|
||||
element_width: usize,
|
||||
) RocList {
|
||||
if (length == 0) {
|
||||
return empty();
|
||||
}
|
||||
|
||||
const capacity = calculateCapacity(0, length, element_width);
|
||||
const data_bytes = capacity * element_width;
|
||||
return RocList{
|
||||
.bytes = utils.allocateWithRefcount(data_bytes, alignment),
|
||||
.length = length,
|
||||
.capacity = capacity,
|
||||
};
|
||||
}
|
||||
|
||||
pub fn allocateExact(
|
||||
alignment: u32,
|
||||
length: usize,
|
||||
element_width: usize,
|
||||
) RocList {
|
||||
if (length == 0) {
|
||||
return empty();
|
||||
}
|
||||
|
||||
const data_bytes = length * element_width;
|
||||
return RocList{
|
||||
.bytes = utils.allocateWithRefcount(data_bytes, alignment),
|
||||
.length = length,
|
||||
.capacity = length,
|
||||
};
|
||||
}
|
||||
|
||||
pub fn reallocate(
|
||||
self: RocList,
|
||||
alignment: u32,
|
||||
new_length: usize,
|
||||
element_width: usize,
|
||||
) RocList {
|
||||
if (self.bytes) |source_ptr| {
|
||||
if (self.isUnique()) {
|
||||
if (self.capacity >= new_length) {
|
||||
return RocList{ .bytes = self.bytes, .length = new_length, .capacity = self.capacity };
|
||||
} else {
|
||||
const new_capacity = calculateCapacity(self.capacity, new_length, element_width);
|
||||
const new_source = utils.unsafeReallocate(source_ptr, alignment, self.len(), new_capacity, element_width);
|
||||
return RocList{ .bytes = new_source, .length = new_length, .capacity = new_capacity };
|
||||
}
|
||||
}
|
||||
// TODO: Investigate the performance of this.
|
||||
// Maybe we should just always reallocate to the new_length instead of expanding capacity?
|
||||
const new_capacity = if (self.capacity >= new_length) self.capacity else calculateCapacity(self.capacity, new_length, element_width);
|
||||
return self.reallocateFresh(alignment, new_length, new_capacity, element_width);
|
||||
}
|
||||
return RocList.allocate(alignment, new_length, element_width);
|
||||
}
|
||||
|
||||
pub fn reallocateExact(
|
||||
self: RocList,
|
||||
alignment: u32,
|
||||
new_length: usize,
|
||||
element_width: usize,
|
||||
) RocList {
|
||||
if (self.bytes) |source_ptr| {
|
||||
if (self.isUnique()) {
|
||||
|
|
@ -155,9 +247,9 @@ pub const RocList = extern struct {
|
|||
return RocList{ .bytes = new_source, .length = new_length, .capacity = new_length };
|
||||
}
|
||||
}
|
||||
return self.reallocateFresh(alignment, new_length, new_length, element_width);
|
||||
}
|
||||
|
||||
return self.reallocateFresh(alignment, new_length, element_width);
|
||||
return RocList.allocateExact(alignment, new_length, element_width);
|
||||
}
|
||||
|
||||
/// reallocate by explicitly making a new allocation and copying elements over
|
||||
|
|
@ -165,16 +257,16 @@ pub const RocList = extern struct {
|
|||
self: RocList,
|
||||
alignment: u32,
|
||||
new_length: usize,
|
||||
new_capacity: usize,
|
||||
element_width: usize,
|
||||
) RocList {
|
||||
const old_length = self.length;
|
||||
const delta_length = new_length - old_length;
|
||||
|
||||
const data_bytes = new_length * element_width;
|
||||
const data_bytes = new_capacity * element_width;
|
||||
const first_slot = utils.allocateWithRefcount(data_bytes, alignment);
|
||||
|
||||
// transfer the memory
|
||||
|
||||
if (self.bytes) |source_ptr| {
|
||||
const dest_ptr = first_slot;
|
||||
|
||||
|
|
@ -185,7 +277,7 @@ pub const RocList = extern struct {
|
|||
const result = RocList{
|
||||
.bytes = first_slot,
|
||||
.length = new_length,
|
||||
.capacity = new_length,
|
||||
.capacity = new_capacity,
|
||||
};
|
||||
|
||||
utils.decref(self.bytes, old_length * element_width, alignment);
|
||||
|
|
@ -412,7 +504,7 @@ pub fn listWithCapacity(
|
|||
alignment: u32,
|
||||
element_width: usize,
|
||||
) callconv(.C) RocList {
|
||||
var output = RocList.allocate(alignment, capacity, element_width);
|
||||
var output = RocList.allocateExact(alignment, capacity, element_width);
|
||||
output.length = 0;
|
||||
return output;
|
||||
}
|
||||
|
|
|
|||
|
|
@ -144,6 +144,7 @@ comptime {
|
|||
exportStrFn(str.strTrimLeft, "trim_left");
|
||||
exportStrFn(str.strTrimRight, "trim_right");
|
||||
exportStrFn(str.strCloneTo, "clone_to");
|
||||
exportStrFn(str.withCapacity, "with_capacity");
|
||||
|
||||
inline for (INTEGERS) |T| {
|
||||
str.exportFromInt(T, ROC_BUILTINS ++ "." ++ STR ++ ".from_int.");
|
||||
|
|
|
|||
|
|
@ -2596,6 +2596,10 @@ pub fn reserve(string: RocStr, capacity: usize) callconv(.C) RocStr {
|
|||
}
|
||||
}
|
||||
|
||||
pub fn withCapacity(capacity: usize) callconv(.C) RocStr {
|
||||
return RocStr.allocate(0, capacity);
|
||||
}
|
||||
|
||||
pub fn getScalarUnsafe(string: RocStr, index: usize) callconv(.C) extern struct { bytesParsed: usize, scalar: u32 } {
|
||||
const slice = string.asSlice();
|
||||
const bytesParsed = @intCast(usize, std.unicode.utf8ByteSequenceLength(slice[index]) catch unreachable);
|
||||
|
|
|
|||
|
|
@ -61,6 +61,7 @@ interface List
|
|||
sortAsc,
|
||||
sortDesc,
|
||||
reserve,
|
||||
walkBackwardsUntil,
|
||||
]
|
||||
imports [
|
||||
Bool.{ Bool },
|
||||
|
|
@ -88,9 +89,8 @@ interface List
|
|||
##
|
||||
## ## Performance Details
|
||||
##
|
||||
## Under the hood, a list is a record containing a `len : Nat` field as well
|
||||
## as a pointer to a reference count and a flat array of bytes. Unique lists
|
||||
## store a capacity #Nat instead of a reference count.
|
||||
## Under the hood, a list is a record containing a `len : Nat` field, a `capacity : Nat`
|
||||
## field, and a pointer to a reference count and a flat array of bytes.
|
||||
##
|
||||
## ## Shared Lists
|
||||
##
|
||||
|
|
@ -112,9 +112,8 @@ interface List
|
|||
## begins with a refcount of 1, because so far only `ratings` is referencing it.
|
||||
##
|
||||
## The second line alters this refcount. `{ foo: ratings` references
|
||||
## the `ratings` list, which will result in its refcount getting incremented
|
||||
## from 0 to 1. Similarly, `bar: ratings }` also references the `ratings` list,
|
||||
## which will result in its refcount getting incremented from 1 to 2.
|
||||
## the `ratings` list, and so does `bar: ratings }`. This will result in its
|
||||
## refcount getting incremented from 1 to 3.
|
||||
##
|
||||
## Let's turn this example into a function.
|
||||
##
|
||||
|
|
@ -132,11 +131,11 @@ interface List
|
|||
##
|
||||
## Since `ratings` represented a way to reference the list, and that way is no
|
||||
## longer accessible, the list's refcount gets decremented when `ratings` goes
|
||||
## out of scope. It will decrease from 2 back down to 1.
|
||||
## out of scope. It will decrease from 3 back down to 2.
|
||||
##
|
||||
## Putting these together, when we call `getRatings 5`, what we get back is
|
||||
## a record with two fields, `foo`, and `bar`, each of which refers to the same
|
||||
## list, and that list has a refcount of 1.
|
||||
## list, and that list has a refcount of 2.
|
||||
##
|
||||
## Let's change the last line to be `(getRatings 5).bar` instead of `getRatings 5`:
|
||||
##
|
||||
|
|
@ -436,6 +435,13 @@ walkUntil = \list, initial, step ->
|
|||
Continue new -> new
|
||||
Break new -> new
|
||||
|
||||
## Same as [List.walkUntil], but does it from the end of the list instead.
|
||||
walkBackwardsUntil : List elem, state, (state, elem -> [Continue state, Break state]) -> state
|
||||
walkBackwardsUntil = \list, initial, func ->
|
||||
when List.iterateBackwards list initial func is
|
||||
Continue new -> new
|
||||
Break new -> new
|
||||
|
||||
sum : List (Num a) -> Num a
|
||||
sum = \list ->
|
||||
List.walk list 0 Num.add
|
||||
|
|
|
|||
|
|
@ -43,6 +43,7 @@ interface Str
|
|||
appendScalar,
|
||||
walkScalars,
|
||||
walkScalarsUntil,
|
||||
withCapacity,
|
||||
withPrefix,
|
||||
]
|
||||
imports [
|
||||
|
|
@ -145,6 +146,9 @@ Utf8Problem : { byteIndex : Nat, problem : Utf8ByteProblem }
|
|||
isEmpty : Str -> Bool
|
||||
concat : Str, Str -> Str
|
||||
|
||||
## Returns a string of the specified capacity without any content
|
||||
withCapacity : Nat -> Str
|
||||
|
||||
## Combine a list of strings into a single string, with a separator
|
||||
## string in between each.
|
||||
##
|
||||
|
|
|
|||
|
|
@ -361,6 +361,7 @@ pub const STR_RESERVE: &str = "roc_builtins.str.reserve";
|
|||
pub const STR_APPEND_SCALAR: &str = "roc_builtins.str.append_scalar";
|
||||
pub const STR_GET_SCALAR_UNSAFE: &str = "roc_builtins.str.get_scalar_unsafe";
|
||||
pub const STR_CLONE_TO: &str = "roc_builtins.str.clone_to";
|
||||
pub const STR_WITH_CAPACITY: &str = "roc_builtins.str.with_capacity";
|
||||
|
||||
pub const LIST_MAP: &str = "roc_builtins.list.map";
|
||||
pub const LIST_MAP2: &str = "roc_builtins.list.map2";
|
||||
|
|
|
|||
|
|
@ -123,6 +123,7 @@ map_symbol_to_lowlevel_and_arity! {
|
|||
StrGetScalarUnsafe; STR_GET_SCALAR_UNSAFE; 2,
|
||||
StrToNum; STR_TO_NUM; 1,
|
||||
StrGetCapacity; STR_CAPACITY; 1,
|
||||
StrWithCapacity; STR_WITH_CAPACITY; 1,
|
||||
|
||||
ListLen; LIST_LEN; 1,
|
||||
ListWithCapacity; LIST_WITH_CAPACITY; 1,
|
||||
|
|
|
|||
|
|
@ -60,8 +60,6 @@ trait CopyEnv {
|
|||
|
||||
fn clone_name(&mut self, name: SubsIndex<Lowercase>) -> SubsIndex<Lowercase>;
|
||||
|
||||
fn clone_tag_name(&mut self, tag_name: SubsIndex<TagName>) -> SubsIndex<TagName>;
|
||||
|
||||
fn clone_field_names(&mut self, field_names: SubsSlice<Lowercase>) -> SubsSlice<Lowercase>;
|
||||
|
||||
fn clone_tag_names(&mut self, tag_names: SubsSlice<TagName>) -> SubsSlice<TagName>;
|
||||
|
|
@ -95,11 +93,6 @@ impl CopyEnv for Subs {
|
|||
name
|
||||
}
|
||||
|
||||
#[inline(always)]
|
||||
fn clone_tag_name(&mut self, tag_name: SubsIndex<TagName>) -> SubsIndex<TagName> {
|
||||
tag_name
|
||||
}
|
||||
|
||||
#[inline(always)]
|
||||
fn clone_field_names(&mut self, field_names: SubsSlice<Lowercase>) -> SubsSlice<Lowercase> {
|
||||
field_names
|
||||
|
|
@ -150,11 +143,6 @@ impl<'a> CopyEnv for AcrossSubs<'a> {
|
|||
SubsIndex::push_new(&mut self.target.field_names, self.source[name].clone())
|
||||
}
|
||||
|
||||
#[inline(always)]
|
||||
fn clone_tag_name(&mut self, tag_name: SubsIndex<TagName>) -> SubsIndex<TagName> {
|
||||
SubsIndex::push_new(&mut self.target.tag_names, self.source[tag_name].clone())
|
||||
}
|
||||
|
||||
#[inline(always)]
|
||||
fn clone_field_names(&mut self, field_names: SubsSlice<Lowercase>) -> SubsSlice<Lowercase> {
|
||||
SubsSlice::extend_new(
|
||||
|
|
@ -935,12 +923,13 @@ fn deep_copy_type_vars<C: CopyEnv>(
|
|||
Structure(RecursiveTagUnion(new_rec_var, new_union_tags, new_ext_var))
|
||||
})
|
||||
}
|
||||
FunctionOrTagUnion(tag_name, symbol, ext_var) => {
|
||||
FunctionOrTagUnion(tag_names, symbols, ext_var) => {
|
||||
let new_ext_var = descend_var!(ext_var);
|
||||
let new_tag_name = env.clone_tag_name(tag_name);
|
||||
let new_tag_names = env.clone_tag_names(tag_names);
|
||||
let new_symbols = env.clone_lambda_names(symbols);
|
||||
perform_clone!(Structure(FunctionOrTagUnion(
|
||||
new_tag_name,
|
||||
symbol,
|
||||
new_tag_names,
|
||||
new_symbols,
|
||||
new_ext_var
|
||||
)))
|
||||
}
|
||||
|
|
|
|||
|
|
@ -2,7 +2,7 @@ use roc_module::{
|
|||
ident::{Lowercase, TagName},
|
||||
symbol::Symbol,
|
||||
};
|
||||
use roc_types::subs::{Content, FlatType, Subs, Variable};
|
||||
use roc_types::subs::{Content, FlatType, GetSubsSlice, Subs, Variable};
|
||||
|
||||
use crate::{
|
||||
util::{check_derivable_ext_var, debug_name_record},
|
||||
|
|
@ -107,9 +107,14 @@ impl FlatEncodable {
|
|||
|
||||
Ok(Key(FlatEncodableKey::TagUnion(tag_names_and_payload_sizes)))
|
||||
}
|
||||
FlatType::FunctionOrTagUnion(name_index, _, _) => Ok(Key(
|
||||
FlatEncodableKey::TagUnion(vec![(subs[name_index].clone(), 0)]),
|
||||
)),
|
||||
FlatType::FunctionOrTagUnion(names_index, _, _) => {
|
||||
Ok(Key(FlatEncodableKey::TagUnion(
|
||||
subs.get_subs_slice(names_index)
|
||||
.iter()
|
||||
.map(|t| (t.clone(), 0))
|
||||
.collect(),
|
||||
)))
|
||||
}
|
||||
FlatType::EmptyRecord => Ok(Key(FlatEncodableKey::Record(vec![]))),
|
||||
FlatType::EmptyTagUnion => Ok(Key(FlatEncodableKey::TagUnion(vec![]))),
|
||||
//
|
||||
|
|
|
|||
|
|
@ -6035,6 +6035,20 @@ fn run_low_level<'a, 'ctx, 'env>(
|
|||
bitcode::STR_TRIM_RIGHT,
|
||||
)
|
||||
}
|
||||
StrWithCapacity => {
|
||||
// Str.withCapacity : Nat -> Str
|
||||
debug_assert_eq!(args.len(), 1);
|
||||
|
||||
let str_len = load_symbol(scope, &args[0]);
|
||||
|
||||
call_str_bitcode_fn(
|
||||
env,
|
||||
&[],
|
||||
&[str_len],
|
||||
BitcodeReturns::Str,
|
||||
bitcode::STR_WITH_CAPACITY,
|
||||
)
|
||||
}
|
||||
ListLen => {
|
||||
// List.len : List * -> Nat
|
||||
debug_assert_eq!(args.len(), 1);
|
||||
|
|
@ -6157,7 +6171,7 @@ fn run_low_level<'a, 'ctx, 'env>(
|
|||
list_prepend(env, original_wrapper, elem, elem_layout)
|
||||
}
|
||||
StrGetUnsafe => {
|
||||
// List.getUnsafe : Str, Nat -> u8
|
||||
// Str.getUnsafe : Str, Nat -> u8
|
||||
debug_assert_eq!(args.len(), 2);
|
||||
|
||||
let wrapper_struct = load_symbol(scope, &args[0]);
|
||||
|
|
|
|||
|
|
@ -302,6 +302,7 @@ impl<'a> LowLevelCall<'a> {
|
|||
StrSubstringUnsafe => {
|
||||
self.load_args_and_call_zig(backend, bitcode::STR_SUBSTRING_UNSAFE)
|
||||
}
|
||||
StrWithCapacity => self.load_args_and_call_zig(backend, bitcode::STR_WITH_CAPACITY),
|
||||
|
||||
// List
|
||||
ListLen => match backend.storage.get(&self.arguments[0]) {
|
||||
|
|
|
|||
|
|
@ -30,6 +30,7 @@ pub enum LowLevel {
|
|||
StrAppendScalar,
|
||||
StrGetScalarUnsafe,
|
||||
StrGetCapacity,
|
||||
StrWithCapacity,
|
||||
ListLen,
|
||||
ListWithCapacity,
|
||||
ListReserve,
|
||||
|
|
@ -249,6 +250,7 @@ map_symbol_to_lowlevel! {
|
|||
StrGetScalarUnsafe <= STR_GET_SCALAR_UNSAFE,
|
||||
StrToNum <= STR_TO_NUM,
|
||||
StrGetCapacity <= STR_CAPACITY,
|
||||
StrWithCapacity <= STR_WITH_CAPACITY,
|
||||
ListLen <= LIST_LEN,
|
||||
ListGetCapacity <= LIST_CAPACITY,
|
||||
ListWithCapacity <= LIST_WITH_CAPACITY,
|
||||
|
|
|
|||
|
|
@ -1296,7 +1296,8 @@ define_builtins! {
|
|||
50 STR_REPLACE_EACH: "replaceEach"
|
||||
51 STR_REPLACE_FIRST: "replaceFirst"
|
||||
52 STR_REPLACE_LAST: "replaceLast"
|
||||
53 STR_WITH_PREFIX: "withPrefix"
|
||||
53 STR_WITH_CAPACITY: "withCapacity"
|
||||
54 STR_WITH_PREFIX: "withPrefix"
|
||||
}
|
||||
6 LIST: "List" => {
|
||||
0 LIST_LIST: "List" exposed_apply_type=true // the List.List type alias
|
||||
|
|
@ -1375,6 +1376,7 @@ define_builtins! {
|
|||
73 LIST_CAPACITY: "capacity"
|
||||
74 LIST_MAP_TRY: "mapTry"
|
||||
75 LIST_WALK_TRY: "walkTry"
|
||||
76 LIST_WALK_BACKWARDS_UNTIL: "walkBackwardsUntil"
|
||||
}
|
||||
7 RESULT: "Result" => {
|
||||
0 RESULT_RESULT: "Result" exposed_type=true // the Result.Result type alias
|
||||
|
|
|
|||
|
|
@ -881,7 +881,7 @@ pub fn lowlevel_borrow_signature(arena: &Bump, op: LowLevel) -> &[bool] {
|
|||
Unreachable => arena.alloc_slice_copy(&[irrelevant]),
|
||||
ListLen | StrIsEmpty | StrToScalars | StrCountGraphemes | StrCountUtf8Bytes
|
||||
| StrGetCapacity | ListGetCapacity => arena.alloc_slice_copy(&[borrowed]),
|
||||
ListWithCapacity => arena.alloc_slice_copy(&[irrelevant]),
|
||||
ListWithCapacity | StrWithCapacity => arena.alloc_slice_copy(&[irrelevant]),
|
||||
ListReplaceUnsafe => arena.alloc_slice_copy(&[owned, irrelevant, irrelevant]),
|
||||
StrGetUnsafe | ListGetUnsafe => arena.alloc_slice_copy(&[borrowed, irrelevant]),
|
||||
ListConcat => arena.alloc_slice_copy(&[owned, owned]),
|
||||
|
|
|
|||
|
|
@ -12,7 +12,7 @@ use roc_problem::can::RuntimeError;
|
|||
use roc_target::{PtrWidth, TargetInfo};
|
||||
use roc_types::num::NumericRange;
|
||||
use roc_types::subs::{
|
||||
self, Content, FlatType, GetSubsSlice, Label, OptVariable, RecordFields, Subs, UnionTags,
|
||||
self, Content, FlatType, GetSubsSlice, Label, OptVariable, RecordFields, Subs,
|
||||
UnsortedUnionLabels, Variable,
|
||||
};
|
||||
use roc_types::types::{gather_fields_unsorted_iter, RecordField, RecordFieldsError};
|
||||
|
|
@ -3152,16 +3152,18 @@ fn layout_from_flat_type<'a>(
|
|||
|
||||
layout_from_non_recursive_union(env, &tags).map(Ok)
|
||||
}
|
||||
FunctionOrTagUnion(tag_name, _, ext_var) => {
|
||||
FunctionOrTagUnion(tag_names, _, ext_var) => {
|
||||
debug_assert!(
|
||||
ext_var_is_empty_tag_union(subs, ext_var),
|
||||
"If ext_var wasn't empty, this wouldn't be a FunctionOrTagUnion!"
|
||||
);
|
||||
|
||||
let union_tags = UnionTags::from_tag_name_index(tag_name);
|
||||
let (tags, _) = union_tags.unsorted_tags_and_ext(subs, ext_var);
|
||||
let tag_names = subs.get_subs_slice(tag_names);
|
||||
let unsorted_tags = UnsortedUnionLabels {
|
||||
tags: tag_names.iter().map(|t| (t, &[] as &[Variable])).collect(),
|
||||
};
|
||||
|
||||
layout_from_non_recursive_union(env, &tags).map(Ok)
|
||||
layout_from_non_recursive_union(env, &unsorted_tags).map(Ok)
|
||||
}
|
||||
RecursiveTagUnion(rec_var, tags, ext_var) => {
|
||||
let (tags, ext_var) = tags.unsorted_tags_and_ext(subs, ext_var);
|
||||
|
|
|
|||
|
|
@ -345,7 +345,12 @@ fn eat_spaces<'a>(
|
|||
state = state.advance(1);
|
||||
return eat_line_comment(state, comments_and_newlines);
|
||||
}
|
||||
_ => break,
|
||||
_ => {
|
||||
if !comments_and_newlines.is_empty() {
|
||||
state = state.mark_current_indent();
|
||||
}
|
||||
break;
|
||||
}
|
||||
}
|
||||
}
|
||||
|
||||
|
|
@ -398,7 +403,10 @@ fn eat_line_comment<'a>(
|
|||
index += 1;
|
||||
continue 'outer;
|
||||
}
|
||||
_ => break,
|
||||
_ => {
|
||||
state = state.mark_current_indent();
|
||||
break;
|
||||
}
|
||||
}
|
||||
|
||||
index += 1;
|
||||
|
|
@ -490,7 +498,10 @@ fn eat_line_comment<'a>(
|
|||
index += 1;
|
||||
continue 'outer;
|
||||
}
|
||||
_ => break,
|
||||
_ => {
|
||||
state = state.mark_current_indent();
|
||||
break;
|
||||
}
|
||||
}
|
||||
|
||||
index += 1;
|
||||
|
|
@ -554,7 +565,10 @@ fn eat_line_comment<'a>(
|
|||
index += 1;
|
||||
continue 'outer;
|
||||
}
|
||||
_ => break,
|
||||
_ => {
|
||||
state = state.mark_current_indent();
|
||||
break;
|
||||
}
|
||||
}
|
||||
|
||||
index += 1;
|
||||
|
|
|
|||
|
|
@ -8,8 +8,8 @@ use crate::blankspace::{
|
|||
use crate::ident::{lowercase_ident, parse_ident, Ident};
|
||||
use crate::keyword;
|
||||
use crate::parser::{
|
||||
self, backtrackable, optional, sep_by1, sep_by1_e, specialize, specialize_ref, then,
|
||||
trailing_sep_by0, word1, word2, EExpect, EExpr, EIf, EInParens, ELambda, EList, ENumber,
|
||||
self, backtrackable, optional, parse_word1, sep_by1, sep_by1_e, specialize, specialize_ref,
|
||||
then, trailing_sep_by0, word1, word2, EClosure, EExpect, EExpr, EIf, EInParens, EList, ENumber,
|
||||
EPattern, ERecord, EString, EType, EWhen, Either, ParseResult, Parser,
|
||||
};
|
||||
use crate::pattern::{loc_closure_param, loc_has_parser};
|
||||
|
|
@ -205,7 +205,10 @@ fn parse_loc_term_or_underscore_or_conditional<'a>(
|
|||
loc!(specialize(EExpr::Str, string_literal_help())),
|
||||
loc!(specialize(EExpr::SingleQuote, single_quote_literal_help())),
|
||||
loc!(specialize(EExpr::Number, positive_number_literal_help())),
|
||||
loc!(specialize(EExpr::Lambda, closure_help(min_indent, options))),
|
||||
loc!(specialize(
|
||||
EExpr::Closure,
|
||||
closure_help(min_indent, options)
|
||||
)),
|
||||
loc!(underscore_expression()),
|
||||
loc!(record_literal_help(min_indent)),
|
||||
loc!(specialize(EExpr::List, list_literal_help(min_indent))),
|
||||
|
|
@ -230,7 +233,10 @@ fn parse_loc_term_or_underscore<'a>(
|
|||
loc!(specialize(EExpr::Str, string_literal_help())),
|
||||
loc!(specialize(EExpr::SingleQuote, single_quote_literal_help())),
|
||||
loc!(specialize(EExpr::Number, positive_number_literal_help())),
|
||||
loc!(specialize(EExpr::Lambda, closure_help(min_indent, options))),
|
||||
loc!(specialize(
|
||||
EExpr::Closure,
|
||||
closure_help(min_indent, options)
|
||||
)),
|
||||
loc!(underscore_expression()),
|
||||
loc!(record_literal_help(min_indent)),
|
||||
loc!(specialize(EExpr::List, list_literal_help(min_indent))),
|
||||
|
|
@ -253,7 +259,10 @@ fn parse_loc_term<'a>(
|
|||
loc!(specialize(EExpr::Str, string_literal_help())),
|
||||
loc!(specialize(EExpr::SingleQuote, single_quote_literal_help())),
|
||||
loc!(specialize(EExpr::Number, positive_number_literal_help())),
|
||||
loc!(specialize(EExpr::Lambda, closure_help(min_indent, options))),
|
||||
loc!(specialize(
|
||||
EExpr::Closure,
|
||||
closure_help(min_indent, options)
|
||||
)),
|
||||
loc!(record_literal_help(min_indent)),
|
||||
loc!(specialize(EExpr::List, list_literal_help(min_indent))),
|
||||
loc!(map_with_arena!(
|
||||
|
|
@ -344,7 +353,6 @@ fn unary_negate<'a>() -> impl Parser<'a, (), EExpr<'a>> {
|
|||
fn parse_expr_start<'a>(
|
||||
min_indent: u32,
|
||||
options: ExprParseOptions,
|
||||
start_column: u32,
|
||||
arena: &'a Bump,
|
||||
state: State<'a>,
|
||||
) -> ParseResult<'a, Loc<Expr<'a>>, EExpr<'a>> {
|
||||
|
|
@ -355,8 +363,11 @@ fn parse_expr_start<'a>(
|
|||
when::expr_help(min_indent, options)
|
||||
)),
|
||||
loc!(specialize(EExpr::Expect, expect_help(min_indent, options))),
|
||||
loc!(specialize(EExpr::Lambda, closure_help(min_indent, options))),
|
||||
loc!(move |a, s| parse_expr_operator_chain(min_indent, options, start_column, a, s)),
|
||||
loc!(specialize(
|
||||
EExpr::Closure,
|
||||
closure_help(min_indent, options)
|
||||
)),
|
||||
loc!(move |a, s| parse_expr_operator_chain(min_indent, options, a, s)),
|
||||
fail_expr_start_e()
|
||||
]
|
||||
.parse(arena, state)
|
||||
|
|
@ -365,10 +376,11 @@ fn parse_expr_start<'a>(
|
|||
fn parse_expr_operator_chain<'a>(
|
||||
min_indent: u32,
|
||||
options: ExprParseOptions,
|
||||
start_column: u32,
|
||||
arena: &'a Bump,
|
||||
state: State<'a>,
|
||||
) -> ParseResult<'a, Expr<'a>, EExpr<'a>> {
|
||||
let min_indent = state.check_indent(min_indent, EExpr::IndentStart)?;
|
||||
|
||||
let (_, expr, state) =
|
||||
loc_possibly_negative_or_negated_term(min_indent, options).parse(arena, state)?;
|
||||
|
||||
|
|
@ -387,7 +399,7 @@ fn parse_expr_operator_chain<'a>(
|
|||
end,
|
||||
};
|
||||
|
||||
parse_expr_end(min_indent, options, start_column, expr_state, arena, state)
|
||||
parse_expr_end(min_indent, options, expr_state, arena, state)
|
||||
}
|
||||
}
|
||||
}
|
||||
|
|
@ -604,13 +616,11 @@ fn numeric_negate_expression<'a, T>(
|
|||
|
||||
fn parse_defs_end<'a>(
|
||||
_options: ExprParseOptions,
|
||||
start_column: u32,
|
||||
min_indent: u32,
|
||||
mut defs: Defs<'a>,
|
||||
arena: &'a Bump,
|
||||
state: State<'a>,
|
||||
) -> ParseResult<'a, Defs<'a>, EExpr<'a>> {
|
||||
let min_indent = start_column;
|
||||
|
||||
let mut global_state = state;
|
||||
|
||||
loop {
|
||||
|
|
@ -723,7 +733,7 @@ fn parse_defs_end<'a>(
|
|||
loc_has_parser(min_indent).parse(arena, state.clone())
|
||||
{
|
||||
let (_, (type_def, def_region), state) = finish_parsing_ability_def_help(
|
||||
start_column,
|
||||
min_indent,
|
||||
Loc::at(name_region, name),
|
||||
args,
|
||||
loc_has,
|
||||
|
|
@ -967,14 +977,12 @@ fn parse_defs_end<'a>(
|
|||
|
||||
fn parse_defs_expr<'a>(
|
||||
options: ExprParseOptions,
|
||||
start_column: u32,
|
||||
min_indent: u32,
|
||||
defs: Defs<'a>,
|
||||
arena: &'a Bump,
|
||||
state: State<'a>,
|
||||
) -> ParseResult<'a, Expr<'a>, EExpr<'a>> {
|
||||
let min_indent = start_column;
|
||||
|
||||
match parse_defs_end(options, start_column, defs, arena, state) {
|
||||
match parse_defs_end(options, min_indent, defs, arena, state) {
|
||||
Err(bad) => Err(bad),
|
||||
Ok((_, def_state, state)) => {
|
||||
// this is no def, because there is no `=` or `:`; parse as an expr
|
||||
|
|
@ -1050,7 +1058,6 @@ enum AliasOrOpaque {
|
|||
fn finish_parsing_alias_or_opaque<'a>(
|
||||
min_indent: u32,
|
||||
options: ExprParseOptions,
|
||||
start_column: u32,
|
||||
expr_state: ExprState<'a>,
|
||||
loc_op: Loc<BinOp>,
|
||||
arena: &'a Bump,
|
||||
|
|
@ -1059,7 +1066,7 @@ fn finish_parsing_alias_or_opaque<'a>(
|
|||
kind: AliasOrOpaque,
|
||||
) -> ParseResult<'a, Expr<'a>, EExpr<'a>> {
|
||||
let expr_region = expr_state.expr.region;
|
||||
let indented_more = start_column + 1;
|
||||
let indented_more = min_indent + 1;
|
||||
|
||||
let (expr, arguments) = expr_state
|
||||
.validate_is_type_def(arena, loc_op, kind)
|
||||
|
|
@ -1175,7 +1182,7 @@ fn finish_parsing_alias_or_opaque<'a>(
|
|||
}
|
||||
};
|
||||
|
||||
parse_defs_expr(options, start_column, defs, arena, state)
|
||||
parse_defs_expr(options, min_indent, defs, arena, state)
|
||||
}
|
||||
|
||||
mod ability {
|
||||
|
|
@ -1364,7 +1371,6 @@ fn finish_parsing_ability_def_help<'a>(
|
|||
fn parse_expr_operator<'a>(
|
||||
min_indent: u32,
|
||||
options: ExprParseOptions,
|
||||
start_column: u32,
|
||||
mut expr_state: ExprState<'a>,
|
||||
loc_op: Loc<BinOp>,
|
||||
arena: &'a Bump,
|
||||
|
|
@ -1405,11 +1411,11 @@ fn parse_expr_operator<'a>(
|
|||
expr_state.spaces_after = spaces;
|
||||
expr_state.end = new_end;
|
||||
|
||||
parse_expr_end(min_indent, options, start_column, expr_state, arena, state)
|
||||
parse_expr_end(min_indent, options, expr_state, arena, state)
|
||||
}
|
||||
BinOp::Assignment => {
|
||||
let expr_region = expr_state.expr.region;
|
||||
let indented_more = start_column + 1;
|
||||
let indented_more = min_indent + 1;
|
||||
|
||||
let call = expr_state
|
||||
.validate_assignment_or_backpassing(arena, loc_op, EExpr::ElmStyleFunction)
|
||||
|
|
@ -1448,11 +1454,11 @@ fn parse_expr_operator<'a>(
|
|||
let mut defs = Defs::default();
|
||||
defs.push_value_def(value_def, def_region, &[], &[]);
|
||||
|
||||
parse_defs_expr(options, start_column, defs, arena, state)
|
||||
parse_defs_expr(options, min_indent, defs, arena, state)
|
||||
}
|
||||
BinOp::Backpassing => {
|
||||
let expr_region = expr_state.expr.region;
|
||||
let indented_more = start_column + 1;
|
||||
let indented_more = min_indent + 1;
|
||||
|
||||
let call = expr_state
|
||||
.validate_assignment_or_backpassing(arena, loc_op, |_, pos| {
|
||||
|
|
@ -1502,7 +1508,6 @@ fn parse_expr_operator<'a>(
|
|||
BinOp::IsAliasType | BinOp::IsOpaqueType => finish_parsing_alias_or_opaque(
|
||||
min_indent,
|
||||
options,
|
||||
start_column,
|
||||
expr_state,
|
||||
loc_op,
|
||||
arena,
|
||||
|
|
@ -1552,7 +1557,7 @@ fn parse_expr_operator<'a>(
|
|||
expr_state.spaces_after = spaces;
|
||||
|
||||
// TODO new start?
|
||||
parse_expr_end(min_indent, options, start_column, expr_state, arena, state)
|
||||
parse_expr_end(min_indent, options, expr_state, arena, state)
|
||||
}
|
||||
}
|
||||
}
|
||||
|
|
@ -1566,7 +1571,6 @@ fn parse_expr_operator<'a>(
|
|||
fn parse_expr_end<'a>(
|
||||
min_indent: u32,
|
||||
options: ExprParseOptions,
|
||||
start_column: u32,
|
||||
mut expr_state: ExprState<'a>,
|
||||
arena: &'a Bump,
|
||||
state: State<'a>,
|
||||
|
|
@ -1626,13 +1630,13 @@ fn parse_expr_end<'a>(
|
|||
|
||||
let args = arguments.into_bump_slice();
|
||||
let (_, (type_def, def_region), state) =
|
||||
finish_parsing_ability_def_help(start_column, name, args, has, arena, state)?;
|
||||
finish_parsing_ability_def_help(min_indent, name, args, has, arena, state)?;
|
||||
|
||||
let mut defs = Defs::default();
|
||||
|
||||
defs.push_type_def(type_def, def_region, &[], &[]);
|
||||
|
||||
parse_defs_expr(options, start_column, defs, arena, state)
|
||||
parse_defs_expr(options, min_indent, defs, arena, state)
|
||||
}
|
||||
Ok((_, mut arg, state)) => {
|
||||
let new_end = state.pos();
|
||||
|
|
@ -1660,7 +1664,7 @@ fn parse_expr_end<'a>(
|
|||
expr_state.end = new_end;
|
||||
expr_state.spaces_after = new_spaces;
|
||||
|
||||
parse_expr_end(min_indent, options, start_column, expr_state, arena, state)
|
||||
parse_expr_end(min_indent, options, expr_state, arena, state)
|
||||
}
|
||||
}
|
||||
}
|
||||
|
|
@ -1672,15 +1676,7 @@ fn parse_expr_end<'a>(
|
|||
Ok((_, loc_op, state)) => {
|
||||
expr_state.consume_spaces(arena);
|
||||
expr_state.initial = before_op;
|
||||
parse_expr_operator(
|
||||
min_indent,
|
||||
options,
|
||||
start_column,
|
||||
expr_state,
|
||||
loc_op,
|
||||
arena,
|
||||
state,
|
||||
)
|
||||
parse_expr_operator(min_indent, options, expr_state, loc_op, arena, state)
|
||||
}
|
||||
Err((NoProgress, _, mut state)) => {
|
||||
// try multi-backpassing
|
||||
|
|
@ -1714,8 +1710,6 @@ fn parse_expr_end<'a>(
|
|||
match word2(b'<', b'-', EExpr::BackpassArrow).parse(arena, state) {
|
||||
Err((_, fail, state)) => Err((MadeProgress, fail, state)),
|
||||
Ok((_, _, state)) => {
|
||||
let min_indent = start_column;
|
||||
|
||||
let parse_body = space0_before_e(
|
||||
move |a, s| parse_loc_expr(min_indent + 1, a, s),
|
||||
min_indent,
|
||||
|
|
@ -1793,8 +1787,7 @@ fn parse_loc_expr_with_options<'a>(
|
|||
arena: &'a Bump,
|
||||
state: State<'a>,
|
||||
) -> ParseResult<'a, Loc<Expr<'a>>, EExpr<'a>> {
|
||||
let column = state.column();
|
||||
parse_expr_start(min_indent, options, column, arena, state)
|
||||
parse_expr_start(min_indent, options, arena, state)
|
||||
}
|
||||
|
||||
/// If the given Expr would parse the same way as a valid Pattern, convert it.
|
||||
|
|
@ -1973,47 +1966,67 @@ pub fn toplevel_defs<'a>(min_indent: u32) -> impl Parser<'a, Defs<'a>, EExpr<'a>
|
|||
fn closure_help<'a>(
|
||||
min_indent: u32,
|
||||
options: ExprParseOptions,
|
||||
) -> impl Parser<'a, Expr<'a>, ELambda<'a>> {
|
||||
map_with_arena!(
|
||||
skip_first!(
|
||||
// All closures start with a '\' - e.g. (\x -> x + 1)
|
||||
word1(b'\\', ELambda::Start),
|
||||
// Once we see the '\', we're committed to parsing this as a closure.
|
||||
// It may turn out to be malformed, but it is definitely a closure.
|
||||
and!(
|
||||
// Parse the params
|
||||
// Params are comma-separated
|
||||
sep_by1_e(
|
||||
word1(b',', ELambda::Comma),
|
||||
space0_around_ee(
|
||||
specialize(ELambda::Pattern, loc_closure_param(min_indent)),
|
||||
min_indent,
|
||||
ELambda::IndentArg,
|
||||
ELambda::IndentArrow
|
||||
),
|
||||
ELambda::Arg,
|
||||
),
|
||||
skip_first!(
|
||||
// Parse the -> which separates params from body
|
||||
word2(b'-', b'>', ELambda::Arrow),
|
||||
// Parse the body
|
||||
space0_before_e(
|
||||
specialize_ref(ELambda::Body, move |arena, state| {
|
||||
parse_loc_expr_with_options(min_indent, options, arena, state)
|
||||
}),
|
||||
min_indent,
|
||||
ELambda::IndentBody
|
||||
)
|
||||
)
|
||||
)
|
||||
),
|
||||
|arena: &'a Bump, (params, loc_body)| {
|
||||
let params: Vec<'a, Loc<Pattern<'a>>> = params;
|
||||
let params: &'a [Loc<Pattern<'a>>] = params.into_bump_slice();
|
||||
) -> impl Parser<'a, Expr<'a>, EClosure<'a>> {
|
||||
move |arena, state| parse_closure_help(arena, state, min_indent, options)
|
||||
}
|
||||
|
||||
Expr::Closure(params, arena.alloc(loc_body))
|
||||
}
|
||||
fn parse_closure_help<'a>(
|
||||
arena: &'a Bump,
|
||||
state: State<'a>,
|
||||
_min_indent: u32,
|
||||
options: ExprParseOptions,
|
||||
) -> ParseResult<'a, Expr<'a>, EClosure<'a>> {
|
||||
let start_indent = state.line_indent();
|
||||
|
||||
let min_indent = start_indent;
|
||||
|
||||
// All closures start with a '\' - e.g. (\x -> x + 1)
|
||||
let (_, (), state) = parse_word1(state, min_indent, b'\\', EClosure::Start)?;
|
||||
|
||||
// After the first token, all other tokens must be indented past the start of the line
|
||||
let min_indent = min_indent + 1;
|
||||
|
||||
// Once we see the '\', we're committed to parsing this as a closure.
|
||||
// It may turn out to be malformed, but it is definitely a closure.
|
||||
|
||||
// Parse the params
|
||||
// Params are comma-separated
|
||||
let (_, params, state) = sep_by1_e(
|
||||
word1(b',', EClosure::Comma),
|
||||
space0_around_ee(
|
||||
specialize(EClosure::Pattern, loc_closure_param(min_indent)),
|
||||
min_indent,
|
||||
EClosure::IndentArg,
|
||||
EClosure::IndentArrow,
|
||||
),
|
||||
EClosure::Arg,
|
||||
)
|
||||
.parse(arena, state)
|
||||
.map_err(|(_p, e, s)| (MadeProgress, e, s))?;
|
||||
|
||||
let (_, loc_body, state) = skip_first!(
|
||||
// Parse the -> which separates params from body
|
||||
word2(b'-', b'>', EClosure::Arrow),
|
||||
// Parse the body
|
||||
space0_before_e(
|
||||
specialize_ref(EClosure::Body, move |arena, state| {
|
||||
parse_loc_expr_with_options(min_indent, options, arena, state)
|
||||
}),
|
||||
min_indent,
|
||||
EClosure::IndentBody
|
||||
)
|
||||
)
|
||||
.parse(arena, state)
|
||||
.map_err(|(_p, e, s)| (MadeProgress, e, s))?;
|
||||
|
||||
let params: Vec<'a, Loc<Pattern<'a>>> = params;
|
||||
let params: &'a [Loc<Pattern<'a>>] = params.into_bump_slice();
|
||||
|
||||
Ok((
|
||||
MadeProgress,
|
||||
Expr::Closure(params, arena.alloc(loc_body)),
|
||||
state,
|
||||
))
|
||||
}
|
||||
|
||||
mod when {
|
||||
|
|
|
|||
|
|
@ -89,7 +89,7 @@ impl_space_problem! {
|
|||
EIf<'a>,
|
||||
EImports,
|
||||
EInParens<'a>,
|
||||
ELambda<'a>,
|
||||
EClosure<'a>,
|
||||
EList<'a>,
|
||||
EPackageEntry<'a>,
|
||||
EPackages<'a>,
|
||||
|
|
@ -354,7 +354,7 @@ pub enum EExpr<'a> {
|
|||
|
||||
Expect(EExpect<'a>, Position),
|
||||
|
||||
Lambda(ELambda<'a>, Position),
|
||||
Closure(EClosure<'a>, Position),
|
||||
Underscore(Position),
|
||||
|
||||
InParens(EInParens<'a>, Position),
|
||||
|
|
@ -428,7 +428,7 @@ pub enum EInParens<'a> {
|
|||
}
|
||||
|
||||
#[derive(Debug, Clone, PartialEq, Eq)]
|
||||
pub enum ELambda<'a> {
|
||||
pub enum EClosure<'a> {
|
||||
Space(BadInputError, Position),
|
||||
Start(Position),
|
||||
Arrow(Position),
|
||||
|
|
@ -1452,6 +1452,31 @@ where
|
|||
}
|
||||
}
|
||||
|
||||
pub fn parse_word1<'a, ToError, E>(
|
||||
state: State<'a>,
|
||||
min_indent: u32,
|
||||
word: u8,
|
||||
to_error: ToError,
|
||||
) -> ParseResult<'a, (), E>
|
||||
where
|
||||
ToError: Fn(Position) -> E,
|
||||
E: 'a,
|
||||
{
|
||||
debug_assert_ne!(word, b'\n');
|
||||
|
||||
if min_indent > state.column() {
|
||||
return Err((NoProgress, to_error(state.pos()), state));
|
||||
}
|
||||
|
||||
match state.bytes().first() {
|
||||
Some(x) if *x == word => {
|
||||
let state = state.advance(1);
|
||||
Ok((MadeProgress, (), state))
|
||||
}
|
||||
_ => Err((NoProgress, to_error(state.pos()), state)),
|
||||
}
|
||||
}
|
||||
|
||||
pub fn word2<'a, ToError, E>(word_1: u8, word_2: u8, to_error: ToError) -> impl Parser<'a, (), E>
|
||||
where
|
||||
ToError: Fn(Position) -> E,
|
||||
|
|
|
|||
|
|
@ -1,13 +1,15 @@
|
|||
use roc_region::all::{Position, Region};
|
||||
use std::fmt;
|
||||
|
||||
use crate::parser::Progress;
|
||||
|
||||
/// A position in a source file.
|
||||
// NB: [Copy] is explicitly NOT derived to reduce the chance of bugs due to accidentally re-using
|
||||
// parser state.
|
||||
#[derive(Clone)]
|
||||
pub struct State<'a> {
|
||||
/// The raw input bytes from the file.
|
||||
/// Beware: original_bytes[0] always points the the start of the file.
|
||||
/// Beware: original_bytes[0] always points at the start of the file.
|
||||
/// Use bytes()[0] to access the current byte the parser is inspecting
|
||||
original_bytes: &'a [u8],
|
||||
|
||||
|
|
@ -16,6 +18,9 @@ pub struct State<'a> {
|
|||
|
||||
/// Position of the start of the current line
|
||||
pub(crate) line_start: Position,
|
||||
|
||||
/// Position of the first non-whitespace character on the current line
|
||||
pub(crate) line_start_after_whitespace: Position,
|
||||
}
|
||||
|
||||
impl<'a> State<'a> {
|
||||
|
|
@ -24,6 +29,10 @@ impl<'a> State<'a> {
|
|||
original_bytes: bytes,
|
||||
offset: 0,
|
||||
line_start: Position::zero(),
|
||||
|
||||
// Technically not correct.
|
||||
// We don't know the position of the first non-whitespace character yet.
|
||||
line_start_after_whitespace: Position::zero(),
|
||||
}
|
||||
}
|
||||
|
||||
|
|
@ -39,6 +48,24 @@ impl<'a> State<'a> {
|
|||
self.pos().offset - self.line_start.offset
|
||||
}
|
||||
|
||||
pub fn line_indent(&self) -> u32 {
|
||||
self.line_start_after_whitespace.offset - self.line_start.offset
|
||||
}
|
||||
|
||||
/// Check that the indent is at least `indent` spaces.
|
||||
/// Return a new indent if the current indent is greater than `indent`.
|
||||
pub fn check_indent<E>(
|
||||
&self,
|
||||
indent: u32,
|
||||
e: impl Fn(Position) -> E,
|
||||
) -> Result<u32, (Progress, E, State<'a>)> {
|
||||
if self.column() < indent {
|
||||
Err((Progress::NoProgress, e(self.pos()), self.clone()))
|
||||
} else {
|
||||
Ok(std::cmp::max(indent, self.line_indent()))
|
||||
}
|
||||
}
|
||||
|
||||
/// Mutably advance the state by a given offset
|
||||
#[inline(always)]
|
||||
pub(crate) fn advance_mut(&mut self, offset: usize) {
|
||||
|
|
@ -70,6 +97,18 @@ impl<'a> State<'a> {
|
|||
pub(crate) const fn advance_newline(mut self) -> State<'a> {
|
||||
self.offset += 1;
|
||||
self.line_start = self.pos();
|
||||
|
||||
// WARNING! COULD CAUSE BUGS IF WE FORGET TO CALL mark_current_ident LATER!
|
||||
// We really need to be stricter about this.
|
||||
self.line_start_after_whitespace = self.line_start;
|
||||
|
||||
self
|
||||
}
|
||||
|
||||
#[must_use]
|
||||
#[inline(always)]
|
||||
pub(crate) const fn mark_current_indent(mut self) -> State<'a> {
|
||||
self.line_start_after_whitespace = self.pos();
|
||||
self
|
||||
}
|
||||
|
||||
|
|
|
|||
|
|
@ -0,0 +1 @@
|
|||
Expr(Closure(Arg(@1), @1), @0)
|
||||
|
|
@ -0,0 +1 @@
|
|||
\,x -> 1
|
||||
|
|
@ -0,0 +1 @@
|
|||
Expr(Closure(IndentBody(@5), @3), @0)
|
||||
|
|
@ -0,0 +1,2 @@
|
|||
\x ->
|
||||
1
|
||||
|
|
@ -0,0 +1,71 @@
|
|||
BinOps(
|
||||
[
|
||||
(
|
||||
@0-10 SpaceAfter(
|
||||
Str(
|
||||
PlainLine(
|
||||
"a string",
|
||||
),
|
||||
),
|
||||
[
|
||||
Newline,
|
||||
],
|
||||
),
|
||||
@11-13 Pizza,
|
||||
),
|
||||
(
|
||||
@14-24 SpaceAfter(
|
||||
Var {
|
||||
module_name: "Str",
|
||||
ident: "toUtf8",
|
||||
},
|
||||
[
|
||||
Newline,
|
||||
],
|
||||
),
|
||||
@25-27 Pizza,
|
||||
),
|
||||
(
|
||||
@28-54 SpaceAfter(
|
||||
Apply(
|
||||
@28-36 Var {
|
||||
module_name: "List",
|
||||
ident: "map",
|
||||
},
|
||||
[
|
||||
@37-54 Closure(
|
||||
[
|
||||
@38-42 Identifier(
|
||||
"byte",
|
||||
),
|
||||
],
|
||||
@46-54 BinOps(
|
||||
[
|
||||
(
|
||||
@46-50 Var {
|
||||
module_name: "",
|
||||
ident: "byte",
|
||||
},
|
||||
@51-52 Plus,
|
||||
),
|
||||
],
|
||||
@53-54 Num(
|
||||
"1",
|
||||
),
|
||||
),
|
||||
),
|
||||
],
|
||||
Space,
|
||||
),
|
||||
[
|
||||
Newline,
|
||||
],
|
||||
),
|
||||
@55-57 Pizza,
|
||||
),
|
||||
],
|
||||
@58-70 Var {
|
||||
module_name: "List",
|
||||
ident: "reverse",
|
||||
},
|
||||
)
|
||||
|
|
@ -0,0 +1,4 @@
|
|||
"a string"
|
||||
|> Str.toUtf8
|
||||
|> List.map \byte -> byte + 1
|
||||
|> List.reverse
|
||||
|
|
@ -0,0 +1,15 @@
|
|||
Closure(
|
||||
[
|
||||
@1-2 Identifier(
|
||||
"x",
|
||||
),
|
||||
],
|
||||
@8-9 SpaceBefore(
|
||||
Num(
|
||||
"1",
|
||||
),
|
||||
[
|
||||
Newline,
|
||||
],
|
||||
),
|
||||
)
|
||||
|
|
@ -0,0 +1,2 @@
|
|||
\x ->
|
||||
1
|
||||
|
|
@ -120,6 +120,8 @@ mod test_parse {
|
|||
|
||||
// see tests/snapshots to see test input(.roc) and expected output(.result-ast)
|
||||
snapshot_tests! {
|
||||
fail/lambda_extra_comma.expr,
|
||||
fail/lambda_missing_indent.expr,
|
||||
fail/type_argument_no_arrow.expr,
|
||||
fail/type_double_comma.expr,
|
||||
pass/ability_demand_signature_is_multiline.expr,
|
||||
|
|
@ -157,6 +159,7 @@ mod test_parse {
|
|||
pass/empty_string.expr,
|
||||
pass/equals_with_spaces.expr,
|
||||
pass/equals.expr,
|
||||
pass/expect_fx.module,
|
||||
pass/expect.expr,
|
||||
pass/float_with_underscores.expr,
|
||||
pass/full_app_header_trailing_commas.header,
|
||||
|
|
@ -167,6 +170,8 @@ mod test_parse {
|
|||
pass/if_def.expr,
|
||||
pass/int_with_underscore.expr,
|
||||
pass/interface_with_newline.header,
|
||||
pass/lambda_in_chain.expr,
|
||||
pass/lambda_indent.expr,
|
||||
pass/list_closing_indent_not_enough.expr,
|
||||
pass/list_closing_same_indent_no_trailing_comma.expr,
|
||||
pass/list_closing_same_indent_with_trailing_comma.expr,
|
||||
|
|
@ -181,6 +186,7 @@ mod test_parse {
|
|||
pass/module_def_newline.module,
|
||||
pass/multi_backpassing.expr,
|
||||
pass/multi_char_string.expr,
|
||||
pass/multiline_string.expr,
|
||||
pass/multiline_type_signature_with_comment.expr,
|
||||
pass/multiline_type_signature.expr,
|
||||
pass/multiple_fields.expr,
|
||||
|
|
@ -204,7 +210,6 @@ mod test_parse {
|
|||
pass/not_docs.expr,
|
||||
pass/number_literal_suffixes.expr,
|
||||
pass/one_backpassing.expr,
|
||||
pass/multiline_string.expr,
|
||||
pass/one_char_string.expr,
|
||||
pass/one_def.expr,
|
||||
pass/one_minus_two.expr,
|
||||
|
|
@ -251,7 +256,6 @@ mod test_parse {
|
|||
pass/spaced_singleton_list.expr,
|
||||
pass/spaces_inside_empty_list.expr,
|
||||
pass/standalone_module_defs.module,
|
||||
pass/expect_fx.module,
|
||||
pass/string_without_escape.expr,
|
||||
pass/sub_var_with_spaces.expr,
|
||||
pass/sub_with_spaces.expr,
|
||||
|
|
@ -277,9 +281,9 @@ mod test_parse {
|
|||
pass/var_minus_two.expr,
|
||||
pass/var_then.expr,
|
||||
pass/var_when.expr,
|
||||
pass/when_if_guard.expr,
|
||||
pass/when_in_assignment.expr,
|
||||
pass/when_in_function.expr,
|
||||
pass/when_if_guard.expr,
|
||||
pass/when_in_parens_indented.expr,
|
||||
pass/when_in_parens.expr,
|
||||
pass/when_with_alternative_patterns.expr,
|
||||
|
|
|
|||
|
|
@ -1522,8 +1522,9 @@ fn solve(
|
|||
|
||||
symbols.iter().any(|(s, _)| {
|
||||
let var = env.get_var_by_symbol(s).expect("Symbol not solved!");
|
||||
let content = subs.get_content_without_compacting(var);
|
||||
!matches!(content, Error | Structure(FlatType::Func(..)))
|
||||
let (_, underlying_content) = chase_alias_content(subs, var);
|
||||
|
||||
!matches!(underlying_content, Error | Structure(FlatType::Func(..)))
|
||||
})
|
||||
};
|
||||
|
||||
|
|
@ -1555,6 +1556,17 @@ fn solve(
|
|||
state
|
||||
}
|
||||
|
||||
fn chase_alias_content(subs: &Subs, mut var: Variable) -> (Variable, &Content) {
|
||||
loop {
|
||||
match subs.get_content_without_compacting(var) {
|
||||
Content::Alias(_, _, real_var, _) => {
|
||||
var = *real_var;
|
||||
}
|
||||
content => return (var, content),
|
||||
}
|
||||
}
|
||||
}
|
||||
|
||||
#[allow(clippy::too_many_arguments)]
|
||||
fn compact_lambdas_and_check_obligations(
|
||||
arena: &Bump,
|
||||
|
|
@ -2299,10 +2311,11 @@ fn type_to_variable<'a>(
|
|||
unreachable!("we assert that the ext var is empty; otherwise we'd already know it was a tag union!");
|
||||
}
|
||||
|
||||
let slice = SubsIndex::new(subs.tag_names.len() as u32);
|
||||
subs.tag_names.push(tag_name.clone());
|
||||
let tag_names = SubsSlice::extend_new(&mut subs.tag_names, [tag_name.clone()]);
|
||||
let symbols = SubsSlice::extend_new(&mut subs.closure_names, [*symbol]);
|
||||
|
||||
let content = Content::Structure(FlatType::FunctionOrTagUnion(slice, *symbol, ext));
|
||||
let content =
|
||||
Content::Structure(FlatType::FunctionOrTagUnion(tag_names, symbols, ext));
|
||||
|
||||
register_with_known_var(subs, destination, rank, pools, content)
|
||||
}
|
||||
|
|
|
|||
|
|
@ -7842,6 +7842,20 @@ mod solve_expr {
|
|||
);
|
||||
}
|
||||
|
||||
#[test]
|
||||
fn dispatch_tag_union_function_inferred() {
|
||||
infer_eq_without_problem(
|
||||
indoc!(
|
||||
r#"
|
||||
g = if Bool.true then A else B
|
||||
|
||||
g ""
|
||||
"#
|
||||
),
|
||||
"[A Str, B Str]*",
|
||||
);
|
||||
}
|
||||
|
||||
#[test]
|
||||
fn check_char_as_u8() {
|
||||
infer_eq_without_problem(
|
||||
|
|
@ -7940,4 +7954,22 @@ mod solve_expr {
|
|||
"U32 -> U32",
|
||||
);
|
||||
}
|
||||
|
||||
#[test]
|
||||
fn issue_4246_admit_recursion_between_opaque_functions() {
|
||||
infer_eq_without_problem(
|
||||
indoc!(
|
||||
r#"
|
||||
app "test" provides [b] to "./platform"
|
||||
|
||||
O := {} -> {}
|
||||
|
||||
a = @O \{} -> ((\@O f -> f {}) b)
|
||||
|
||||
b = a
|
||||
"#
|
||||
),
|
||||
"O",
|
||||
);
|
||||
}
|
||||
}
|
||||
|
|
|
|||
|
|
@ -3395,3 +3395,59 @@ fn list_let_generalization() {
|
|||
usize
|
||||
);
|
||||
}
|
||||
|
||||
#[test]
|
||||
#[cfg(any(feature = "gen-llvm", feature = "gen-wasm"))]
|
||||
fn list_walk_backwards_until_sum() {
|
||||
assert_evals_to!(
|
||||
r#"List.walkBackwardsUntil [1, 2] 0 \a,b -> Continue (a + b)"#,
|
||||
3,
|
||||
i64
|
||||
);
|
||||
}
|
||||
|
||||
#[test]
|
||||
#[cfg(any(feature = "gen-llvm", feature = "gen-wasm"))]
|
||||
fn list_walk_backwards_implements_position() {
|
||||
assert_evals_to!(
|
||||
r#"
|
||||
Option a : [Some a, None]
|
||||
|
||||
find : List a, a -> Option Nat
|
||||
find = \list, needle ->
|
||||
findHelp list needle
|
||||
|> .v
|
||||
|
||||
findHelp = \list, needle ->
|
||||
List.walkBackwardsUntil list { n: 0, v: None } \{ n, v }, element ->
|
||||
if element == needle then
|
||||
Break { n, v: Some n }
|
||||
else
|
||||
Continue { n: n + 1, v }
|
||||
|
||||
when find [1, 2, 3] 3 is
|
||||
None -> 0
|
||||
Some v -> v
|
||||
"#,
|
||||
0,
|
||||
usize
|
||||
);
|
||||
}
|
||||
|
||||
#[test]
|
||||
#[cfg(any(feature = "gen-llvm", feature = "gen-wasm"))]
|
||||
fn list_walk_backwards_until_even_prefix_sum() {
|
||||
assert_evals_to!(
|
||||
r#"
|
||||
helper = \a, b ->
|
||||
if Num.isEven b then
|
||||
Continue (a + b)
|
||||
|
||||
else
|
||||
Break a
|
||||
|
||||
List.walkBackwardsUntil [9, 8, 4, 2] 0 helper"#,
|
||||
2 + 4 + 8,
|
||||
i64
|
||||
);
|
||||
}
|
||||
|
|
|
|||
|
|
@ -1931,6 +1931,34 @@ fn when_on_strings() {
|
|||
);
|
||||
}
|
||||
|
||||
#[test]
|
||||
#[cfg(any(feature = "gen-llvm", feature = "gen-wasm"))]
|
||||
fn with_capacity() {
|
||||
assert_evals_to!(
|
||||
indoc!(
|
||||
r#"
|
||||
Str.withCapacity 10
|
||||
"#
|
||||
),
|
||||
RocStr::from(""),
|
||||
RocStr
|
||||
);
|
||||
}
|
||||
|
||||
#[test]
|
||||
#[cfg(any(feature = "gen-llvm", feature = "gen-wasm"))]
|
||||
fn with_capacity_concat() {
|
||||
assert_evals_to!(
|
||||
indoc!(
|
||||
r#"
|
||||
Str.withCapacity 10 |> Str.concat "Forty-two"
|
||||
"#
|
||||
),
|
||||
RocStr::from("Forty-two"),
|
||||
RocStr
|
||||
);
|
||||
}
|
||||
|
||||
#[test]
|
||||
#[cfg(any(feature = "gen-llvm", feature = "gen-wasm"))]
|
||||
fn str_with_prefix() {
|
||||
|
|
|
|||
|
|
@ -2004,3 +2004,21 @@ fn match_on_result_with_uninhabited_error_branch() {
|
|||
RocStr
|
||||
);
|
||||
}
|
||||
|
||||
#[test]
|
||||
#[cfg(any(feature = "gen-llvm", feature = "gen-wasm"))]
|
||||
fn dispatch_tag_union_function_inferred() {
|
||||
assert_evals_to!(
|
||||
indoc!(
|
||||
r#"
|
||||
g = \b -> if b then H else J
|
||||
|
||||
when P ((g Bool.true) "") ((g Bool.false) "") is
|
||||
P (H _) (J _) -> "okay"
|
||||
_ -> "FAIL"
|
||||
"#
|
||||
),
|
||||
RocStr::from("okay"),
|
||||
RocStr
|
||||
);
|
||||
}
|
||||
|
|
|
|||
|
|
@ -1156,11 +1156,15 @@ fn write_flat_type<'a>(
|
|||
)
|
||||
}
|
||||
|
||||
FunctionOrTagUnion(tag_name, _, ext_var) => {
|
||||
FunctionOrTagUnion(tag_names, _, ext_var) => {
|
||||
buf.push('[');
|
||||
|
||||
let mut tags: MutMap<TagName, _> = MutMap::default();
|
||||
tags.insert(subs[*tag_name].clone(), vec![]);
|
||||
tags.extend(
|
||||
subs.get_subs_slice(*tag_names)
|
||||
.iter()
|
||||
.map(|t| (t.clone(), vec![])),
|
||||
);
|
||||
let ext_content = write_sorted_tags(env, ctx, subs, buf, &tags, *ext_var);
|
||||
|
||||
buf.push(']');
|
||||
|
|
@ -1241,8 +1245,12 @@ pub fn chase_ext_tag_union(
|
|||
push_union(subs, tags, fields);
|
||||
chase_ext_tag_union(subs, *ext_var, fields)
|
||||
}
|
||||
Content::Structure(FunctionOrTagUnion(tag_name, _, ext_var)) => {
|
||||
fields.push((subs[*tag_name].clone(), vec![]));
|
||||
Content::Structure(FunctionOrTagUnion(tag_names, _, ext_var)) => {
|
||||
fields.extend(
|
||||
subs.get_subs_slice(*tag_names)
|
||||
.iter()
|
||||
.map(|t| (t.clone(), vec![])),
|
||||
);
|
||||
|
||||
chase_ext_tag_union(subs, *ext_var, fields)
|
||||
}
|
||||
|
|
|
|||
|
|
@ -962,13 +962,13 @@ fn subs_fmt_flat_type(this: &FlatType, subs: &Subs, f: &mut fmt::Formatter) -> f
|
|||
|
||||
write!(f, "]<{:?}>", new_ext)
|
||||
}
|
||||
FlatType::FunctionOrTagUnion(tagname_index, symbol, ext) => {
|
||||
let tagname: &TagName = &subs[*tagname_index];
|
||||
FlatType::FunctionOrTagUnion(tagnames, symbol, ext) => {
|
||||
let tagnames: &[TagName] = subs.get_subs_slice(*tagnames);
|
||||
|
||||
write!(
|
||||
f,
|
||||
"FunctionOrTagUnion({:?}, {:?}, {:?})",
|
||||
tagname, symbol, ext
|
||||
tagnames, symbol, ext
|
||||
)
|
||||
}
|
||||
FlatType::RecursiveTagUnion(rec, tags, ext) => {
|
||||
|
|
@ -2424,7 +2424,12 @@ pub enum FlatType {
|
|||
Func(VariableSubsSlice, Variable, Variable),
|
||||
Record(RecordFields, Variable),
|
||||
TagUnion(UnionTags, Variable),
|
||||
FunctionOrTagUnion(SubsIndex<TagName>, Symbol, Variable),
|
||||
|
||||
/// `A` might either be a function
|
||||
/// x -> A x : a -> [A a, B a, C a]
|
||||
/// or a tag `[A, B, C]`
|
||||
FunctionOrTagUnion(SubsSlice<TagName>, SubsSlice<Symbol>, Variable),
|
||||
|
||||
RecursiveTagUnion(Variable, UnionTags, Variable),
|
||||
Erroneous(SubsIndex<Problem>),
|
||||
EmptyRecord,
|
||||
|
|
@ -3881,12 +3886,12 @@ fn flat_type_to_err_type(
|
|||
}
|
||||
}
|
||||
|
||||
FunctionOrTagUnion(tag_name, _, ext_var) => {
|
||||
let tag_name = subs[tag_name].clone();
|
||||
FunctionOrTagUnion(tag_names, _, ext_var) => {
|
||||
let tag_names = subs.get_subs_slice(tag_names);
|
||||
|
||||
let mut err_tags = SendMap::default();
|
||||
let mut err_tags: SendMap<TagName, Vec<_>> = SendMap::default();
|
||||
|
||||
err_tags.insert(tag_name, vec![]);
|
||||
err_tags.extend(tag_names.iter().map(|t| (t.clone(), vec![])));
|
||||
|
||||
match var_to_err_type(subs, state, ext_var).unwrap_structural_alias() {
|
||||
ErrorType::TagUnion(sub_tags, sub_ext) => {
|
||||
|
|
@ -4202,8 +4207,8 @@ impl StorageSubs {
|
|||
Self::offset_tag_union(offsets, *union_tags),
|
||||
Self::offset_variable(offsets, *ext),
|
||||
),
|
||||
FlatType::FunctionOrTagUnion(tag_name, symbol, ext) => FlatType::FunctionOrTagUnion(
|
||||
Self::offset_tag_name_index(offsets, *tag_name),
|
||||
FlatType::FunctionOrTagUnion(tag_names, symbol, ext) => FlatType::FunctionOrTagUnion(
|
||||
Self::offset_tag_name_slice(offsets, *tag_names),
|
||||
*symbol,
|
||||
Self::offset_variable(offsets, *ext),
|
||||
),
|
||||
|
|
@ -4295,13 +4300,13 @@ impl StorageSubs {
|
|||
record_fields
|
||||
}
|
||||
|
||||
fn offset_tag_name_index(
|
||||
fn offset_tag_name_slice(
|
||||
offsets: &StorageSubsOffsets,
|
||||
mut tag_name: SubsIndex<TagName>,
|
||||
) -> SubsIndex<TagName> {
|
||||
tag_name.index += offsets.tag_names;
|
||||
mut tag_names: SubsSlice<TagName>,
|
||||
) -> SubsSlice<TagName> {
|
||||
tag_names.start += offsets.tag_names;
|
||||
|
||||
tag_name
|
||||
tag_names
|
||||
}
|
||||
|
||||
fn offset_variable(offsets: &StorageSubsOffsets, variable: Variable) -> Variable {
|
||||
|
|
@ -4542,12 +4547,22 @@ fn storage_copy_var_to_help(env: &mut StorageCopyVarToEnv<'_>, var: Variable) ->
|
|||
TagUnion(union_tags, new_ext)
|
||||
}
|
||||
|
||||
FunctionOrTagUnion(tag_name, symbol, ext_var) => {
|
||||
let new_tag_name = SubsIndex::new(env.target.tag_names.len() as u32);
|
||||
FunctionOrTagUnion(tag_names, symbols, ext_var) => {
|
||||
let new_tag_names = SubsSlice::extend_new(
|
||||
&mut env.target.tag_names,
|
||||
env.source.get_subs_slice(tag_names).iter().cloned(),
|
||||
);
|
||||
|
||||
env.target.tag_names.push(env.source[tag_name].clone());
|
||||
let new_symbols = SubsSlice::extend_new(
|
||||
&mut env.target.closure_names,
|
||||
env.source.get_subs_slice(symbols).iter().cloned(),
|
||||
);
|
||||
|
||||
FunctionOrTagUnion(new_tag_name, symbol, storage_copy_var_to_help(env, ext_var))
|
||||
FunctionOrTagUnion(
|
||||
new_tag_names,
|
||||
new_symbols,
|
||||
storage_copy_var_to_help(env, ext_var),
|
||||
)
|
||||
}
|
||||
|
||||
RecursiveTagUnion(rec_var, tags, ext_var) => {
|
||||
|
|
@ -4981,14 +4996,20 @@ fn copy_import_to_help(env: &mut CopyImportEnv<'_>, max_rank: Rank, var: Variabl
|
|||
TagUnion(union_tags, new_ext)
|
||||
}
|
||||
|
||||
FunctionOrTagUnion(tag_name, symbol, ext_var) => {
|
||||
let new_tag_name = SubsIndex::new(env.target.tag_names.len() as u32);
|
||||
FunctionOrTagUnion(tag_names, symbols, ext_var) => {
|
||||
let new_tag_names = SubsSlice::extend_new(
|
||||
&mut env.target.tag_names,
|
||||
env.source.get_subs_slice(tag_names).iter().cloned(),
|
||||
);
|
||||
|
||||
env.target.tag_names.push(env.source[tag_name].clone());
|
||||
let new_symbols = SubsSlice::extend_new(
|
||||
&mut env.target.closure_names,
|
||||
env.source.get_subs_slice(symbols).iter().cloned(),
|
||||
);
|
||||
|
||||
FunctionOrTagUnion(
|
||||
new_tag_name,
|
||||
symbol,
|
||||
new_tag_names,
|
||||
new_symbols,
|
||||
copy_import_to_help(env, max_rank, ext_var),
|
||||
)
|
||||
}
|
||||
|
|
|
|||
|
|
@ -2657,13 +2657,13 @@ fn unify_flat_type<M: MetaCollector>(
|
|||
|
||||
outcome
|
||||
}
|
||||
(FunctionOrTagUnion(tag_name, tag_symbol, ext), Func(args, closure, ret)) => {
|
||||
(FunctionOrTagUnion(tag_names, tag_symbols, ext), Func(args, closure, ret)) => {
|
||||
unify_function_or_tag_union_and_func(
|
||||
env,
|
||||
pool,
|
||||
ctx,
|
||||
tag_name,
|
||||
*tag_symbol,
|
||||
*tag_names,
|
||||
*tag_symbols,
|
||||
*ext,
|
||||
*args,
|
||||
*ret,
|
||||
|
|
@ -2671,13 +2671,13 @@ fn unify_flat_type<M: MetaCollector>(
|
|||
true,
|
||||
)
|
||||
}
|
||||
(Func(args, closure, ret), FunctionOrTagUnion(tag_name, tag_symbol, ext)) => {
|
||||
(Func(args, closure, ret), FunctionOrTagUnion(tag_names, tag_symbols, ext)) => {
|
||||
unify_function_or_tag_union_and_func(
|
||||
env,
|
||||
pool,
|
||||
ctx,
|
||||
tag_name,
|
||||
*tag_symbol,
|
||||
*tag_names,
|
||||
*tag_symbols,
|
||||
*ext,
|
||||
*args,
|
||||
*ret,
|
||||
|
|
@ -2685,50 +2685,61 @@ fn unify_flat_type<M: MetaCollector>(
|
|||
false,
|
||||
)
|
||||
}
|
||||
(FunctionOrTagUnion(tag_name_1, _, ext1), FunctionOrTagUnion(tag_name_2, _, ext2)) => {
|
||||
let tag_name_1_ref = &env.subs[*tag_name_1];
|
||||
let tag_name_2_ref = &env.subs[*tag_name_2];
|
||||
|
||||
if tag_name_1_ref == tag_name_2_ref {
|
||||
let outcome = unify_pool(env, pool, *ext1, *ext2, ctx.mode);
|
||||
if outcome.mismatches.is_empty() {
|
||||
let content = *env.subs.get_content_without_compacting(ctx.second);
|
||||
merge(env, ctx, content)
|
||||
} else {
|
||||
outcome
|
||||
}
|
||||
} else {
|
||||
let tags1 = UnionTags::from_tag_name_index(*tag_name_1);
|
||||
let tags2 = UnionTags::from_tag_name_index(*tag_name_2);
|
||||
|
||||
unify_tag_unions(env, pool, ctx, tags1, *ext1, tags2, *ext2, Rec::None)
|
||||
}
|
||||
}
|
||||
(TagUnion(tags1, ext1), FunctionOrTagUnion(tag_name, _, ext2)) => {
|
||||
let tags2 = UnionTags::from_tag_name_index(*tag_name);
|
||||
(
|
||||
FunctionOrTagUnion(tag_names_1, tag_symbols_1, ext1),
|
||||
FunctionOrTagUnion(tag_names_2, tag_symbols_2, ext2),
|
||||
) => unify_two_function_or_tag_unions(
|
||||
env,
|
||||
pool,
|
||||
ctx,
|
||||
*tag_names_1,
|
||||
*tag_symbols_1,
|
||||
*ext1,
|
||||
*tag_names_2,
|
||||
*tag_symbols_2,
|
||||
*ext2,
|
||||
),
|
||||
(TagUnion(tags1, ext1), FunctionOrTagUnion(tag_names, _, ext2)) => {
|
||||
let empty_tag_var_slices = SubsSlice::extend_new(
|
||||
&mut env.subs.variable_slices,
|
||||
std::iter::repeat(Default::default()).take(tag_names.len()),
|
||||
);
|
||||
let tags2 = UnionTags::from_slices(*tag_names, empty_tag_var_slices);
|
||||
|
||||
unify_tag_unions(env, pool, ctx, *tags1, *ext1, tags2, *ext2, Rec::None)
|
||||
}
|
||||
(FunctionOrTagUnion(tag_name, _, ext1), TagUnion(tags2, ext2)) => {
|
||||
let tags1 = UnionTags::from_tag_name_index(*tag_name);
|
||||
(FunctionOrTagUnion(tag_names, _, ext1), TagUnion(tags2, ext2)) => {
|
||||
let empty_tag_var_slices = SubsSlice::extend_new(
|
||||
&mut env.subs.variable_slices,
|
||||
std::iter::repeat(Default::default()).take(tag_names.len()),
|
||||
);
|
||||
let tags1 = UnionTags::from_slices(*tag_names, empty_tag_var_slices);
|
||||
|
||||
unify_tag_unions(env, pool, ctx, tags1, *ext1, *tags2, *ext2, Rec::None)
|
||||
}
|
||||
|
||||
(RecursiveTagUnion(recursion_var, tags1, ext1), FunctionOrTagUnion(tag_name, _, ext2)) => {
|
||||
(RecursiveTagUnion(recursion_var, tags1, ext1), FunctionOrTagUnion(tag_names, _, ext2)) => {
|
||||
// this never happens in type-correct programs, but may happen if there is a type error
|
||||
debug_assert!(is_recursion_var(env.subs, *recursion_var));
|
||||
|
||||
let tags2 = UnionTags::from_tag_name_index(*tag_name);
|
||||
let empty_tag_var_slices = SubsSlice::extend_new(
|
||||
&mut env.subs.variable_slices,
|
||||
std::iter::repeat(Default::default()).take(tag_names.len()),
|
||||
);
|
||||
let tags2 = UnionTags::from_slices(*tag_names, empty_tag_var_slices);
|
||||
let rec = Rec::Left(*recursion_var);
|
||||
|
||||
unify_tag_unions(env, pool, ctx, *tags1, *ext1, tags2, *ext2, rec)
|
||||
}
|
||||
|
||||
(FunctionOrTagUnion(tag_name, _, ext1), RecursiveTagUnion(recursion_var, tags2, ext2)) => {
|
||||
(FunctionOrTagUnion(tag_names, _, ext1), RecursiveTagUnion(recursion_var, tags2, ext2)) => {
|
||||
debug_assert!(is_recursion_var(env.subs, *recursion_var));
|
||||
|
||||
let tags1 = UnionTags::from_tag_name_index(*tag_name);
|
||||
let empty_tag_var_slices = SubsSlice::extend_new(
|
||||
&mut env.subs.variable_slices,
|
||||
std::iter::repeat(Default::default()).take(tag_names.len()),
|
||||
);
|
||||
let tags1 = UnionTags::from_slices(*tag_names, empty_tag_var_slices);
|
||||
let rec = Rec::Right(*recursion_var);
|
||||
|
||||
unify_tag_unions(env, pool, ctx, tags1, *ext1, *tags2, *ext2, rec)
|
||||
|
|
@ -3133,17 +3144,20 @@ fn unify_function_or_tag_union_and_func<M: MetaCollector>(
|
|||
env: &mut Env,
|
||||
pool: &mut Pool,
|
||||
ctx: &Context,
|
||||
tag_name_index: &SubsIndex<TagName>,
|
||||
tag_symbol: Symbol,
|
||||
tag_names_slice: SubsSlice<TagName>,
|
||||
tag_fn_lambdas: SubsSlice<Symbol>,
|
||||
tag_ext: Variable,
|
||||
function_arguments: VariableSubsSlice,
|
||||
function_return: Variable,
|
||||
function_lambda_set: Variable,
|
||||
left: bool,
|
||||
) -> Outcome<M> {
|
||||
let tag_name = env.subs[*tag_name_index].clone();
|
||||
let tag_names = env.subs.get_subs_slice(tag_names_slice).to_vec();
|
||||
|
||||
let union_tags = UnionTags::insert_slices_into_subs(env.subs, [(tag_name, function_arguments)]);
|
||||
let union_tags = UnionTags::insert_slices_into_subs(
|
||||
env.subs,
|
||||
tag_names.into_iter().map(|tag| (tag, function_arguments)),
|
||||
);
|
||||
let content = Content::Structure(FlatType::TagUnion(union_tags, tag_ext));
|
||||
|
||||
let new_tag_union_var = fresh(env, pool, ctx, content);
|
||||
|
|
@ -3155,7 +3169,14 @@ fn unify_function_or_tag_union_and_func<M: MetaCollector>(
|
|||
};
|
||||
|
||||
{
|
||||
let union_tags = UnionLambdas::tag_without_arguments(env.subs, tag_symbol);
|
||||
let lambda_names = env.subs.get_subs_slice(tag_fn_lambdas).to_vec();
|
||||
let new_lambda_names = SubsSlice::extend_new(&mut env.subs.closure_names, lambda_names);
|
||||
let empty_captures_slices = SubsSlice::extend_new(
|
||||
&mut env.subs.variable_slices,
|
||||
std::iter::repeat(Default::default()).take(new_lambda_names.len()),
|
||||
);
|
||||
let union_tags = UnionLambdas::from_slices(new_lambda_names, empty_captures_slices);
|
||||
|
||||
let ambient_function_var = if left { ctx.first } else { ctx.second };
|
||||
let lambda_set_content = LambdaSet(self::LambdaSet {
|
||||
solved: union_tags,
|
||||
|
|
@ -3196,3 +3217,53 @@ fn unify_function_or_tag_union_and_func<M: MetaCollector>(
|
|||
|
||||
outcome
|
||||
}
|
||||
|
||||
#[allow(clippy::too_many_arguments)]
|
||||
fn unify_two_function_or_tag_unions<M: MetaCollector>(
|
||||
env: &mut Env,
|
||||
pool: &mut Pool,
|
||||
ctx: &Context,
|
||||
tag_names_1: SubsSlice<TagName>,
|
||||
tag_symbols_1: SubsSlice<Symbol>,
|
||||
ext1: Variable,
|
||||
tag_names_2: SubsSlice<TagName>,
|
||||
tag_symbols_2: SubsSlice<Symbol>,
|
||||
ext2: Variable,
|
||||
) -> Outcome<M> {
|
||||
let merged_tags = {
|
||||
let mut all_tags: Vec<_> = (env.subs.get_subs_slice(tag_names_1).iter())
|
||||
.chain(env.subs.get_subs_slice(tag_names_2))
|
||||
.cloned()
|
||||
.collect();
|
||||
all_tags.sort();
|
||||
all_tags.dedup();
|
||||
SubsSlice::extend_new(&mut env.subs.tag_names, all_tags)
|
||||
};
|
||||
let merged_lambdas = {
|
||||
let mut all_lambdas: Vec<_> = (env.subs.get_subs_slice(tag_symbols_1).iter())
|
||||
.chain(env.subs.get_subs_slice(tag_symbols_2))
|
||||
.cloned()
|
||||
.collect();
|
||||
all_lambdas.sort();
|
||||
all_lambdas.dedup();
|
||||
SubsSlice::extend_new(&mut env.subs.closure_names, all_lambdas)
|
||||
};
|
||||
|
||||
let mut outcome = unify_pool(env, pool, ext1, ext2, ctx.mode);
|
||||
if !outcome.mismatches.is_empty() {
|
||||
return outcome;
|
||||
}
|
||||
|
||||
let merge_outcome = merge(
|
||||
env,
|
||||
ctx,
|
||||
Content::Structure(FlatType::FunctionOrTagUnion(
|
||||
merged_tags,
|
||||
merged_lambdas,
|
||||
ext1,
|
||||
)),
|
||||
);
|
||||
|
||||
outcome.union(merge_outcome);
|
||||
outcome
|
||||
}
|
||||
|
|
|
|||
|
|
@ -44,4 +44,21 @@
|
|||
searchBox.addEventListener("input", search);
|
||||
|
||||
search();
|
||||
|
||||
// Capture '/' keypress for quick search
|
||||
window.addEventListener("keyup", (e) => {
|
||||
|
||||
if (e.code === "Slash") {
|
||||
e.preventDefault;
|
||||
searchBox.focus();
|
||||
searchBox.value = "";
|
||||
}
|
||||
|
||||
if (e.code === "Escape" && document.activeElement === searchBox) {
|
||||
e.preventDefault;
|
||||
searchBox.blur();
|
||||
}
|
||||
|
||||
});
|
||||
|
||||
})();
|
||||
|
|
|
|||
|
|
@ -47,7 +47,7 @@ cgmath = "0.18.0"
|
|||
snafu = { version = "0.7.1", features = ["backtraces"] }
|
||||
colored = "2.0.0"
|
||||
pest = "2.3.1"
|
||||
pest_derive = "2.1.0"
|
||||
pest_derive = "2.3.1"
|
||||
copypasta = "0.8.1"
|
||||
palette = "0.6.1"
|
||||
confy = { git = 'https://github.com/rust-cli/confy', features = [
|
||||
|
|
|
|||
|
|
@ -20,7 +20,7 @@ use roc_gen_llvm::{run_jit_function, run_jit_function_dynamic_type};
|
|||
use roc_load::{EntryPoint, MonomorphizedModule};
|
||||
use roc_mono::ir::OptLevel;
|
||||
use roc_parse::ast::Expr;
|
||||
use roc_parse::parser::{EExpr, ELambda, SyntaxError};
|
||||
use roc_parse::parser::{EClosure, EExpr, SyntaxError};
|
||||
use roc_repl_eval::eval::jit_to_ast;
|
||||
use roc_repl_eval::gen::{compile_to_mono, format_answer, ReplOutput};
|
||||
use roc_repl_eval::{ReplApp, ReplAppMemory};
|
||||
|
|
@ -136,7 +136,7 @@ impl Validator for InputValidator {
|
|||
// Special case some syntax errors to allow for multi-line inputs
|
||||
Err((_, EExpr::DefMissingFinalExpr(_), _))
|
||||
| Err((_, EExpr::DefMissingFinalExpr2(_, _), _))
|
||||
| Err((_, EExpr::Lambda(ELambda::Body(_, _), _), _)) => {
|
||||
| Err((_, EExpr::Closure(EClosure::Body(_, _), _), _)) => {
|
||||
Ok(ValidationResult::Incomplete)
|
||||
}
|
||||
_ => Ok(ValidationResult::Valid(None)),
|
||||
|
|
|
|||
|
|
@ -450,8 +450,8 @@ fn jit_to_ast_help<'a, A: ReplApp<'a>>(
|
|||
payload_vars,
|
||||
))
|
||||
}
|
||||
Content::Structure(FlatType::FunctionOrTagUnion(tag_name, _, _)) => {
|
||||
let tag_name = &env.subs[*tag_name];
|
||||
Content::Structure(FlatType::FunctionOrTagUnion(tag_names, _, _)) => {
|
||||
let tag_name = &env.subs.get_subs_slice(*tag_names)[0];
|
||||
|
||||
Ok(single_tag_union_to_ast(
|
||||
env,
|
||||
|
|
@ -631,8 +631,8 @@ fn addr_to_ast<'a, M: ReplAppMemory>(
|
|||
let (tag_name, payload_vars) = unpack_single_element_tag_union(env.subs, *tags);
|
||||
single_tag_union_to_ast(env, mem, addr, field_layouts, tag_name, payload_vars)
|
||||
}
|
||||
Content::Structure(FlatType::FunctionOrTagUnion(tag_name, _, _)) => {
|
||||
let tag_name = &env.subs[*tag_name];
|
||||
Content::Structure(FlatType::FunctionOrTagUnion(tag_names, _, _)) => {
|
||||
let tag_name = &env.subs.get_subs_slice(*tag_names)[0];
|
||||
single_tag_union_to_ast(env, mem, addr, field_layouts, tag_name, &[])
|
||||
}
|
||||
Content::Structure(FlatType::EmptyRecord) => {
|
||||
|
|
@ -1200,6 +1200,19 @@ fn bool_to_ast<'a, M: ReplAppMemory>(
|
|||
|
||||
tag_name_to_expr(env, tag_name)
|
||||
}
|
||||
FlatType::FunctionOrTagUnion(tags, _, _) if tags.len() == 2 => {
|
||||
let tags = env.subs.get_subs_slice(*tags);
|
||||
let tag_name_1 = &tags[0];
|
||||
let tag_name_2 = &tags[1];
|
||||
|
||||
let tag_name = if value {
|
||||
max_by_key(tag_name_1, tag_name_2, |n| n.as_ident_str())
|
||||
} else {
|
||||
min_by_key(tag_name_1, tag_name_2, |n| n.as_ident_str())
|
||||
};
|
||||
|
||||
tag_name_to_expr(env, tag_name)
|
||||
}
|
||||
other => {
|
||||
unreachable!("Unexpected FlatType {:?} in bool_to_ast", other);
|
||||
}
|
||||
|
|
@ -1293,6 +1306,37 @@ fn byte_to_ast<'a, M: ReplAppMemory>(
|
|||
_ => unreachable!("invalid union variant for a Byte!"),
|
||||
}
|
||||
}
|
||||
FlatType::FunctionOrTagUnion(tags, _, _) => {
|
||||
// anything with fewer tags is not a byte
|
||||
debug_assert!(tags.len() > 2);
|
||||
|
||||
let tags_vec: std::vec::Vec<(TagName, std::vec::Vec<Variable>)> = env
|
||||
.subs
|
||||
.get_subs_slice(*tags)
|
||||
.iter()
|
||||
.map(|t| (t.clone(), vec![]))
|
||||
.collect();
|
||||
|
||||
let union_variant = {
|
||||
let mut layout_env = layout::Env::from_components(
|
||||
&mut env.layout_cache,
|
||||
env.subs,
|
||||
env.arena,
|
||||
env.target_info,
|
||||
);
|
||||
union_sorted_tags_pub(&mut layout_env, tags_vec, None)
|
||||
};
|
||||
|
||||
match union_variant {
|
||||
UnionVariant::ByteUnion(tagnames) => {
|
||||
let tag_name = &tagnames[value as usize].expect_tag_ref();
|
||||
let tag_expr = tag_name_to_expr(env, tag_name);
|
||||
let loc_tag_expr = Loc::at_zero(tag_expr);
|
||||
Expr::Apply(env.arena.alloc(loc_tag_expr), &[], CalledVia::Space)
|
||||
}
|
||||
_ => unreachable!("invalid union variant for a Byte!"),
|
||||
}
|
||||
}
|
||||
other => {
|
||||
unreachable!("Unexpected FlatType {:?} in byte_to_ast", other);
|
||||
}
|
||||
|
|
|
|||
|
|
@ -178,7 +178,7 @@ fn to_expr_report<'a>(
|
|||
match parse_problem {
|
||||
EExpr::If(if_, pos) => to_if_report(alloc, lines, filename, context, if_, *pos),
|
||||
EExpr::When(when, pos) => to_when_report(alloc, lines, filename, context, when, *pos),
|
||||
EExpr::Lambda(lambda, pos) => {
|
||||
EExpr::Closure(lambda, pos) => {
|
||||
to_lambda_report(alloc, lines, filename, context, lambda, *pos)
|
||||
}
|
||||
EExpr::List(list, pos) => to_list_report(alloc, lines, filename, context, list, *pos),
|
||||
|
|
@ -557,13 +557,13 @@ fn to_lambda_report<'a>(
|
|||
lines: &LineInfo,
|
||||
filename: PathBuf,
|
||||
_context: Context,
|
||||
parse_problem: &roc_parse::parser::ELambda<'a>,
|
||||
parse_problem: &roc_parse::parser::EClosure<'a>,
|
||||
start: Position,
|
||||
) -> Report<'a> {
|
||||
use roc_parse::parser::ELambda;
|
||||
use roc_parse::parser::EClosure;
|
||||
|
||||
match *parse_problem {
|
||||
ELambda::Arrow(pos) => match what_is_next(alloc.src_lines, lines.convert_pos(pos)) {
|
||||
EClosure::Arrow(pos) => match what_is_next(alloc.src_lines, lines.convert_pos(pos)) {
|
||||
Next::Token("=>") => {
|
||||
let surroundings = Region::new(start, pos);
|
||||
let region = LineColumnRegion::from_pos(lines.convert_pos(pos));
|
||||
|
|
@ -610,7 +610,7 @@ fn to_lambda_report<'a>(
|
|||
}
|
||||
},
|
||||
|
||||
ELambda::Comma(pos) => match what_is_next(alloc.src_lines, lines.convert_pos(pos)) {
|
||||
EClosure::Comma(pos) => match what_is_next(alloc.src_lines, lines.convert_pos(pos)) {
|
||||
Next::Token("=>") => {
|
||||
let surroundings = Region::new(start, pos);
|
||||
let region = LineColumnRegion::from_pos(lines.convert_pos(pos));
|
||||
|
|
@ -657,7 +657,7 @@ fn to_lambda_report<'a>(
|
|||
}
|
||||
},
|
||||
|
||||
ELambda::Arg(pos) => match what_is_next(alloc.src_lines, lines.convert_pos(pos)) {
|
||||
EClosure::Arg(pos) => match what_is_next(alloc.src_lines, lines.convert_pos(pos)) {
|
||||
Next::Other(Some(',')) => {
|
||||
let surroundings = Region::new(start, pos);
|
||||
let region = LineColumnRegion::from_pos(lines.convert_pos(pos));
|
||||
|
|
@ -702,17 +702,17 @@ fn to_lambda_report<'a>(
|
|||
}
|
||||
},
|
||||
|
||||
ELambda::Start(_pos) => unreachable!("another branch would have been taken"),
|
||||
EClosure::Start(_pos) => unreachable!("another branch would have been taken"),
|
||||
|
||||
ELambda::Body(expr, pos) => {
|
||||
EClosure::Body(expr, pos) => {
|
||||
to_expr_report(alloc, lines, filename, Context::InDef(start), expr, pos)
|
||||
}
|
||||
ELambda::Pattern(ref pattern, pos) => {
|
||||
EClosure::Pattern(ref pattern, pos) => {
|
||||
to_pattern_report(alloc, lines, filename, pattern, pos)
|
||||
}
|
||||
ELambda::Space(error, pos) => to_space_report(alloc, lines, filename, &error, pos),
|
||||
EClosure::Space(error, pos) => to_space_report(alloc, lines, filename, &error, pos),
|
||||
|
||||
ELambda::IndentArrow(pos) => to_unfinished_lambda_report(
|
||||
EClosure::IndentArrow(pos) => to_unfinished_lambda_report(
|
||||
alloc,
|
||||
lines,
|
||||
filename,
|
||||
|
|
@ -725,7 +725,7 @@ fn to_lambda_report<'a>(
|
|||
]),
|
||||
),
|
||||
|
||||
ELambda::IndentBody(pos) => to_unfinished_lambda_report(
|
||||
EClosure::IndentBody(pos) => to_unfinished_lambda_report(
|
||||
alloc,
|
||||
lines,
|
||||
filename,
|
||||
|
|
@ -738,7 +738,7 @@ fn to_lambda_report<'a>(
|
|||
]),
|
||||
),
|
||||
|
||||
ELambda::IndentArg(pos) => to_unfinished_lambda_report(
|
||||
EClosure::IndentArg(pos) => to_unfinished_lambda_report(
|
||||
alloc,
|
||||
lines,
|
||||
filename,
|
||||
|
|
|
|||
|
|
@ -8,5 +8,5 @@ description = "Utilities for setting up tracing at various executable entry poin
|
|||
|
||||
[dependencies]
|
||||
tracing = { version = "0.1.36", features = ["release_max_level_off"] }
|
||||
tracing-subscriber = { version = "0.3.15", features = ["env-filter"] }
|
||||
tracing-subscriber = { version = "0.3.16", features = ["env-filter"] }
|
||||
tracing-appender = "0.2.2"
|
||||
|
|
|
|||
|
|
@ -10,7 +10,7 @@ main = Program.withArgs \args ->
|
|||
Arg.succeed (\dividend -> \divisor -> Div (Num.toF64 dividend) (Num.toF64 divisor))
|
||||
|> Arg.withParser
|
||||
(
|
||||
Arg.i64 {
|
||||
Arg.i64Option {
|
||||
long: "dividend",
|
||||
short: "n",
|
||||
help: "the number to divide; corresponds to a numerator",
|
||||
|
|
@ -18,7 +18,7 @@ main = Program.withArgs \args ->
|
|||
)
|
||||
|> Arg.withParser
|
||||
(
|
||||
Arg.i64 {
|
||||
Arg.i64Option {
|
||||
long: "divisor",
|
||||
short: "d",
|
||||
help: "the number to divide by; corresponds to a denominator",
|
||||
|
|
@ -30,7 +30,7 @@ main = Program.withArgs \args ->
|
|||
Arg.succeed (\base -> \num -> Log (Num.toF64 base) (Num.toF64 num))
|
||||
|> Arg.withParser
|
||||
(
|
||||
Arg.i64 {
|
||||
Arg.i64Option {
|
||||
long: "base",
|
||||
short: "b",
|
||||
help: "base of the logarithm",
|
||||
|
|
@ -38,7 +38,7 @@ main = Program.withArgs \args ->
|
|||
)
|
||||
|> Arg.withParser
|
||||
(
|
||||
Arg.i64 {
|
||||
Arg.i64Option {
|
||||
long: "num",
|
||||
help: "the number to take the logarithm of",
|
||||
}
|
||||
|
|
|
|||
|
|
@ -6,10 +6,10 @@ interface Arg
|
|||
toHelp,
|
||||
parseFormatted,
|
||||
succeed,
|
||||
bool,
|
||||
boolOption,
|
||||
strOption,
|
||||
i64Option,
|
||||
str,
|
||||
i64,
|
||||
positional,
|
||||
subCommand,
|
||||
choice,
|
||||
withParser,
|
||||
|
|
@ -32,7 +32,7 @@ NamedParser a := {
|
|||
## needs, consider transforming it into a [NamedParser].
|
||||
Parser a := [
|
||||
Succeed a,
|
||||
Arg ArgConfig (MarkedArgs -> Result { newlyTaken : Taken, val : a } (ParseError [])),
|
||||
Option OptionConfig (MarkedArgs -> Result { newlyTaken : Taken, val : a } (ParseError [])),
|
||||
Positional PositionalConfig (MarkedArgs -> Result { newlyTaken : Taken, val : a } (ParseError [])),
|
||||
# TODO: hiding the record behind an alias currently causes a panic
|
||||
SubCommand
|
||||
|
|
@ -59,15 +59,15 @@ MarkedArgs : { args : List Str, taken : Taken }
|
|||
ParseError a : [
|
||||
## The program name was not found as the first argument to be parsed.
|
||||
ProgramNameNotProvided Str,
|
||||
## An argument is required, but it was not found.
|
||||
MissingRequiredArg Str,
|
||||
## A positional argument is required, but it was not found.
|
||||
MissingPositionalArg Str,
|
||||
## An argument was found, but it didn't have the expected [Type].
|
||||
WrongType
|
||||
## A positional argument (inherently required) was not found.
|
||||
MissingPositional Str,
|
||||
## An option argument is required, but it was not found.
|
||||
MissingRequiredOption Str,
|
||||
## An argument was found, but it didn't have the expected [OptionType].
|
||||
WrongOptionType
|
||||
{
|
||||
arg : Str,
|
||||
expected : Type,
|
||||
expected : OptionType,
|
||||
},
|
||||
## A subcommand is required, but it was not found.
|
||||
SubCommandNotFound
|
||||
|
|
@ -82,9 +82,9 @@ ParseError a : [
|
|||
},
|
||||
]a
|
||||
|
||||
## Expected type of an argument, in an argument list being parsed.
|
||||
## Describes how a string argument should be interpreted as a certain type.
|
||||
Type : [
|
||||
## Expected type of an option, in an argument list being parsed.
|
||||
## Describes how a string option should be interpreted as a certain type.
|
||||
OptionType : [
|
||||
Str,
|
||||
Bool,
|
||||
I64,
|
||||
|
|
@ -96,11 +96,11 @@ Help : [
|
|||
Config (List Config),
|
||||
]
|
||||
|
||||
ArgConfig : {
|
||||
OptionConfig : {
|
||||
long : Str,
|
||||
short : Str,
|
||||
help : Str,
|
||||
type : Type,
|
||||
type : OptionType,
|
||||
}
|
||||
|
||||
PositionalConfig : {
|
||||
|
|
@ -108,7 +108,7 @@ PositionalConfig : {
|
|||
help : Str,
|
||||
}
|
||||
|
||||
Config : [Arg ArgConfig, Positional PositionalConfig]
|
||||
Config : [Option OptionConfig, Positional PositionalConfig]
|
||||
|
||||
## Generates help metadata from a [Parser].
|
||||
##
|
||||
|
|
@ -133,8 +133,8 @@ toHelpHelper = \@Parser parser, configs ->
|
|||
WithConfig innerParser config ->
|
||||
toHelpHelper innerParser (List.append configs config)
|
||||
|
||||
Arg config _ ->
|
||||
List.append configs (Arg config)
|
||||
Option config _ ->
|
||||
List.append configs (Option config)
|
||||
|> Config
|
||||
|
||||
SubCommand commands ->
|
||||
|
|
@ -165,7 +165,7 @@ findOneArg = \long, short, { args, taken } ->
|
|||
if !found then
|
||||
Err NotFound
|
||||
else
|
||||
# Return the next arg after the given one
|
||||
# Return the next argument after the given one
|
||||
List.get args (argIndex + 1)
|
||||
|> Result.mapErr (\_ -> NotFound)
|
||||
|> Result.map
|
||||
|
|
@ -194,8 +194,8 @@ andMap = \@Parser parser, @Parser mapper ->
|
|||
|> andMap (@Parser mapper)
|
||||
|> WithConfig config
|
||||
|
||||
Arg config run ->
|
||||
Arg config \args ->
|
||||
Option config run ->
|
||||
Option config \args ->
|
||||
run args
|
||||
|> Result.map (\{ val, newlyTaken } -> { val: fn val, newlyTaken })
|
||||
|
||||
|
|
@ -211,16 +211,16 @@ andMap = \@Parser parser, @Parser mapper ->
|
|||
List.map cmds mapSubParser
|
||||
|> SubCommand
|
||||
|
||||
Arg config run ->
|
||||
Option config run ->
|
||||
when parser is
|
||||
Succeed a ->
|
||||
Arg config \args ->
|
||||
Option config \args ->
|
||||
when run args is
|
||||
Ok { val: fn, newlyTaken } -> Ok { val: fn a, newlyTaken }
|
||||
Err err -> Err err
|
||||
|
||||
Lazy thunk ->
|
||||
Arg config \args ->
|
||||
Option config \args ->
|
||||
when run args is
|
||||
Ok { val: fn, newlyTaken } -> Ok { val: fn (thunk {}), newlyTaken }
|
||||
Err err -> Err err
|
||||
|
|
@ -230,9 +230,9 @@ andMap = \@Parser parser, @Parser mapper ->
|
|||
|> andMap (@Parser mapper)
|
||||
|> WithConfig config2
|
||||
|
||||
Arg config2 run2 ->
|
||||
Option config2 run2 ->
|
||||
# Parse first the one and then the other.
|
||||
combinedParser = Arg config2 \args ->
|
||||
combinedParser = Option config2 \args ->
|
||||
when run args is
|
||||
Ok { val: fn, newlyTaken } ->
|
||||
run2 (updateTaken args newlyTaken)
|
||||
|
|
@ -242,7 +242,7 @@ andMap = \@Parser parser, @Parser mapper ->
|
|||
|
||||
# Store the extra config.
|
||||
@Parser combinedParser
|
||||
|> WithConfig (Arg config)
|
||||
|> WithConfig (Option config)
|
||||
|
||||
Positional config2 run2 ->
|
||||
combinedParser = Positional config2 \args ->
|
||||
|
|
@ -255,7 +255,7 @@ andMap = \@Parser parser, @Parser mapper ->
|
|||
|
||||
# Store the extra config.
|
||||
@Parser combinedParser
|
||||
|> WithConfig (Arg config)
|
||||
|> WithConfig (Option config)
|
||||
|
||||
SubCommand cmds ->
|
||||
# For each subcommand, first run the subcommand, then
|
||||
|
|
@ -285,9 +285,9 @@ andMap = \@Parser parser, @Parser mapper ->
|
|||
|> andMap (@Parser mapper)
|
||||
|> WithConfig config2
|
||||
|
||||
Arg config2 run2 ->
|
||||
Option config2 run2 ->
|
||||
# Parse first the one and then the other.
|
||||
combinedParser = Arg config2 \args ->
|
||||
combinedParser = Option config2 \args ->
|
||||
when run args is
|
||||
Ok { val: fn, newlyTaken } ->
|
||||
run2 (updateTaken args newlyTaken)
|
||||
|
|
@ -336,8 +336,8 @@ andMap = \@Parser parser, @Parser mapper ->
|
|||
|> andMap (@Parser mapper)
|
||||
|> WithConfig config
|
||||
|
||||
Arg config run ->
|
||||
Arg config \args ->
|
||||
Option config run ->
|
||||
Option config \args ->
|
||||
run args
|
||||
|> Result.map (\{ val, newlyTaken } -> { val: fn val, newlyTaken })
|
||||
|
||||
|
|
@ -385,7 +385,7 @@ program = \parser, { name, help ? "" } ->
|
|||
# TODO panics in alias analysis when this annotation is included
|
||||
# parse : NamedParser a, List Str -> Result a (ParseError*)
|
||||
parse = \@NamedParser parser, args ->
|
||||
# By convention the first string in the arg list is the program name.
|
||||
# By convention the first string in the argument list is the program name.
|
||||
if
|
||||
List.isEmpty args
|
||||
then
|
||||
|
|
@ -399,7 +399,7 @@ parseHelp : Parser a, MarkedArgs -> Result a (ParseError [])
|
|||
parseHelp = \@Parser parser, args ->
|
||||
when parser is
|
||||
Succeed val -> Ok val
|
||||
Arg _ run ->
|
||||
Option _ run ->
|
||||
run args
|
||||
|> Result.map .val
|
||||
|
||||
|
|
@ -444,51 +444,51 @@ nextUnmarked = \marked ->
|
|||
|
||||
help 0
|
||||
|
||||
## Creates a parser for a boolean flag argument.
|
||||
## Flags of value "true" and "false" will be parsed as [Bool.true] and [Bool.false], respectively.
|
||||
## All other values will result in a `WrongType` error.
|
||||
bool : _ -> Parser Bool # TODO: panics if parameter annotation given
|
||||
bool = \{ long, short ? "", help ? "" } ->
|
||||
## Creates a parser for a boolean option argument.
|
||||
## Options of value "true" and "false" will be parsed as [Bool.true] and [Bool.false], respectively.
|
||||
## All other values will result in a `WrongOptionType` error.
|
||||
boolOption : _ -> Parser Bool # TODO: panics if parameter annotation given
|
||||
boolOption = \{ long, short ? "", help ? "" } ->
|
||||
fn = \args ->
|
||||
when findOneArg long short args is
|
||||
Err NotFound -> Err (MissingRequiredArg long)
|
||||
Err NotFound -> Err (MissingRequiredOption long)
|
||||
Ok { val, newlyTaken } ->
|
||||
when val is
|
||||
"true" -> Ok { val: Bool.true, newlyTaken }
|
||||
"false" -> Ok { val: Bool.false, newlyTaken }
|
||||
_ -> Err (WrongType { arg: long, expected: Bool })
|
||||
_ -> Err (WrongOptionType { arg: long, expected: Bool })
|
||||
|
||||
@Parser (Arg { long, short, help, type: Bool } fn)
|
||||
@Parser (Option { long, short, help, type: Bool } fn)
|
||||
|
||||
## Creates a parser for a string flag argument.
|
||||
str : _ -> Parser Str # TODO: panics if parameter annotation given
|
||||
str = \{ long, short ? "", help ? "" } ->
|
||||
## Creates a parser for a string option argument.
|
||||
strOption : _ -> Parser Str # TODO: panics if parameter annotation given
|
||||
strOption = \{ long, short ? "", help ? "" } ->
|
||||
fn = \args ->
|
||||
when findOneArg long short args is
|
||||
Err NotFound -> Err (MissingRequiredArg long)
|
||||
Err NotFound -> Err (MissingRequiredOption long)
|
||||
Ok { val, newlyTaken } -> Ok { val, newlyTaken }
|
||||
|
||||
@Parser (Arg { long, short, help, type: Str } fn)
|
||||
@Parser (Option { long, short, help, type: Str } fn)
|
||||
|
||||
## Creates a parser for a 64-bit signed integer ([I64]).
|
||||
i64 : _ -> Parser I64 # TODO: panics if parameter annotation given
|
||||
i64 = \{ long, short ? "", help ? "" } ->
|
||||
## Creates a parser for a 64-bit signed integer ([I64]) option argument.
|
||||
i64Option : _ -> Parser I64 # TODO: panics if parameter annotation given
|
||||
i64Option = \{ long, short ? "", help ? "" } ->
|
||||
fn = \args ->
|
||||
when findOneArg long short args is
|
||||
Err NotFound -> Err (MissingRequiredArg long)
|
||||
Err NotFound -> Err (MissingRequiredOption long)
|
||||
Ok { val, newlyTaken } ->
|
||||
Str.toI64 val
|
||||
|> Result.mapErr (\_ -> WrongType { arg: long, expected: I64 })
|
||||
|> Result.mapErr (\_ -> WrongOptionType { arg: long, expected: I64 })
|
||||
|> Result.map (\v -> { val: v, newlyTaken })
|
||||
|
||||
@Parser (Arg { long, short, help, type: I64 } fn)
|
||||
@Parser (Option { long, short, help, type: I64 } fn)
|
||||
|
||||
## Parses a single positional argument as a string.
|
||||
positional : _ -> Parser Str
|
||||
positional = \{ name, help ? "" } ->
|
||||
str : _ -> Parser Str
|
||||
str = \{ name, help ? "" } ->
|
||||
fn = \args ->
|
||||
nextUnmarked args
|
||||
|> Result.mapErr (\OutOfBounds -> MissingPositionalArg name)
|
||||
|> Result.mapErr (\OutOfBounds -> MissingPositional name)
|
||||
|> Result.map (\{ val, index } -> { val, newlyTaken: Set.insert args.taken index })
|
||||
|
||||
@Parser (Positional { name, help } fn)
|
||||
|
|
@ -573,12 +573,12 @@ formatHelpHelp = \n, cmdHelp ->
|
|||
"""
|
||||
|
||||
Config configs ->
|
||||
argConfigs =
|
||||
optionConfigs =
|
||||
filterMap
|
||||
configs
|
||||
(\config ->
|
||||
when config is
|
||||
Arg c -> Some c
|
||||
Option c -> Some c
|
||||
_ -> None)
|
||||
|
||||
positionalConfigs =
|
||||
|
|
@ -589,13 +589,13 @@ formatHelpHelp = \n, cmdHelp ->
|
|||
Positional c -> Some c
|
||||
_ -> None)
|
||||
|
||||
fmtArgsHelp =
|
||||
if List.isEmpty argConfigs then
|
||||
fmtOptionsHelp =
|
||||
if List.isEmpty optionConfigs then
|
||||
""
|
||||
else
|
||||
helpStr =
|
||||
argConfigs
|
||||
|> List.map (\c -> formatArgConfig (n + indentLevel) c)
|
||||
optionConfigs
|
||||
|> List.map (\c -> formatOptionConfig (n + indentLevel) c)
|
||||
|> Str.joinWith "\n"
|
||||
|
||||
"""
|
||||
|
|
@ -615,11 +615,11 @@ formatHelpHelp = \n, cmdHelp ->
|
|||
|
||||
"""
|
||||
|
||||
\(indented)POSITIONAL ARGUMENTS:
|
||||
\(indented)ARGS:
|
||||
\(helpStr)
|
||||
"""
|
||||
|
||||
Str.concat fmtArgsHelp fmtPositionalsHelp
|
||||
Str.concat fmtPositionalsHelp fmtOptionsHelp
|
||||
|
||||
formatSubCommand = \n, { name, help } ->
|
||||
indented = indent n
|
||||
|
|
@ -628,14 +628,14 @@ formatSubCommand = \n, { name, help } ->
|
|||
|
||||
"\(indented)\(name)\(fmtHelp)"
|
||||
|
||||
formatArgConfig : Nat, ArgConfig -> Str
|
||||
formatArgConfig = \n, { long, short, help, type } ->
|
||||
formatOptionConfig : Nat, OptionConfig -> Str
|
||||
formatOptionConfig = \n, { long, short, help, type } ->
|
||||
indented = indent n
|
||||
|
||||
formattedShort =
|
||||
mapNonEmptyStr short \s -> ", -\(s)"
|
||||
|
||||
formattedType = formatType type
|
||||
formattedType = formatOptionType type
|
||||
|
||||
formattedHelp =
|
||||
mapNonEmptyStr help \h -> " \(h)"
|
||||
|
|
@ -651,12 +651,12 @@ formatPositionalConfig = \n, { name, help } ->
|
|||
|
||||
"\(indented)\(name)\(formattedHelp)"
|
||||
|
||||
formatType : Type -> Str
|
||||
formatType = \type ->
|
||||
formatOptionType : OptionType -> Str
|
||||
formatOptionType = \type ->
|
||||
when type is
|
||||
Bool -> "bool"
|
||||
Bool -> "boolean"
|
||||
Str -> "string"
|
||||
I64 -> "i64"
|
||||
I64 -> "integer, 64-bit signed"
|
||||
|
||||
quote = \s -> "\"\(s)\""
|
||||
|
||||
|
|
@ -664,18 +664,18 @@ formatError : ParseError [] -> Str
|
|||
formatError = \err ->
|
||||
when err is
|
||||
ProgramNameNotProvided programName ->
|
||||
"The program name \"\(programName)\" was not probided as a first argument!"
|
||||
"The program name \"\(programName)\" was not provided as a first argument!"
|
||||
|
||||
MissingRequiredArg arg ->
|
||||
"Argument `--\(arg)` is required but was not provided!"
|
||||
MissingPositional arg ->
|
||||
"The argument `\(arg)` is required but was not provided!"
|
||||
|
||||
MissingPositionalArg arg ->
|
||||
"A positional argument for `\(arg)` is required but was not provided!"
|
||||
MissingRequiredOption arg ->
|
||||
"The option `--\(arg)` is required but was not provided!"
|
||||
|
||||
WrongType { arg, expected } ->
|
||||
formattedType = formatType expected
|
||||
WrongOptionType { arg, expected } ->
|
||||
formattedType = formatOptionType expected
|
||||
|
||||
"The argument `--\(arg)` expects a value of type \(formattedType)!"
|
||||
"The option `--\(arg)` expects a value of type \(formattedType)!"
|
||||
|
||||
SubCommandNotFound { choices } ->
|
||||
fmtChoices =
|
||||
|
|
@ -708,117 +708,117 @@ formatError = \err ->
|
|||
## the result of `parser` to `mapper`.
|
||||
##
|
||||
## This provides a way to chain the results of multiple parsers together. For
|
||||
## example, to combine the results of two [str] arguments into a record, you
|
||||
## could use
|
||||
## example, to combine the results of two [strOption] arguments into a record,
|
||||
## you could use
|
||||
##
|
||||
## ```
|
||||
## succeed (\host -> \port -> { host, port })
|
||||
## |> withParser (str { long: "host" })
|
||||
## |> withParser (str { long: "port" })
|
||||
## |> withParser (strOption { long: "host" })
|
||||
## |> withParser (strOption { long: "port" })
|
||||
## ```
|
||||
withParser = \arg1, arg2 -> andMap arg2 arg1
|
||||
|
||||
mark = \args -> { args, taken: Set.empty }
|
||||
|
||||
# bool undashed long argument is missing
|
||||
# boolean undashed long optional is missing
|
||||
expect
|
||||
parser = bool { long: "foo" }
|
||||
parser = boolOption { long: "foo" }
|
||||
|
||||
parseHelp parser (mark ["foo"]) == Err (MissingRequiredArg "foo")
|
||||
parseHelp parser (mark ["foo"]) == Err (MissingRequiredOption "foo")
|
||||
|
||||
# bool dashed long argument without value is missing
|
||||
# boolean dashed long optional without value is missing
|
||||
expect
|
||||
parser = bool { long: "foo" }
|
||||
parser = boolOption { long: "foo" }
|
||||
|
||||
parseHelp parser (mark ["--foo"]) == Err (MissingRequiredArg "foo")
|
||||
parseHelp parser (mark ["--foo"]) == Err (MissingRequiredOption "foo")
|
||||
|
||||
# bool dashed long argument with value is determined true
|
||||
# boolean dashed long optional with value is determined true
|
||||
expect
|
||||
parser = bool { long: "foo" }
|
||||
parser = boolOption { long: "foo" }
|
||||
|
||||
parseHelp parser (mark ["--foo", "true"]) == Ok Bool.true
|
||||
|
||||
# bool dashed long argument with value is determined false
|
||||
# boolean dashed long optional with value is determined false
|
||||
expect
|
||||
parser = bool { long: "foo" }
|
||||
parser = boolOption { long: "foo" }
|
||||
|
||||
parseHelp parser (mark ["--foo", "false"]) == Ok Bool.false
|
||||
|
||||
# bool dashed long argument with value is determined wrong type
|
||||
# boolean dashed long optional with value is determined wrong type
|
||||
expect
|
||||
parser = bool { long: "foo" }
|
||||
parser = boolOption { long: "foo" }
|
||||
|
||||
parseHelp parser (mark ["--foo", "not-a-bool"]) == Err (WrongType { arg: "foo", expected: Bool })
|
||||
parseHelp parser (mark ["--foo", "not-a-boolean"]) == Err (WrongOptionType { arg: "foo", expected: Bool })
|
||||
|
||||
# bool dashed short argument with value is determined true
|
||||
# boolean dashed short optional with value is determined true
|
||||
expect
|
||||
parser = bool { long: "foo", short: "F" }
|
||||
parser = boolOption { long: "foo", short: "F" }
|
||||
|
||||
parseHelp parser (mark ["-F", "true"]) == Ok Bool.true
|
||||
|
||||
# bool dashed short argument with value is determined false
|
||||
# boolean dashed short optional with value is determined false
|
||||
expect
|
||||
parser = bool { long: "foo", short: "F" }
|
||||
parser = boolOption { long: "foo", short: "F" }
|
||||
|
||||
parseHelp parser (mark ["-F", "false"]) == Ok Bool.false
|
||||
|
||||
# bool dashed short argument with value is determined wrong type
|
||||
# boolean dashed short optional with value is determined wrong type
|
||||
expect
|
||||
parser = bool { long: "foo", short: "F" }
|
||||
parser = boolOption { long: "foo", short: "F" }
|
||||
|
||||
parseHelp parser (mark ["-F", "not-a-bool"]) == Err (WrongType { arg: "foo", expected: Bool })
|
||||
parseHelp parser (mark ["-F", "not-a-boolean"]) == Err (WrongOptionType { arg: "foo", expected: Bool })
|
||||
|
||||
# string dashed long argument without value is missing
|
||||
# string dashed long option without value is missing
|
||||
expect
|
||||
parser = str { long: "foo" }
|
||||
parser = strOption { long: "foo" }
|
||||
|
||||
parseHelp parser (mark ["--foo"]) == Err (MissingRequiredArg "foo")
|
||||
parseHelp parser (mark ["--foo"]) == Err (MissingRequiredOption "foo")
|
||||
|
||||
# string dashed long argument with value is determined
|
||||
# string dashed long option with value is determined
|
||||
expect
|
||||
parser = str { long: "foo" }
|
||||
parser = strOption { long: "foo" }
|
||||
|
||||
parseHelp parser (mark ["--foo", "itsme"]) == Ok "itsme"
|
||||
|
||||
# string dashed short argument without value is missing
|
||||
# string dashed short option without value is missing
|
||||
expect
|
||||
parser = str { long: "foo", short: "F" }
|
||||
parser = strOption { long: "foo", short: "F" }
|
||||
|
||||
parseHelp parser (mark ["-F"]) == Err (MissingRequiredArg "foo")
|
||||
parseHelp parser (mark ["-F"]) == Err (MissingRequiredOption "foo")
|
||||
|
||||
# string dashed short argument with value is determined
|
||||
# string dashed short option with value is determined
|
||||
expect
|
||||
parser = str { long: "foo", short: "F" }
|
||||
parser = strOption { long: "foo", short: "F" }
|
||||
|
||||
parseHelp parser (mark ["-F", "itsme"]) == Ok "itsme"
|
||||
|
||||
# i64 dashed long argument without value is missing
|
||||
# i64 dashed long option without value is missing
|
||||
expect
|
||||
parser = i64 { long: "foo" }
|
||||
parser = i64Option { long: "foo" }
|
||||
|
||||
parseHelp parser (mark ["--foo"]) == Err (MissingRequiredArg "foo")
|
||||
parseHelp parser (mark ["--foo"]) == Err (MissingRequiredOption "foo")
|
||||
|
||||
# i64 dashed long argument with value is determined positive
|
||||
# i64 dashed long option with value is determined positive
|
||||
expect
|
||||
parser = i64 { long: "foo" }
|
||||
parser = i64Option { long: "foo" }
|
||||
|
||||
parseHelp parser (mark ["--foo", "1234"]) == Ok 1234
|
||||
|
||||
# i64 dashed long argument with value is determined negative
|
||||
# i64 dashed long option with value is determined negative
|
||||
expect
|
||||
parser = i64 { long: "foo" }
|
||||
parser = i64Option { long: "foo" }
|
||||
|
||||
parseHelp parser (mark ["--foo", "-1234"]) == Ok -1234
|
||||
|
||||
# i64 dashed short argument without value is missing
|
||||
# i64 dashed short option without value is missing
|
||||
expect
|
||||
parser = i64 { long: "foo", short: "F" }
|
||||
parser = i64Option { long: "foo", short: "F" }
|
||||
|
||||
parseHelp parser (mark ["-F"]) == Err (MissingRequiredArg "foo")
|
||||
parseHelp parser (mark ["-F"]) == Err (MissingRequiredOption "foo")
|
||||
|
||||
# i64 dashed short argument with value is determined
|
||||
# i64 dashed short option with value is determined
|
||||
expect
|
||||
parser = i64 { long: "foo", short: "F" }
|
||||
parser = i64Option { long: "foo", short: "F" }
|
||||
|
||||
parseHelp parser (mark ["-F", "1234"]) == Ok 1234
|
||||
|
||||
|
|
@ -826,8 +826,8 @@ expect
|
|||
expect
|
||||
parser =
|
||||
succeed (\foo -> \bar -> "foo: \(foo) bar: \(bar)")
|
||||
|> withParser (str { long: "foo" })
|
||||
|> withParser (str { long: "bar" })
|
||||
|> withParser (strOption { long: "foo" })
|
||||
|> withParser (strOption { long: "bar" })
|
||||
|
||||
cases = [
|
||||
["--foo", "true", "--bar", "baz"],
|
||||
|
|
@ -841,61 +841,61 @@ expect
|
|||
expect
|
||||
parser =
|
||||
succeed (\foo -> \bar -> "foo: \(foo) bar: \(bar)")
|
||||
|> withParser (str { long: "foo" })
|
||||
|> withParser (str { long: "bar" })
|
||||
|> withParser (strOption { long: "foo" })
|
||||
|> withParser (strOption { long: "bar" })
|
||||
|
||||
List.all
|
||||
[
|
||||
parseHelp parser (mark ["--foo", "zaz"]) == Err (MissingRequiredArg "bar"),
|
||||
parseHelp parser (mark ["--bar", "zaz"]) == Err (MissingRequiredArg "foo"),
|
||||
parseHelp parser (mark ["--foo", "zaz"]) == Err (MissingRequiredOption "bar"),
|
||||
parseHelp parser (mark ["--bar", "zaz"]) == Err (MissingRequiredOption "foo"),
|
||||
]
|
||||
(\b -> b)
|
||||
|
||||
# string and bool parsers build help
|
||||
# string and boolean parsers build help
|
||||
expect
|
||||
parser =
|
||||
succeed (\foo -> \bar -> \_bool -> "foo: \(foo) bar: \(bar)")
|
||||
|> withParser (str { long: "foo", help: "the foo flag" })
|
||||
|> withParser (str { long: "bar", short: "B" })
|
||||
|> withParser (bool { long: "bool" })
|
||||
|> withParser (strOption { long: "foo", help: "the foo option" })
|
||||
|> withParser (strOption { long: "bar", short: "B" })
|
||||
|> withParser (boolOption { long: "boolean" })
|
||||
|
||||
toHelp parser
|
||||
== Config [
|
||||
Arg { long: "foo", short: "", help: "the foo flag", type: Str },
|
||||
Arg { long: "bar", short: "B", help: "", type: Str },
|
||||
Arg { long: "bool", short: "", help: "", type: Bool },
|
||||
Option { long: "foo", short: "", help: "the foo option", type: Str },
|
||||
Option { long: "bar", short: "B", help: "", type: Str },
|
||||
Option { long: "boolean", short: "", help: "", type: Bool },
|
||||
]
|
||||
|
||||
# format argument is missing
|
||||
# format option is missing
|
||||
expect
|
||||
parser = bool { long: "foo" }
|
||||
parser = boolOption { long: "foo" }
|
||||
|
||||
when parseHelp parser (mark ["foo"]) is
|
||||
Ok _ -> Bool.false
|
||||
Err e ->
|
||||
err = formatError e
|
||||
|
||||
err == "Argument `--foo` is required but was not provided!"
|
||||
err == "The option `--foo` is required but was not provided!"
|
||||
|
||||
# format argument has wrong type
|
||||
# format option has wrong type
|
||||
expect
|
||||
parser = bool { long: "foo" }
|
||||
parser = boolOption { long: "foo" }
|
||||
|
||||
when parseHelp parser (mark ["--foo", "12"]) is
|
||||
Ok _ -> Bool.false
|
||||
Err e ->
|
||||
err = formatError e
|
||||
|
||||
err == "The argument `--foo` expects a value of type bool!"
|
||||
err == "The option `--foo` expects a value of type boolean!"
|
||||
|
||||
# format help menu with only args
|
||||
# format help menu with only options
|
||||
expect
|
||||
parser =
|
||||
succeed (\_foo -> \_bar -> \_baz -> \_bool -> "")
|
||||
|> withParser (str { long: "foo", help: "the foo flag" })
|
||||
|> withParser (str { long: "bar", short: "B" })
|
||||
|> withParser (str { long: "baz", short: "z", help: "the baz flag" })
|
||||
|> withParser (bool { long: "bool" })
|
||||
|> withParser (strOption { long: "foo", help: "the foo option" })
|
||||
|> withParser (strOption { long: "bar", short: "B" })
|
||||
|> withParser (strOption { long: "baz", short: "z", help: "the baz option" })
|
||||
|> withParser (boolOption { long: "boolean" })
|
||||
|> program { name: "test" }
|
||||
|
||||
formatHelp parser
|
||||
|
|
@ -904,10 +904,10 @@ expect
|
|||
test
|
||||
|
||||
OPTIONS:
|
||||
--foo the foo flag (string)
|
||||
--foo the foo option (string)
|
||||
--bar, -B (string)
|
||||
--baz, -z the baz flag (string)
|
||||
--bool (bool)
|
||||
--baz, -z the baz option (string)
|
||||
--boolean (boolean)
|
||||
"""
|
||||
|
||||
# format help menu with subcommands
|
||||
|
|
@ -915,12 +915,12 @@ expect
|
|||
parser =
|
||||
choice [
|
||||
succeed (\user -> \pw -> "\(user)\(pw)")
|
||||
|> withParser (str { long: "user" })
|
||||
|> withParser (str { long: "pw" })
|
||||
|> withParser (strOption { long: "user" })
|
||||
|> withParser (strOption { long: "pw" })
|
||||
|> subCommand "login",
|
||||
succeed (\file -> \url -> "\(file)\(url)")
|
||||
|> withParser (str { long: "file" })
|
||||
|> withParser (str { long: "url" })
|
||||
|> withParser (strOption { long: "file" })
|
||||
|> withParser (strOption { long: "url" })
|
||||
|> subCommand "publish",
|
||||
]
|
||||
|> program { name: "test" }
|
||||
|
|
@ -963,12 +963,12 @@ expect
|
|||
parser =
|
||||
choice [
|
||||
succeed (\user -> \pw -> "logging in \(user) with \(pw)")
|
||||
|> withParser (str { long: "user" })
|
||||
|> withParser (str { long: "pw" })
|
||||
|> withParser (strOption { long: "user" })
|
||||
|> withParser (strOption { long: "pw" })
|
||||
|> subCommand "login",
|
||||
succeed (\file -> \url -> "\(file)\(url)")
|
||||
|> withParser (str { long: "file" })
|
||||
|> withParser (str { long: "url" })
|
||||
|> withParser (strOption { long: "file" })
|
||||
|> withParser (strOption { long: "url" })
|
||||
|> subCommand "publish",
|
||||
]
|
||||
|> program { name: "test" }
|
||||
|
|
@ -983,8 +983,8 @@ expect
|
|||
choice [
|
||||
choice [
|
||||
succeed (\user -> \pw -> "logging in \(user) with \(pw)")
|
||||
|> withParser (str { long: "user" })
|
||||
|> withParser (str { long: "pw" })
|
||||
|> withParser (strOption { long: "user" })
|
||||
|> withParser (strOption { long: "pw" })
|
||||
|> subCommand "login",
|
||||
]
|
||||
|> subCommand "auth",
|
||||
|
|
@ -1031,18 +1031,18 @@ expect
|
|||
\t"auth", "publish"
|
||||
"""
|
||||
|
||||
# parse positional argument
|
||||
# parse positional
|
||||
expect
|
||||
parser = positional { name: "foo" }
|
||||
parser = str { name: "foo" }
|
||||
|
||||
parseHelp parser (mark ["myArg"]) == Ok "myArg"
|
||||
|
||||
# parse positional argument with argument flag
|
||||
# parse positional with option
|
||||
expect
|
||||
parser =
|
||||
succeed (\foo -> \bar -> "foo: \(foo), bar: \(bar)")
|
||||
|> withParser (str { long: "foo" })
|
||||
|> withParser (positional { name: "bar" })
|
||||
|> withParser (strOption { long: "foo" })
|
||||
|> withParser (str { name: "bar" })
|
||||
|
||||
cases = [
|
||||
["--foo", "true", "baz"],
|
||||
|
|
@ -1051,17 +1051,17 @@ expect
|
|||
|
||||
List.all cases \args -> parseHelp parser (mark args) == Ok "foo: true, bar: baz"
|
||||
|
||||
# parse positional argument with subcommand
|
||||
# parse positional with subcommand
|
||||
expect
|
||||
parser = choice [
|
||||
positional { name: "bar" }
|
||||
str { name: "bar" }
|
||||
|> subCommand "hello",
|
||||
]
|
||||
|
||||
parseHelp parser (mark ["hello", "foo"]) == Ok "foo"
|
||||
|
||||
# missing positional argument
|
||||
# missing positional
|
||||
expect
|
||||
parser = positional { name: "bar" }
|
||||
parser = str { name: "bar" }
|
||||
|
||||
parseHelp parser (mark []) == Err (MissingPositionalArg "bar")
|
||||
parseHelp parser (mark []) == Err (MissingPositional "bar")
|
||||
|
|
|
|||
249
examples/cli/cli-platform/Cargo.lock
generated
249
examples/cli/cli-platform/Cargo.lock
generated
|
|
@ -2,6 +2,21 @@
|
|||
# It is not intended for manual editing.
|
||||
version = 3
|
||||
|
||||
[[package]]
|
||||
name = "addr2line"
|
||||
version = "0.17.0"
|
||||
source = "registry+https://github.com/rust-lang/crates.io-index"
|
||||
checksum = "b9ecd88a8c8378ca913a680cd98f0f13ac67383d35993f86c90a70e3f137816b"
|
||||
dependencies = [
|
||||
"gimli",
|
||||
]
|
||||
|
||||
[[package]]
|
||||
name = "adler"
|
||||
version = "1.0.2"
|
||||
source = "registry+https://github.com/rust-lang/crates.io-index"
|
||||
checksum = "f26201604c87b1e01bd3d98f8d5d9a8fcbb815e8cedb41ffccbeb4bf593a35fe"
|
||||
|
||||
[[package]]
|
||||
name = "arrayvec"
|
||||
version = "0.7.2"
|
||||
|
|
@ -14,6 +29,21 @@ version = "1.1.0"
|
|||
source = "registry+https://github.com/rust-lang/crates.io-index"
|
||||
checksum = "d468802bab17cbc0cc575e9b053f41e72aa36bfa6b7f55e3529ffa43161b97fa"
|
||||
|
||||
[[package]]
|
||||
name = "backtrace"
|
||||
version = "0.3.66"
|
||||
source = "registry+https://github.com/rust-lang/crates.io-index"
|
||||
checksum = "cab84319d616cfb654d03394f38ab7e6f0919e181b1b57e1fd15e7fb4077d9a7"
|
||||
dependencies = [
|
||||
"addr2line",
|
||||
"cc",
|
||||
"cfg-if",
|
||||
"libc",
|
||||
"miniz_oxide",
|
||||
"object",
|
||||
"rustc-demangle",
|
||||
]
|
||||
|
||||
[[package]]
|
||||
name = "base64"
|
||||
version = "0.13.0"
|
||||
|
|
@ -22,15 +52,15 @@ checksum = "904dfeac50f3cdaba28fc6f57fdcddb75f49ed61346676a78c4ffe55877802fd"
|
|||
|
||||
[[package]]
|
||||
name = "bumpalo"
|
||||
version = "3.10.0"
|
||||
version = "3.11.0"
|
||||
source = "registry+https://github.com/rust-lang/crates.io-index"
|
||||
checksum = "37ccbd214614c6783386c1af30caf03192f17891059cecc394b4fb119e363de3"
|
||||
checksum = "c1ad822118d20d2c234f427000d5acc36eabe1e29a348c89b63dd60b13f28e5d"
|
||||
|
||||
[[package]]
|
||||
name = "bytes"
|
||||
version = "1.2.0"
|
||||
version = "1.2.1"
|
||||
source = "registry+https://github.com/rust-lang/crates.io-index"
|
||||
checksum = "f0b3de4a0c5e67e16066a0715723abd91edc2f9001d09c46e1dca929351e130e"
|
||||
checksum = "ec8a7b6a70fde80372154c65702f00a0f56f3e1c36abbc6c440484be248856db"
|
||||
|
||||
[[package]]
|
||||
name = "cc"
|
||||
|
|
@ -61,52 +91,51 @@ checksum = "3f9eec918d3f24069decb9af1554cad7c880e2da24a9afd88aca000531ab82c1"
|
|||
|
||||
[[package]]
|
||||
name = "form_urlencoded"
|
||||
version = "1.0.1"
|
||||
version = "1.1.0"
|
||||
source = "registry+https://github.com/rust-lang/crates.io-index"
|
||||
checksum = "5fc25a87fa4fd2094bffb06925852034d90a17f0d1e05197d4956d3555752191"
|
||||
checksum = "a9c384f161156f5260c24a097c56119f9be8c798586aecc13afbcbe7b7e26bf8"
|
||||
dependencies = [
|
||||
"matches",
|
||||
"percent-encoding",
|
||||
]
|
||||
|
||||
[[package]]
|
||||
name = "futures-channel"
|
||||
version = "0.3.21"
|
||||
version = "0.3.24"
|
||||
source = "registry+https://github.com/rust-lang/crates.io-index"
|
||||
checksum = "c3083ce4b914124575708913bca19bfe887522d6e2e6d0952943f5eac4a74010"
|
||||
checksum = "30bdd20c28fadd505d0fd6712cdfcb0d4b5648baf45faef7f852afb2399bb050"
|
||||
dependencies = [
|
||||
"futures-core",
|
||||
]
|
||||
|
||||
[[package]]
|
||||
name = "futures-core"
|
||||
version = "0.3.21"
|
||||
version = "0.3.24"
|
||||
source = "registry+https://github.com/rust-lang/crates.io-index"
|
||||
checksum = "0c09fd04b7e4073ac7156a9539b57a484a8ea920f79c7c675d05d289ab6110d3"
|
||||
checksum = "4e5aa3de05362c3fb88de6531e6296e85cde7739cccad4b9dfeeb7f6ebce56bf"
|
||||
|
||||
[[package]]
|
||||
name = "futures-io"
|
||||
version = "0.3.21"
|
||||
version = "0.3.24"
|
||||
source = "registry+https://github.com/rust-lang/crates.io-index"
|
||||
checksum = "fc4045962a5a5e935ee2fdedaa4e08284547402885ab326734432bed5d12966b"
|
||||
checksum = "bbf4d2a7a308fd4578637c0b17c7e1c7ba127b8f6ba00b29f717e9655d85eb68"
|
||||
|
||||
[[package]]
|
||||
name = "futures-sink"
|
||||
version = "0.3.21"
|
||||
version = "0.3.24"
|
||||
source = "registry+https://github.com/rust-lang/crates.io-index"
|
||||
checksum = "21163e139fa306126e6eedaf49ecdb4588f939600f0b1e770f4205ee4b7fa868"
|
||||
checksum = "21b20ba5a92e727ba30e72834706623d94ac93a725410b6a6b6fbc1b07f7ba56"
|
||||
|
||||
[[package]]
|
||||
name = "futures-task"
|
||||
version = "0.3.21"
|
||||
version = "0.3.24"
|
||||
source = "registry+https://github.com/rust-lang/crates.io-index"
|
||||
checksum = "57c66a976bf5909d801bbef33416c41372779507e7a6b3a5e25e4749c58f776a"
|
||||
checksum = "a6508c467c73851293f390476d4491cf4d227dbabcd4170f3bb6044959b294f1"
|
||||
|
||||
[[package]]
|
||||
name = "futures-util"
|
||||
version = "0.3.21"
|
||||
version = "0.3.24"
|
||||
source = "registry+https://github.com/rust-lang/crates.io-index"
|
||||
checksum = "d8b7abd5d659d9b90c8cba917f6ec750a74e2dc23902ef9cd4cc8c8b22e6036a"
|
||||
checksum = "44fb6cb1be61cc1d2e43b262516aafcf63b241cffdb1d3fa115f91d9c7b09c90"
|
||||
dependencies = [
|
||||
"futures-core",
|
||||
"futures-io",
|
||||
|
|
@ -118,10 +147,16 @@ dependencies = [
|
|||
]
|
||||
|
||||
[[package]]
|
||||
name = "h2"
|
||||
version = "0.3.13"
|
||||
name = "gimli"
|
||||
version = "0.26.2"
|
||||
source = "registry+https://github.com/rust-lang/crates.io-index"
|
||||
checksum = "37a82c6d637fc9515a4694bbf1cb2457b79d81ce52b3108bdeea58b07dd34a57"
|
||||
checksum = "22030e2c5a68ec659fde1e949a745124b48e6fa8b045b7ed5bd1fe4ccc5c4e5d"
|
||||
|
||||
[[package]]
|
||||
name = "h2"
|
||||
version = "0.3.14"
|
||||
source = "registry+https://github.com/rust-lang/crates.io-index"
|
||||
checksum = "5ca32592cf21ac7ccab1825cd87f6c9b3d9022c44d086172ed0966bec8af30be"
|
||||
dependencies = [
|
||||
"bytes",
|
||||
"fnv",
|
||||
|
|
@ -155,6 +190,7 @@ dependencies = [
|
|||
name = "host"
|
||||
version = "0.0.1"
|
||||
dependencies = [
|
||||
"backtrace",
|
||||
"libc",
|
||||
"reqwest",
|
||||
"roc_std",
|
||||
|
|
@ -184,9 +220,9 @@ dependencies = [
|
|||
|
||||
[[package]]
|
||||
name = "httparse"
|
||||
version = "1.7.1"
|
||||
version = "1.8.0"
|
||||
source = "registry+https://github.com/rust-lang/crates.io-index"
|
||||
checksum = "496ce29bb5a52785b44e0f7ca2847ae0bb839c9bd28f69acac9b99d461c0c04c"
|
||||
checksum = "d897f394bad6a705d5f4104762e116a75639e470d80901eed05a860a95cb1904"
|
||||
|
||||
[[package]]
|
||||
name = "httpdate"
|
||||
|
|
@ -233,11 +269,10 @@ dependencies = [
|
|||
|
||||
[[package]]
|
||||
name = "idna"
|
||||
version = "0.2.3"
|
||||
version = "0.3.0"
|
||||
source = "registry+https://github.com/rust-lang/crates.io-index"
|
||||
checksum = "418a0a6fab821475f634efe3ccc45c013f742efe03d853e8d3355d5cb850ecf8"
|
||||
checksum = "e14ddfc70884202db2244c223200c204c2bda1bc6e0998d11b5e024d657209e6"
|
||||
dependencies = [
|
||||
"matches",
|
||||
"unicode-bidi",
|
||||
"unicode-normalization",
|
||||
]
|
||||
|
|
@ -260,30 +295,24 @@ checksum = "879d54834c8c76457ef4293a689b2a8c59b076067ad77b15efafbb05f92a592b"
|
|||
|
||||
[[package]]
|
||||
name = "itoa"
|
||||
version = "1.0.2"
|
||||
version = "1.0.4"
|
||||
source = "registry+https://github.com/rust-lang/crates.io-index"
|
||||
checksum = "112c678d4050afce233f4f2852bb2eb519230b3cf12f33585275537d7e41578d"
|
||||
checksum = "4217ad341ebadf8d8e724e264f13e593e0648f5b3e94b3896a5df283be015ecc"
|
||||
|
||||
[[package]]
|
||||
name = "js-sys"
|
||||
version = "0.3.58"
|
||||
version = "0.3.60"
|
||||
source = "registry+https://github.com/rust-lang/crates.io-index"
|
||||
checksum = "c3fac17f7123a73ca62df411b1bf727ccc805daa070338fda671c86dac1bdc27"
|
||||
checksum = "49409df3e3bf0856b916e2ceaca09ee28e6871cf7d9ce97a692cacfdb2a25a47"
|
||||
dependencies = [
|
||||
"wasm-bindgen",
|
||||
]
|
||||
|
||||
[[package]]
|
||||
name = "lazy_static"
|
||||
version = "1.4.0"
|
||||
source = "registry+https://github.com/rust-lang/crates.io-index"
|
||||
checksum = "e2abad23fbc42b3700f2f279844dc832adb2b2eb069b2df918f455c4e18cc646"
|
||||
|
||||
[[package]]
|
||||
name = "libc"
|
||||
version = "0.2.126"
|
||||
version = "0.2.134"
|
||||
source = "registry+https://github.com/rust-lang/crates.io-index"
|
||||
checksum = "349d5a591cd28b49e1d1037471617a32ddcda5731b99419008085f72d5a53836"
|
||||
checksum = "329c933548736bc49fd575ee68c89e8be4d260064184389a5b77517cddd99ffb"
|
||||
|
||||
[[package]]
|
||||
name = "log"
|
||||
|
|
@ -294,12 +323,6 @@ dependencies = [
|
|||
"cfg-if",
|
||||
]
|
||||
|
||||
[[package]]
|
||||
name = "matches"
|
||||
version = "0.1.9"
|
||||
source = "registry+https://github.com/rust-lang/crates.io-index"
|
||||
checksum = "a3e378b66a060d48947b590737b30a1be76706c8dd7b8ba0f2fe3989c68a853f"
|
||||
|
||||
[[package]]
|
||||
name = "memchr"
|
||||
version = "2.5.0"
|
||||
|
|
@ -312,6 +335,15 @@ version = "0.3.16"
|
|||
source = "registry+https://github.com/rust-lang/crates.io-index"
|
||||
checksum = "2a60c7ce501c71e03a9c9c0d35b861413ae925bd979cc7a4e30d060069aaac8d"
|
||||
|
||||
[[package]]
|
||||
name = "miniz_oxide"
|
||||
version = "0.5.4"
|
||||
source = "registry+https://github.com/rust-lang/crates.io-index"
|
||||
checksum = "96590ba8f175222643a85693f33d26e9c8a015f599c216509b1a6894af675d34"
|
||||
dependencies = [
|
||||
"adler",
|
||||
]
|
||||
|
||||
[[package]]
|
||||
name = "mio"
|
||||
version = "0.8.4"
|
||||
|
|
@ -335,16 +367,25 @@ dependencies = [
|
|||
]
|
||||
|
||||
[[package]]
|
||||
name = "once_cell"
|
||||
version = "1.13.0"
|
||||
name = "object"
|
||||
version = "0.29.0"
|
||||
source = "registry+https://github.com/rust-lang/crates.io-index"
|
||||
checksum = "18a6dbe30758c9f83eb00cbea4ac95966305f5a7772f3f42ebfc7fc7eddbd8e1"
|
||||
checksum = "21158b2c33aa6d4561f1c0a6ea283ca92bc54802a93b263e910746d679a7eb53"
|
||||
dependencies = [
|
||||
"memchr",
|
||||
]
|
||||
|
||||
[[package]]
|
||||
name = "once_cell"
|
||||
version = "1.15.0"
|
||||
source = "registry+https://github.com/rust-lang/crates.io-index"
|
||||
checksum = "e82dad04139b71a90c080c8463fe0dc7902db5192d939bd0950f074d014339e1"
|
||||
|
||||
[[package]]
|
||||
name = "percent-encoding"
|
||||
version = "2.1.0"
|
||||
version = "2.2.0"
|
||||
source = "registry+https://github.com/rust-lang/crates.io-index"
|
||||
checksum = "d4fd5641d01c8f18a23da7b6fe29298ff4b55afcccdf78973b24cf3175fee32e"
|
||||
checksum = "478c572c3d73181ff3c2539045f6eb99e5491218eae919370993b890cdbdd98e"
|
||||
|
||||
[[package]]
|
||||
name = "pin-project-lite"
|
||||
|
|
@ -360,27 +401,27 @@ checksum = "8b870d8c151b6f2fb93e84a13146138f05d02ed11c7e7c54f8826aaaf7c9f184"
|
|||
|
||||
[[package]]
|
||||
name = "proc-macro2"
|
||||
version = "1.0.40"
|
||||
version = "1.0.46"
|
||||
source = "registry+https://github.com/rust-lang/crates.io-index"
|
||||
checksum = "dd96a1e8ed2596c337f8eae5f24924ec83f5ad5ab21ea8e455d3566c69fbcaf7"
|
||||
checksum = "94e2ef8dbfc347b10c094890f778ee2e36ca9bb4262e86dc99cd217e35f3470b"
|
||||
dependencies = [
|
||||
"unicode-ident",
|
||||
]
|
||||
|
||||
[[package]]
|
||||
name = "quote"
|
||||
version = "1.0.20"
|
||||
version = "1.0.21"
|
||||
source = "registry+https://github.com/rust-lang/crates.io-index"
|
||||
checksum = "3bcdf212e9776fbcb2d23ab029360416bb1706b1aea2d1a5ba002727cbcab804"
|
||||
checksum = "bbe448f377a7d6961e30f5955f9b8d106c3f5e449d493ee1b125c1d43c2b5179"
|
||||
dependencies = [
|
||||
"proc-macro2",
|
||||
]
|
||||
|
||||
[[package]]
|
||||
name = "reqwest"
|
||||
version = "0.11.11"
|
||||
version = "0.11.12"
|
||||
source = "registry+https://github.com/rust-lang/crates.io-index"
|
||||
checksum = "b75aa69a3f06bbcc66ede33af2af253c6f7a86b1ca0033f60c580a27074fbf92"
|
||||
checksum = "431949c384f4e2ae07605ccaa56d1d9d2ecdb5cadd4f9577ccfab29f2e5149fc"
|
||||
dependencies = [
|
||||
"base64",
|
||||
"bytes",
|
||||
|
|
@ -394,9 +435,9 @@ dependencies = [
|
|||
"hyper-rustls",
|
||||
"ipnet",
|
||||
"js-sys",
|
||||
"lazy_static",
|
||||
"log",
|
||||
"mime",
|
||||
"once_cell",
|
||||
"percent-encoding",
|
||||
"pin-project-lite",
|
||||
"rustls",
|
||||
|
|
@ -438,6 +479,12 @@ dependencies = [
|
|||
"static_assertions",
|
||||
]
|
||||
|
||||
[[package]]
|
||||
name = "rustc-demangle"
|
||||
version = "0.1.21"
|
||||
source = "registry+https://github.com/rust-lang/crates.io-index"
|
||||
checksum = "7ef03e0a2b150c7a90d01faf6254c9c48a41e95fb2a8c2ac1c6f0d2b9aefc342"
|
||||
|
||||
[[package]]
|
||||
name = "rustls"
|
||||
version = "0.20.6"
|
||||
|
|
@ -452,18 +499,18 @@ dependencies = [
|
|||
|
||||
[[package]]
|
||||
name = "rustls-pemfile"
|
||||
version = "1.0.0"
|
||||
version = "1.0.1"
|
||||
source = "registry+https://github.com/rust-lang/crates.io-index"
|
||||
checksum = "e7522c9de787ff061458fe9a829dc790a3f5b22dc571694fc5883f448b94d9a9"
|
||||
checksum = "0864aeff53f8c05aa08d86e5ef839d3dfcf07aeba2db32f12db0ef716e87bd55"
|
||||
dependencies = [
|
||||
"base64",
|
||||
]
|
||||
|
||||
[[package]]
|
||||
name = "ryu"
|
||||
version = "1.0.10"
|
||||
version = "1.0.11"
|
||||
source = "registry+https://github.com/rust-lang/crates.io-index"
|
||||
checksum = "f3f6f92acf49d1b98f7a81226834412ada05458b7364277387724a237f062695"
|
||||
checksum = "4501abdff3ae82a1c1b477a17252eb69cee9e66eb915c1abaa4f44d873df9f09"
|
||||
|
||||
[[package]]
|
||||
name = "sct"
|
||||
|
|
@ -477,15 +524,15 @@ dependencies = [
|
|||
|
||||
[[package]]
|
||||
name = "serde"
|
||||
version = "1.0.140"
|
||||
version = "1.0.145"
|
||||
source = "registry+https://github.com/rust-lang/crates.io-index"
|
||||
checksum = "fc855a42c7967b7c369eb5860f7164ef1f6f81c20c7cc1141f2a604e18723b03"
|
||||
checksum = "728eb6351430bccb993660dfffc5a72f91ccc1295abaa8ce19b27ebe4f75568b"
|
||||
|
||||
[[package]]
|
||||
name = "serde_json"
|
||||
version = "1.0.82"
|
||||
version = "1.0.85"
|
||||
source = "registry+https://github.com/rust-lang/crates.io-index"
|
||||
checksum = "82c2c1fdcd807d1098552c5b9a36e425e42e9fbd7c6a37a8425f390f781f7fa7"
|
||||
checksum = "e55a28e3aaef9d5ce0506d0a14dbba8054ddc7e499ef522dd8b26859ec9d4a44"
|
||||
dependencies = [
|
||||
"itoa",
|
||||
"ryu",
|
||||
|
|
@ -515,9 +562,9 @@ dependencies = [
|
|||
|
||||
[[package]]
|
||||
name = "socket2"
|
||||
version = "0.4.4"
|
||||
version = "0.4.7"
|
||||
source = "registry+https://github.com/rust-lang/crates.io-index"
|
||||
checksum = "66d72b759436ae32898a2af0a14218dbf55efde3feeb170eb623637db85ee1e0"
|
||||
checksum = "02e2d2db9033d13a1567121ddd7a095ee144db4e1ca1b1bda3419bc0da294ebd"
|
||||
dependencies = [
|
||||
"libc",
|
||||
"winapi",
|
||||
|
|
@ -537,9 +584,9 @@ checksum = "a2eb9349b6444b326872e140eb1cf5e7c522154d69e7a0ffb0fb81c06b37543f"
|
|||
|
||||
[[package]]
|
||||
name = "syn"
|
||||
version = "1.0.98"
|
||||
version = "1.0.102"
|
||||
source = "registry+https://github.com/rust-lang/crates.io-index"
|
||||
checksum = "c50aef8a904de4c23c788f104b7dddc7d6f79c647c7c8ce4cc8f73eb0ca773dd"
|
||||
checksum = "3fcd952facd492f9be3ef0d0b7032a6e442ee9b361d4acc2b1d0c4aaa5f613a1"
|
||||
dependencies = [
|
||||
"proc-macro2",
|
||||
"quote",
|
||||
|
|
@ -563,9 +610,9 @@ checksum = "cda74da7e1a664f795bb1f8a87ec406fb89a02522cf6e50620d016add6dbbf5c"
|
|||
|
||||
[[package]]
|
||||
name = "tokio"
|
||||
version = "1.20.0"
|
||||
version = "1.21.2"
|
||||
source = "registry+https://github.com/rust-lang/crates.io-index"
|
||||
checksum = "57aec3cfa4c296db7255446efb4928a6be304b431a806216105542a67b6ca82e"
|
||||
checksum = "a9e03c497dc955702ba729190dc4aac6f2a0ce97f913e5b1b5912fc5039d9099"
|
||||
dependencies = [
|
||||
"autocfg",
|
||||
"bytes",
|
||||
|
|
@ -573,7 +620,6 @@ dependencies = [
|
|||
"memchr",
|
||||
"mio",
|
||||
"num_cpus",
|
||||
"once_cell",
|
||||
"pin-project-lite",
|
||||
"socket2",
|
||||
"winapi",
|
||||
|
|
@ -592,9 +638,9 @@ dependencies = [
|
|||
|
||||
[[package]]
|
||||
name = "tokio-util"
|
||||
version = "0.7.3"
|
||||
version = "0.7.4"
|
||||
source = "registry+https://github.com/rust-lang/crates.io-index"
|
||||
checksum = "cc463cd8deddc3770d20f9852143d50bf6094e640b485cb2e189a2099085ff45"
|
||||
checksum = "0bb2e075f03b3d66d8d8785356224ba688d2906a371015e225beeb65ca92c740"
|
||||
dependencies = [
|
||||
"bytes",
|
||||
"futures-core",
|
||||
|
|
@ -612,9 +658,9 @@ checksum = "b6bc1c9ce2b5135ac7f93c72918fc37feb872bdc6a5533a8b85eb4b86bfdae52"
|
|||
|
||||
[[package]]
|
||||
name = "tracing"
|
||||
version = "0.1.35"
|
||||
version = "0.1.37"
|
||||
source = "registry+https://github.com/rust-lang/crates.io-index"
|
||||
checksum = "a400e31aa60b9d44a52a8ee0343b5b18566b03a8321e0d321f695cf56e940160"
|
||||
checksum = "8ce8c33a8d48bd45d624a6e523445fd21ec13d3653cd51f681abf67418f54eb8"
|
||||
dependencies = [
|
||||
"cfg-if",
|
||||
"pin-project-lite",
|
||||
|
|
@ -623,9 +669,9 @@ dependencies = [
|
|||
|
||||
[[package]]
|
||||
name = "tracing-core"
|
||||
version = "0.1.28"
|
||||
version = "0.1.30"
|
||||
source = "registry+https://github.com/rust-lang/crates.io-index"
|
||||
checksum = "7b7358be39f2f274f322d2aaed611acc57f382e8eb1e5b48cb9ae30933495ce7"
|
||||
checksum = "24eb03ba0eab1fd845050058ce5e616558e8f8d8fca633e6b163fe25c797213a"
|
||||
dependencies = [
|
||||
"once_cell",
|
||||
]
|
||||
|
|
@ -644,15 +690,15 @@ checksum = "099b7128301d285f79ddd55b9a83d5e6b9e97c92e0ea0daebee7263e932de992"
|
|||
|
||||
[[package]]
|
||||
name = "unicode-ident"
|
||||
version = "1.0.1"
|
||||
version = "1.0.4"
|
||||
source = "registry+https://github.com/rust-lang/crates.io-index"
|
||||
checksum = "5bd2fe26506023ed7b5e1e315add59d6f584c621d037f9368fea9cfb988f368c"
|
||||
checksum = "dcc811dc4066ac62f84f11307873c4850cb653bfa9b1719cee2bd2204a4bc5dd"
|
||||
|
||||
[[package]]
|
||||
name = "unicode-normalization"
|
||||
version = "0.1.21"
|
||||
version = "0.1.22"
|
||||
source = "registry+https://github.com/rust-lang/crates.io-index"
|
||||
checksum = "854cbdc4f7bc6ae19c820d44abdc3277ac3e1b2b93db20a636825d9322fb60e6"
|
||||
checksum = "5c5713f0fc4b5db668a2ac63cdb7bb4469d8c9fed047b1d0292cc7b0ce2ba921"
|
||||
dependencies = [
|
||||
"tinyvec",
|
||||
]
|
||||
|
|
@ -665,13 +711,12 @@ checksum = "a156c684c91ea7d62626509bce3cb4e1d9ed5c4d978f7b4352658f96a4c26b4a"
|
|||
|
||||
[[package]]
|
||||
name = "url"
|
||||
version = "2.2.2"
|
||||
version = "2.3.1"
|
||||
source = "registry+https://github.com/rust-lang/crates.io-index"
|
||||
checksum = "a507c383b2d33b5fc35d1861e77e6b383d158b2da5e14fe51b83dfedf6fd578c"
|
||||
checksum = "0d68c799ae75762b8c3fe375feb6600ef5602c883c5d21eb51c09f22b83c4643"
|
||||
dependencies = [
|
||||
"form_urlencoded",
|
||||
"idna",
|
||||
"matches",
|
||||
"percent-encoding",
|
||||
]
|
||||
|
||||
|
|
@ -693,9 +738,9 @@ checksum = "9c8d87e72b64a3b4db28d11ce29237c246188f4f51057d65a7eab63b7987e423"
|
|||
|
||||
[[package]]
|
||||
name = "wasm-bindgen"
|
||||
version = "0.2.81"
|
||||
version = "0.2.83"
|
||||
source = "registry+https://github.com/rust-lang/crates.io-index"
|
||||
checksum = "7c53b543413a17a202f4be280a7e5c62a1c69345f5de525ee64f8cfdbc954994"
|
||||
checksum = "eaf9f5aceeec8be17c128b2e93e031fb8a4d469bb9c4ae2d7dc1888b26887268"
|
||||
dependencies = [
|
||||
"cfg-if",
|
||||
"wasm-bindgen-macro",
|
||||
|
|
@ -703,13 +748,13 @@ dependencies = [
|
|||
|
||||
[[package]]
|
||||
name = "wasm-bindgen-backend"
|
||||
version = "0.2.81"
|
||||
version = "0.2.83"
|
||||
source = "registry+https://github.com/rust-lang/crates.io-index"
|
||||
checksum = "5491a68ab4500fa6b4d726bd67408630c3dbe9c4fe7bda16d5c82a1fd8c7340a"
|
||||
checksum = "4c8ffb332579b0557b52d268b91feab8df3615f265d5270fec2a8c95b17c1142"
|
||||
dependencies = [
|
||||
"bumpalo",
|
||||
"lazy_static",
|
||||
"log",
|
||||
"once_cell",
|
||||
"proc-macro2",
|
||||
"quote",
|
||||
"syn",
|
||||
|
|
@ -718,9 +763,9 @@ dependencies = [
|
|||
|
||||
[[package]]
|
||||
name = "wasm-bindgen-futures"
|
||||
version = "0.4.31"
|
||||
version = "0.4.33"
|
||||
source = "registry+https://github.com/rust-lang/crates.io-index"
|
||||
checksum = "de9a9cec1733468a8c657e57fa2413d2ae2c0129b95e87c5b72b8ace4d13f31f"
|
||||
checksum = "23639446165ca5a5de86ae1d8896b737ae80319560fbaa4c2887b7da6e7ebd7d"
|
||||
dependencies = [
|
||||
"cfg-if",
|
||||
"js-sys",
|
||||
|
|
@ -730,9 +775,9 @@ dependencies = [
|
|||
|
||||
[[package]]
|
||||
name = "wasm-bindgen-macro"
|
||||
version = "0.2.81"
|
||||
version = "0.2.83"
|
||||
source = "registry+https://github.com/rust-lang/crates.io-index"
|
||||
checksum = "c441e177922bc58f1e12c022624b6216378e5febc2f0533e41ba443d505b80aa"
|
||||
checksum = "052be0f94026e6cbc75cdefc9bae13fd6052cdcaf532fa6c45e7ae33a1e6c810"
|
||||
dependencies = [
|
||||
"quote",
|
||||
"wasm-bindgen-macro-support",
|
||||
|
|
@ -740,9 +785,9 @@ dependencies = [
|
|||
|
||||
[[package]]
|
||||
name = "wasm-bindgen-macro-support"
|
||||
version = "0.2.81"
|
||||
version = "0.2.83"
|
||||
source = "registry+https://github.com/rust-lang/crates.io-index"
|
||||
checksum = "7d94ac45fcf608c1f45ef53e748d35660f168490c10b23704c7779ab8f5c3048"
|
||||
checksum = "07bc0c051dc5f23e307b13285f9d75df86bfdf816c5721e573dec1f9b8aa193c"
|
||||
dependencies = [
|
||||
"proc-macro2",
|
||||
"quote",
|
||||
|
|
@ -753,15 +798,15 @@ dependencies = [
|
|||
|
||||
[[package]]
|
||||
name = "wasm-bindgen-shared"
|
||||
version = "0.2.81"
|
||||
version = "0.2.83"
|
||||
source = "registry+https://github.com/rust-lang/crates.io-index"
|
||||
checksum = "6a89911bd99e5f3659ec4acf9c4d93b0a90fe4a2a11f15328472058edc5261be"
|
||||
checksum = "1c38c045535d93ec4f0b4defec448e4291638ee608530863b1e2ba115d4fff7f"
|
||||
|
||||
[[package]]
|
||||
name = "web-sys"
|
||||
version = "0.3.58"
|
||||
version = "0.3.60"
|
||||
source = "registry+https://github.com/rust-lang/crates.io-index"
|
||||
checksum = "2fed94beee57daf8dd7d51f2b15dc2bcde92d7a72304cdf662a4371008b71b90"
|
||||
checksum = "bcda906d8be16e728fd5adc5b729afad4e444e106ab28cd1c7256e54fa61510f"
|
||||
dependencies = [
|
||||
"js-sys",
|
||||
"wasm-bindgen",
|
||||
|
|
@ -779,9 +824,9 @@ dependencies = [
|
|||
|
||||
[[package]]
|
||||
name = "webpki-roots"
|
||||
version = "0.22.4"
|
||||
version = "0.22.5"
|
||||
source = "registry+https://github.com/rust-lang/crates.io-index"
|
||||
checksum = "f1c760f0d366a6c24a02ed7816e23e691f5d92291f94d15e836006fd11b04daf"
|
||||
checksum = "368bfe657969fb01238bb756d351dcade285e0f6fcbd36dcb23359a5169975be"
|
||||
dependencies = [
|
||||
"webpki",
|
||||
]
|
||||
|
|
|
|||
|
|
@ -20,5 +20,6 @@ path = "src/main.rs"
|
|||
roc_std = { path = "../../../crates/roc_std" }
|
||||
libc = "0.2"
|
||||
reqwest = { version="0.11.11", default-features=false, features=["blocking", "rustls-tls"] }
|
||||
backtrace = "0.3"
|
||||
|
||||
[workspace]
|
||||
|
|
|
|||
|
|
@ -14,7 +14,9 @@ hosted Effect
|
|||
setCwd,
|
||||
exePath,
|
||||
stdoutLine,
|
||||
stdoutWrite,
|
||||
stderrLine,
|
||||
stderrWrite,
|
||||
stdinLine,
|
||||
sendRequest,
|
||||
fileReadBytes,
|
||||
|
|
@ -26,7 +28,9 @@ hosted Effect
|
|||
generates Effect with [after, map, always, forever, loop]
|
||||
|
||||
stdoutLine : Str -> Effect {}
|
||||
stdoutWrite : Str -> Effect {}
|
||||
stderrLine : Str -> Effect {}
|
||||
stderrWrite : Str -> Effect {}
|
||||
stdinLine : Effect Str
|
||||
|
||||
fileWriteBytes : List U8, List U8 -> Effect (Result {} InternalFile.WriteErr)
|
||||
|
|
|
|||
|
|
@ -1,8 +1,15 @@
|
|||
interface Stderr
|
||||
exposes [line]
|
||||
exposes [line, write]
|
||||
imports [Effect, Task.{ Task }, InternalTask]
|
||||
|
||||
line : Str -> Task {} * [Write [Stderr]*]*
|
||||
line = \str ->
|
||||
Effect.map (Effect.stderrLine str) (\_ -> Ok {})
|
||||
Effect.stderrLine str
|
||||
|> Effect.map (\_ -> Ok {})
|
||||
|> InternalTask.fromEffect
|
||||
|
||||
write : Str -> Task {} * [Write [Stderr]*]*
|
||||
write = \str ->
|
||||
Effect.stderrWrite str
|
||||
|> Effect.map (\_ -> Ok {})
|
||||
|> InternalTask.fromEffect
|
||||
|
|
|
|||
|
|
@ -1,8 +1,15 @@
|
|||
interface Stdout
|
||||
exposes [line]
|
||||
exposes [line, write]
|
||||
imports [Effect, Task.{ Task }, InternalTask]
|
||||
|
||||
line : Str -> Task {} * [Write [Stdout]*]*
|
||||
line = \str ->
|
||||
Effect.map (Effect.stdoutLine str) (\_ -> Ok {})
|
||||
Effect.stdoutLine str
|
||||
|> Effect.map (\_ -> Ok {})
|
||||
|> InternalTask.fromEffect
|
||||
|
||||
write : Str -> Task {} * [Write [Stdout]*]*
|
||||
write = \str ->
|
||||
Effect.stdoutWrite str
|
||||
|> Effect.map (\_ -> Ok {})
|
||||
|> InternalTask.fromEffect
|
||||
|
|
|
|||
|
|
@ -1,5 +1,5 @@
|
|||
interface Task
|
||||
exposes [Task, succeed, fail, await, map, mapFail, onFail, attempt, forever, loop]
|
||||
exposes [Task, succeed, fail, await, map, mapFail, onFail, attempt, forever, loop, fromResult]
|
||||
imports [Effect, InternalTask]
|
||||
|
||||
Task ok err fx : InternalTask.Task ok err fx
|
||||
|
|
@ -93,3 +93,10 @@ mapFail = \task, transform ->
|
|||
Err err -> Task.fail (transform err) |> InternalTask.toEffect
|
||||
|
||||
InternalTask.fromEffect effect
|
||||
|
||||
## Use a Result among other Tasks by converting it into a Task.
|
||||
fromResult : Result ok err -> Task ok err *
|
||||
fromResult = \result ->
|
||||
when result is
|
||||
Ok ok -> succeed ok
|
||||
Err err -> fail err
|
||||
|
|
|
|||
|
|
@ -12,6 +12,7 @@ use roc_std::{RocDict, RocList, RocResult, RocStr};
|
|||
use std::borrow::Borrow;
|
||||
use std::ffi::{CStr, OsStr};
|
||||
use std::fs::File;
|
||||
use std::io::{self, Write};
|
||||
use std::os::raw::c_char;
|
||||
use std::path::Path;
|
||||
use std::time::Duration;
|
||||
|
|
@ -63,13 +64,110 @@ pub unsafe extern "C" fn roc_panic(c_ptr: *mut c_void, tag_id: u32) {
|
|||
0 => {
|
||||
let slice = CStr::from_ptr(c_ptr as *const c_char);
|
||||
let string = slice.to_str().unwrap();
|
||||
eprintln!("Roc hit a panic: {}", string);
|
||||
eprintln!("Roc crashed with:\n\n\t{}\n", string);
|
||||
|
||||
print_backtrace();
|
||||
std::process::exit(1);
|
||||
}
|
||||
_ => todo!(),
|
||||
}
|
||||
}
|
||||
|
||||
fn print_backtrace() {
|
||||
eprintln!("Here is the call stack that led to the crash:\n");
|
||||
|
||||
let mut entries = Vec::new();
|
||||
|
||||
#[derive(Default)]
|
||||
struct Entry {
|
||||
pub fn_name: String,
|
||||
pub filename: Option<String>,
|
||||
pub line: Option<u32>,
|
||||
pub col: Option<u32>,
|
||||
}
|
||||
|
||||
backtrace::trace(|frame| {
|
||||
backtrace::resolve_frame(frame, |symbol| {
|
||||
if let Some(fn_name) = symbol.name() {
|
||||
let fn_name = fn_name.to_string();
|
||||
|
||||
if should_show_in_backtrace(&fn_name) {
|
||||
let mut entry: Entry = Default::default();
|
||||
|
||||
entry.fn_name = format_fn_name(&fn_name);
|
||||
|
||||
if let Some(path) = symbol.filename() {
|
||||
entry.filename = Some(path.to_string_lossy().into_owned());
|
||||
};
|
||||
|
||||
entry.line = symbol.lineno();
|
||||
entry.col = symbol.colno();
|
||||
|
||||
entries.push(entry);
|
||||
}
|
||||
} else {
|
||||
entries.push(Entry {
|
||||
fn_name: "???".to_string(),
|
||||
..Default::default()
|
||||
});
|
||||
}
|
||||
});
|
||||
|
||||
true // keep going to the next frame
|
||||
});
|
||||
|
||||
for entry in entries {
|
||||
eprintln!("\t{}", entry.fn_name);
|
||||
|
||||
if let Some(filename) = entry.filename {
|
||||
eprintln!("\t\t{filename}");
|
||||
}
|
||||
}
|
||||
|
||||
eprintln!("\nOptimizations can make this list inaccurate! If it looks wrong, try running without `--optimize` and with `--linker=legacy`\n");
|
||||
}
|
||||
|
||||
fn should_show_in_backtrace(fn_name: &str) -> bool {
|
||||
let is_from_rust = fn_name.contains("::");
|
||||
let is_host_fn = fn_name.starts_with("roc_panic")
|
||||
|| fn_name.starts_with("_Effect_effect")
|
||||
|| fn_name.starts_with("_roc__")
|
||||
|| fn_name.starts_with("rust_main")
|
||||
|| fn_name == "_main";
|
||||
|
||||
!is_from_rust && !is_host_fn
|
||||
}
|
||||
|
||||
fn format_fn_name(fn_name: &str) -> String {
|
||||
// e.g. convert "_Num_sub_a0c29024d3ec6e3a16e414af99885fbb44fa6182331a70ab4ca0886f93bad5"
|
||||
// to ["Num", "sub", "a0c29024d3ec6e3a16e414af99885fbb44fa6182331a70ab4ca0886f93bad5"]
|
||||
let mut pieces_iter = fn_name.split("_");
|
||||
|
||||
if let (_, Some(module_name), Some(name)) =
|
||||
(pieces_iter.next(), pieces_iter.next(), pieces_iter.next())
|
||||
{
|
||||
display_roc_fn(module_name, name)
|
||||
} else {
|
||||
"???".to_string()
|
||||
}
|
||||
}
|
||||
|
||||
fn display_roc_fn(module_name: &str, fn_name: &str) -> String {
|
||||
let module_name = if module_name == "#UserApp" {
|
||||
"app"
|
||||
} else {
|
||||
module_name
|
||||
};
|
||||
|
||||
let fn_name = if fn_name.parse::<u64>().is_ok() {
|
||||
"(anonymous function)"
|
||||
} else {
|
||||
fn_name
|
||||
};
|
||||
|
||||
format!("\u{001B}[36m{module_name}\u{001B}[39m.{fn_name}")
|
||||
}
|
||||
|
||||
#[no_mangle]
|
||||
pub unsafe extern "C" fn roc_memcpy(dst: *mut c_void, src: *mut c_void, n: usize) -> *mut c_void {
|
||||
libc::memcpy(dst, src, n)
|
||||
|
|
@ -179,12 +277,26 @@ pub extern "C" fn roc_fx_stdoutLine(line: &RocStr) {
|
|||
println!("{}", string);
|
||||
}
|
||||
|
||||
#[no_mangle]
|
||||
pub extern "C" fn roc_fx_stdoutWrite(text: &RocStr) {
|
||||
let string = text.as_str();
|
||||
print!("{}", string);
|
||||
io::stdout().flush().unwrap();
|
||||
}
|
||||
|
||||
#[no_mangle]
|
||||
pub extern "C" fn roc_fx_stderrLine(line: &RocStr) {
|
||||
let string = line.as_str();
|
||||
eprintln!("{}", string);
|
||||
}
|
||||
|
||||
#[no_mangle]
|
||||
pub extern "C" fn roc_fx_stderrWrite(text: &RocStr) {
|
||||
let string = text.as_str();
|
||||
eprint!("{}", string);
|
||||
io::stderr().flush().unwrap();
|
||||
}
|
||||
|
||||
// #[no_mangle]
|
||||
// pub extern "C" fn roc_fx_fileWriteUtf8(
|
||||
// roc_path: &RocList<u8>,
|
||||
|
|
|
|||
1
examples/swiftui/.gitignore
vendored
Normal file
1
examples/swiftui/.gitignore
vendored
Normal file
|
|
@ -0,0 +1 @@
|
|||
swiftui
|
||||
|
|
@ -12,9 +12,9 @@ If you have a specific question, the [FAQ](../FAQ.md) might have an answer, alth
|
|||
|
||||
## Installation
|
||||
|
||||
- [Linux x86](linux_x86.md)
|
||||
- [Linux x86_64](linux_x86_64.md)
|
||||
- [MacOS Apple Silicon](macos_apple_silicon.md)
|
||||
- [MacOS x86](macos_x86.md)
|
||||
- [MacOS x86_64](macos_x86_64.md)
|
||||
- [Windows](windows.md)
|
||||
- [Other](other.md)
|
||||
|
||||
|
|
|
|||
|
|
@ -1,4 +1,4 @@
|
|||
# Roc installation guide for x86 Linux systems
|
||||
# Roc installation guide for x86_64 Linux systems
|
||||
|
||||
## How to install Roc
|
||||
|
||||
|
|
@ -1,4 +1,4 @@
|
|||
# Roc installation guide for x86 macOS systems
|
||||
# Roc installation guide for x86_64 macOS systems
|
||||
|
||||
## How to install Roc
|
||||
|
||||
Loading…
Add table
Add a link
Reference in a new issue