From f8771ebeb204c95fc5d5db2ee506d7997e8c76ac Mon Sep 17 00:00:00 2001 From: Brian Carroll Date: Thu, 21 Jul 2022 09:06:43 +0100 Subject: [PATCH] http: Switch to using reqwest crate for blocking http --- examples/interactive/cli-platform/Cargo.lock | 739 +++++++- examples/interactive/cli-platform/Cargo.toml | 2 +- examples/interactive/cli-platform/Http.roc | 4 +- .../interactive/cli-platform/InternalHttp.roc | 7 +- examples/interactive/cli-platform/src/glue.rs | 1559 ++++++----------- examples/interactive/cli-platform/src/lib.rs | 78 +- 6 files changed, 1188 insertions(+), 1201 deletions(-) diff --git a/examples/interactive/cli-platform/Cargo.lock b/examples/interactive/cli-platform/Cargo.lock index 7b9ea88d05..9f66edd215 100644 --- a/examples/interactive/cli-platform/Cargo.lock +++ b/examples/interactive/cli-platform/Cargo.lock @@ -2,30 +2,42 @@ # It is not intended for manual editing. version = 3 -[[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" source = "registry+https://github.com/rust-lang/crates.io-index" checksum = "8da52d66c7071e2e3fa2a1e5c6d088fec47b593032b254f5e980de8ea54454d6" +[[package]] +name = "autocfg" +version = "1.1.0" +source = "registry+https://github.com/rust-lang/crates.io-index" +checksum = "d468802bab17cbc0cc575e9b053f41e72aa36bfa6b7f55e3529ffa43161b97fa" + [[package]] name = "base64" version = "0.13.0" source = "registry+https://github.com/rust-lang/crates.io-index" checksum = "904dfeac50f3cdaba28fc6f57fdcddb75f49ed61346676a78c4ffe55877802fd" +[[package]] +name = "bitflags" +version = "1.3.2" +source = "registry+https://github.com/rust-lang/crates.io-index" +checksum = "bef38d45163c2f1dde094a7dfd33ccf595c92905c8f8f4fdc18d06fb1037718a" + [[package]] name = "bumpalo" version = "3.10.0" source = "registry+https://github.com/rust-lang/crates.io-index" checksum = "37ccbd214614c6783386c1af30caf03192f17891059cecc394b4fb119e363de3" +[[package]] +name = "bytes" +version = "1.2.0" +source = "registry+https://github.com/rust-lang/crates.io-index" +checksum = "f0b3de4a0c5e67e16066a0715723abd91edc2f9001d09c46e1dca929351e130e" + [[package]] name = "cc" version = "1.0.73" @@ -39,30 +51,60 @@ source = "registry+https://github.com/rust-lang/crates.io-index" checksum = "baf1de4339761588bc0619e3cbc0120ee582ebb74b53b4efbf79117bd2da40fd" [[package]] -name = "chunked_transfer" -version = "1.4.0" +name = "core-foundation" +version = "0.9.3" source = "registry+https://github.com/rust-lang/crates.io-index" -checksum = "fff857943da45f546682664a79488be82e69e43c1a7a2307679ab9afb3a66d2e" +checksum = "194a7a9e6de53fa55116934067c844d9d749312f75c6f6d0980e8c252f8c2146" +dependencies = [ + "core-foundation-sys", + "libc", +] [[package]] -name = "crc32fast" -version = "1.3.2" +name = "core-foundation-sys" +version = "0.8.3" source = "registry+https://github.com/rust-lang/crates.io-index" -checksum = "b540bd8bc810d3885c6ea91e2018302f68baba2129ab3e88f32389ee9370880d" +checksum = "5827cebf4670468b8772dd191856768aedcb1b0278a04f989f7766351917b9dc" + +[[package]] +name = "encoding_rs" +version = "0.8.31" +source = "registry+https://github.com/rust-lang/crates.io-index" +checksum = "9852635589dc9f9ea1b6fe9f05b50ef208c85c834a562f0c6abb1c475736ec2b" dependencies = [ "cfg-if", ] [[package]] -name = "flate2" -version = "1.0.24" +name = "fastrand" +version = "1.7.0" source = "registry+https://github.com/rust-lang/crates.io-index" -checksum = "f82b0f4c27ad9f8bfd1f3208d882da2b09c301bc1c828fd3a00d0216d2fbbff6" +checksum = "c3fcf0cee53519c866c09b5de1f6c56ff9d647101f81c1964fa632e148896cdf" dependencies = [ - "crc32fast", - "miniz_oxide", + "instant", ] +[[package]] +name = "fnv" +version = "1.0.7" +source = "registry+https://github.com/rust-lang/crates.io-index" +checksum = "3f9eec918d3f24069decb9af1554cad7c880e2da24a9afd88aca000531ab82c1" + +[[package]] +name = "foreign-types" +version = "0.3.2" +source = "registry+https://github.com/rust-lang/crates.io-index" +checksum = "f6f339eb8adc052cd2ca78910fda869aefa38d22d5cb648e6485e4d3fc06f3b1" +dependencies = [ + "foreign-types-shared", +] + +[[package]] +name = "foreign-types-shared" +version = "0.1.1" +source = "registry+https://github.com/rust-lang/crates.io-index" +checksum = "00b0228411908ca8685dba7fc2cdd70ec9990a6e753e89b6ac91a84c40fbaf4b" + [[package]] name = "form_urlencoded" version = "1.0.1" @@ -73,13 +115,166 @@ dependencies = [ "percent-encoding", ] +[[package]] +name = "futures-channel" +version = "0.3.21" +source = "registry+https://github.com/rust-lang/crates.io-index" +checksum = "c3083ce4b914124575708913bca19bfe887522d6e2e6d0952943f5eac4a74010" +dependencies = [ + "futures-core", +] + +[[package]] +name = "futures-core" +version = "0.3.21" +source = "registry+https://github.com/rust-lang/crates.io-index" +checksum = "0c09fd04b7e4073ac7156a9539b57a484a8ea920f79c7c675d05d289ab6110d3" + +[[package]] +name = "futures-io" +version = "0.3.21" +source = "registry+https://github.com/rust-lang/crates.io-index" +checksum = "fc4045962a5a5e935ee2fdedaa4e08284547402885ab326734432bed5d12966b" + +[[package]] +name = "futures-sink" +version = "0.3.21" +source = "registry+https://github.com/rust-lang/crates.io-index" +checksum = "21163e139fa306126e6eedaf49ecdb4588f939600f0b1e770f4205ee4b7fa868" + +[[package]] +name = "futures-task" +version = "0.3.21" +source = "registry+https://github.com/rust-lang/crates.io-index" +checksum = "57c66a976bf5909d801bbef33416c41372779507e7a6b3a5e25e4749c58f776a" + +[[package]] +name = "futures-util" +version = "0.3.21" +source = "registry+https://github.com/rust-lang/crates.io-index" +checksum = "d8b7abd5d659d9b90c8cba917f6ec750a74e2dc23902ef9cd4cc8c8b22e6036a" +dependencies = [ + "futures-core", + "futures-io", + "futures-task", + "memchr", + "pin-project-lite", + "pin-utils", + "slab", +] + +[[package]] +name = "h2" +version = "0.3.13" +source = "registry+https://github.com/rust-lang/crates.io-index" +checksum = "37a82c6d637fc9515a4694bbf1cb2457b79d81ce52b3108bdeea58b07dd34a57" +dependencies = [ + "bytes", + "fnv", + "futures-core", + "futures-sink", + "futures-util", + "http", + "indexmap", + "slab", + "tokio", + "tokio-util", + "tracing", +] + +[[package]] +name = "hashbrown" +version = "0.12.3" +source = "registry+https://github.com/rust-lang/crates.io-index" +checksum = "8a9ee70c43aaf417c914396645a0fa852624801b24ebb7ae78fe8272889ac888" + +[[package]] +name = "hermit-abi" +version = "0.1.19" +source = "registry+https://github.com/rust-lang/crates.io-index" +checksum = "62b467343b94ba476dcb2500d242dadbb39557df889310ac77c5d99100aaac33" +dependencies = [ + "libc", +] + [[package]] name = "host" version = "0.1.0" dependencies = [ "libc", + "reqwest", "roc_std", - "ureq", +] + +[[package]] +name = "http" +version = "0.2.8" +source = "registry+https://github.com/rust-lang/crates.io-index" +checksum = "75f43d41e26995c17e71ee126451dd3941010b0514a81a9d11f3b341debc2399" +dependencies = [ + "bytes", + "fnv", + "itoa", +] + +[[package]] +name = "http-body" +version = "0.4.5" +source = "registry+https://github.com/rust-lang/crates.io-index" +checksum = "d5f38f16d184e36f2408a55281cd658ecbd3ca05cce6d6510a176eca393e26d1" +dependencies = [ + "bytes", + "http", + "pin-project-lite", +] + +[[package]] +name = "httparse" +version = "1.7.1" +source = "registry+https://github.com/rust-lang/crates.io-index" +checksum = "496ce29bb5a52785b44e0f7ca2847ae0bb839c9bd28f69acac9b99d461c0c04c" + +[[package]] +name = "httpdate" +version = "1.0.2" +source = "registry+https://github.com/rust-lang/crates.io-index" +checksum = "c4a1e36c821dbe04574f602848a19f742f4fb3c98d40449f11bcad18d6b17421" + +[[package]] +name = "hyper" +version = "0.14.20" +source = "registry+https://github.com/rust-lang/crates.io-index" +checksum = "02c929dc5c39e335a03c405292728118860721b10190d98c2a0f0efd5baafbac" +dependencies = [ + "bytes", + "futures-channel", + "futures-core", + "futures-util", + "h2", + "http", + "http-body", + "httparse", + "httpdate", + "itoa", + "pin-project-lite", + "socket2", + "tokio", + "tower-service", + "tracing", + "want", +] + +[[package]] +name = "hyper-tls" +version = "0.5.0" +source = "registry+https://github.com/rust-lang/crates.io-index" +checksum = "d6183ddfa99b85da61a140bea0efc93fdf56ceaa041b37d553518030827f9905" +dependencies = [ + "bytes", + "hyper", + "native-tls", + "tokio", + "tokio-native-tls", ] [[package]] @@ -93,6 +288,37 @@ dependencies = [ "unicode-normalization", ] +[[package]] +name = "indexmap" +version = "1.9.1" +source = "registry+https://github.com/rust-lang/crates.io-index" +checksum = "10a35a97730320ffe8e2d410b5d3b69279b98d2c14bdb8b70ea89ecf7888d41e" +dependencies = [ + "autocfg", + "hashbrown", +] + +[[package]] +name = "instant" +version = "0.1.12" +source = "registry+https://github.com/rust-lang/crates.io-index" +checksum = "7a5bbe824c507c5da5956355e86a746d82e0e1464f65d862cc5e71da70e94b2c" +dependencies = [ + "cfg-if", +] + +[[package]] +name = "ipnet" +version = "2.5.0" +source = "registry+https://github.com/rust-lang/crates.io-index" +checksum = "879d54834c8c76457ef4293a689b2a8c59b076067ad77b15efafbb05f92a592b" + +[[package]] +name = "itoa" +version = "1.0.2" +source = "registry+https://github.com/rust-lang/crates.io-index" +checksum = "112c678d4050afce233f4f2852bb2eb519230b3cf12f33585275537d7e41578d" + [[package]] name = "js-sys" version = "0.3.58" @@ -130,12 +356,55 @@ source = "registry+https://github.com/rust-lang/crates.io-index" checksum = "a3e378b66a060d48947b590737b30a1be76706c8dd7b8ba0f2fe3989c68a853f" [[package]] -name = "miniz_oxide" -version = "0.5.3" +name = "memchr" +version = "2.5.0" source = "registry+https://github.com/rust-lang/crates.io-index" -checksum = "6f5c75688da582b8ffc1f1799e9db273f32133c49e048f614d22ec3256773ccc" +checksum = "2dffe52ecf27772e601905b7522cb4ef790d2cc203488bbd0e2fe85fcb74566d" + +[[package]] +name = "mime" +version = "0.3.16" +source = "registry+https://github.com/rust-lang/crates.io-index" +checksum = "2a60c7ce501c71e03a9c9c0d35b861413ae925bd979cc7a4e30d060069aaac8d" + +[[package]] +name = "mio" +version = "0.8.4" +source = "registry+https://github.com/rust-lang/crates.io-index" +checksum = "57ee1c23c7c63b0c9250c339ffdc69255f110b298b901b9f6c82547b7b87caaf" dependencies = [ - "adler", + "libc", + "log", + "wasi", + "windows-sys", +] + +[[package]] +name = "native-tls" +version = "0.2.10" +source = "registry+https://github.com/rust-lang/crates.io-index" +checksum = "fd7e2f3618557f980e0b17e8856252eee3c97fa12c54dff0ca290fb6266ca4a9" +dependencies = [ + "lazy_static", + "libc", + "log", + "openssl", + "openssl-probe", + "openssl-sys", + "schannel", + "security-framework", + "security-framework-sys", + "tempfile", +] + +[[package]] +name = "num_cpus" +version = "1.13.1" +source = "registry+https://github.com/rust-lang/crates.io-index" +checksum = "19e64526ebdee182341572e50e9ad03965aa510cd94427a4549448f285e957a1" +dependencies = [ + "hermit-abi", + "libc", ] [[package]] @@ -144,12 +413,75 @@ version = "1.13.0" source = "registry+https://github.com/rust-lang/crates.io-index" checksum = "18a6dbe30758c9f83eb00cbea4ac95966305f5a7772f3f42ebfc7fc7eddbd8e1" +[[package]] +name = "openssl" +version = "0.10.41" +source = "registry+https://github.com/rust-lang/crates.io-index" +checksum = "618febf65336490dfcf20b73f885f5651a0c89c64c2d4a8c3662585a70bf5bd0" +dependencies = [ + "bitflags", + "cfg-if", + "foreign-types", + "libc", + "once_cell", + "openssl-macros", + "openssl-sys", +] + +[[package]] +name = "openssl-macros" +version = "0.1.0" +source = "registry+https://github.com/rust-lang/crates.io-index" +checksum = "b501e44f11665960c7e7fcf062c7d96a14ade4aa98116c004b2e37b5be7d736c" +dependencies = [ + "proc-macro2", + "quote", + "syn", +] + +[[package]] +name = "openssl-probe" +version = "0.1.5" +source = "registry+https://github.com/rust-lang/crates.io-index" +checksum = "ff011a302c396a5197692431fc1948019154afc178baf7d8e37367442a4601cf" + +[[package]] +name = "openssl-sys" +version = "0.9.75" +source = "registry+https://github.com/rust-lang/crates.io-index" +checksum = "e5f9bd0c2710541a3cda73d6f9ac4f1b240de4ae261065d309dbe73d9dceb42f" +dependencies = [ + "autocfg", + "cc", + "libc", + "pkg-config", + "vcpkg", +] + [[package]] name = "percent-encoding" version = "2.1.0" source = "registry+https://github.com/rust-lang/crates.io-index" checksum = "d4fd5641d01c8f18a23da7b6fe29298ff4b55afcccdf78973b24cf3175fee32e" +[[package]] +name = "pin-project-lite" +version = "0.2.9" +source = "registry+https://github.com/rust-lang/crates.io-index" +checksum = "e0a7ae3ac2f1173085d398531c705756c94a4c56843785df85a60c1a0afac116" + +[[package]] +name = "pin-utils" +version = "0.1.0" +source = "registry+https://github.com/rust-lang/crates.io-index" +checksum = "8b870d8c151b6f2fb93e84a13146138f05d02ed11c7e7c54f8826aaaf7c9f184" + +[[package]] +name = "pkg-config" +version = "0.3.25" +source = "registry+https://github.com/rust-lang/crates.io-index" +checksum = "1df8c4ec4b0627e53bdf214615ad287367e482558cf84b109250b37464dc03ae" + [[package]] name = "proc-macro2" version = "1.0.40" @@ -169,20 +501,60 @@ dependencies = [ ] [[package]] -name = "ring" -version = "0.16.20" +name = "redox_syscall" +version = "0.2.13" source = "registry+https://github.com/rust-lang/crates.io-index" -checksum = "3053cf52e236a3ed746dfc745aa9cacf1b791d846bdaf412f60a8d7d6e17c8fc" +checksum = "62f25bc4c7e55e0b0b7a1d43fb893f4fa1361d0abe38b9ce4f323c2adfe6ef42" +dependencies = [ + "bitflags", +] + +[[package]] +name = "remove_dir_all" +version = "0.5.3" +source = "registry+https://github.com/rust-lang/crates.io-index" +checksum = "3acd125665422973a33ac9d3dd2df85edad0f4ae9b00dafb1a05e43a9f5ef8e7" dependencies = [ - "cc", - "libc", - "once_cell", - "spin", - "untrusted", - "web-sys", "winapi", ] +[[package]] +name = "reqwest" +version = "0.11.11" +source = "registry+https://github.com/rust-lang/crates.io-index" +checksum = "b75aa69a3f06bbcc66ede33af2af253c6f7a86b1ca0033f60c580a27074fbf92" +dependencies = [ + "base64", + "bytes", + "encoding_rs", + "futures-core", + "futures-util", + "h2", + "http", + "http-body", + "hyper", + "hyper-tls", + "ipnet", + "js-sys", + "lazy_static", + "log", + "mime", + "native-tls", + "percent-encoding", + "pin-project-lite", + "serde", + "serde_json", + "serde_urlencoded", + "tokio", + "tokio-native-tls", + "tower-service", + "url", + "wasm-bindgen", + "wasm-bindgen-futures", + "web-sys", + "winreg", +] + [[package]] name = "roc_std" version = "0.1.0" @@ -192,32 +564,91 @@ dependencies = [ ] [[package]] -name = "rustls" -version = "0.20.6" +name = "ryu" +version = "1.0.10" source = "registry+https://github.com/rust-lang/crates.io-index" -checksum = "5aab8ee6c7097ed6057f43c187a62418d0c05a4bd5f18b3571db50ee0f9ce033" +checksum = "f3f6f92acf49d1b98f7a81226834412ada05458b7364277387724a237f062695" + +[[package]] +name = "schannel" +version = "0.1.20" +source = "registry+https://github.com/rust-lang/crates.io-index" +checksum = "88d6731146462ea25d9244b2ed5fd1d716d25c52e4d54aa4fb0f3c4e9854dbe2" dependencies = [ - "log", - "ring", - "sct", - "webpki", + "lazy_static", + "windows-sys", ] [[package]] -name = "sct" -version = "0.7.0" +name = "security-framework" +version = "2.6.1" source = "registry+https://github.com/rust-lang/crates.io-index" -checksum = "d53dcdb7c9f8158937a7981b48accfd39a43af418591a5d008c7b22b5e1b7ca4" +checksum = "2dc14f172faf8a0194a3aded622712b0de276821addc574fa54fc0a1167e10dc" dependencies = [ - "ring", - "untrusted", + "bitflags", + "core-foundation", + "core-foundation-sys", + "libc", + "security-framework-sys", ] [[package]] -name = "spin" -version = "0.5.2" +name = "security-framework-sys" +version = "2.6.1" source = "registry+https://github.com/rust-lang/crates.io-index" -checksum = "6e63cff320ae2c57904679ba7cb63280a3dc4613885beafb148ee7bf9aa9042d" +checksum = "0160a13a177a45bfb43ce71c01580998474f556ad854dcbca936dd2841a5c556" +dependencies = [ + "core-foundation-sys", + "libc", +] + +[[package]] +name = "serde" +version = "1.0.140" +source = "registry+https://github.com/rust-lang/crates.io-index" +checksum = "fc855a42c7967b7c369eb5860f7164ef1f6f81c20c7cc1141f2a604e18723b03" + +[[package]] +name = "serde_json" +version = "1.0.82" +source = "registry+https://github.com/rust-lang/crates.io-index" +checksum = "82c2c1fdcd807d1098552c5b9a36e425e42e9fbd7c6a37a8425f390f781f7fa7" +dependencies = [ + "itoa", + "ryu", + "serde", +] + +[[package]] +name = "serde_urlencoded" +version = "0.7.1" +source = "registry+https://github.com/rust-lang/crates.io-index" +checksum = "d3491c14715ca2294c4d6a88f15e84739788c1d030eed8c110436aafdaa2f3fd" +dependencies = [ + "form_urlencoded", + "itoa", + "ryu", + "serde", +] + +[[package]] +name = "slab" +version = "0.4.7" +source = "registry+https://github.com/rust-lang/crates.io-index" +checksum = "4614a76b2a8be0058caa9dbbaf66d988527d86d003c11a94fbd335d7661edcef" +dependencies = [ + "autocfg", +] + +[[package]] +name = "socket2" +version = "0.4.4" +source = "registry+https://github.com/rust-lang/crates.io-index" +checksum = "66d72b759436ae32898a2af0a14218dbf55efde3feeb170eb623637db85ee1e0" +dependencies = [ + "libc", + "winapi", +] [[package]] name = "static_assertions" @@ -236,6 +667,20 @@ dependencies = [ "unicode-ident", ] +[[package]] +name = "tempfile" +version = "3.3.0" +source = "registry+https://github.com/rust-lang/crates.io-index" +checksum = "5cdb1ef4eaeeaddc8fbd371e5017057064af0911902ef36b39801f67cc6d79e4" +dependencies = [ + "cfg-if", + "fastrand", + "libc", + "redox_syscall", + "remove_dir_all", + "winapi", +] + [[package]] name = "tinyvec" version = "1.6.0" @@ -251,6 +696,80 @@ version = "0.1.0" source = "registry+https://github.com/rust-lang/crates.io-index" checksum = "cda74da7e1a664f795bb1f8a87ec406fb89a02522cf6e50620d016add6dbbf5c" +[[package]] +name = "tokio" +version = "1.20.0" +source = "registry+https://github.com/rust-lang/crates.io-index" +checksum = "57aec3cfa4c296db7255446efb4928a6be304b431a806216105542a67b6ca82e" +dependencies = [ + "autocfg", + "bytes", + "libc", + "memchr", + "mio", + "num_cpus", + "once_cell", + "pin-project-lite", + "socket2", + "winapi", +] + +[[package]] +name = "tokio-native-tls" +version = "0.3.0" +source = "registry+https://github.com/rust-lang/crates.io-index" +checksum = "f7d995660bd2b7f8c1568414c1126076c13fbb725c40112dc0120b78eb9b717b" +dependencies = [ + "native-tls", + "tokio", +] + +[[package]] +name = "tokio-util" +version = "0.7.3" +source = "registry+https://github.com/rust-lang/crates.io-index" +checksum = "cc463cd8deddc3770d20f9852143d50bf6094e640b485cb2e189a2099085ff45" +dependencies = [ + "bytes", + "futures-core", + "futures-sink", + "pin-project-lite", + "tokio", + "tracing", +] + +[[package]] +name = "tower-service" +version = "0.3.2" +source = "registry+https://github.com/rust-lang/crates.io-index" +checksum = "b6bc1c9ce2b5135ac7f93c72918fc37feb872bdc6a5533a8b85eb4b86bfdae52" + +[[package]] +name = "tracing" +version = "0.1.35" +source = "registry+https://github.com/rust-lang/crates.io-index" +checksum = "a400e31aa60b9d44a52a8ee0343b5b18566b03a8321e0d321f695cf56e940160" +dependencies = [ + "cfg-if", + "pin-project-lite", + "tracing-core", +] + +[[package]] +name = "tracing-core" +version = "0.1.28" +source = "registry+https://github.com/rust-lang/crates.io-index" +checksum = "7b7358be39f2f274f322d2aaed611acc57f382e8eb1e5b48cb9ae30933495ce7" +dependencies = [ + "once_cell", +] + +[[package]] +name = "try-lock" +version = "0.2.3" +source = "registry+https://github.com/rust-lang/crates.io-index" +checksum = "59547bce71d9c38b83d9c0e92b6066c4253371f15005def0c30d9657f50c7642" + [[package]] name = "unicode-bidi" version = "0.3.8" @@ -272,29 +791,6 @@ dependencies = [ "tinyvec", ] -[[package]] -name = "untrusted" -version = "0.7.1" -source = "registry+https://github.com/rust-lang/crates.io-index" -checksum = "a156c684c91ea7d62626509bce3cb4e1d9ed5c4d978f7b4352658f96a4c26b4a" - -[[package]] -name = "ureq" -version = "2.5.0" -source = "registry+https://github.com/rust-lang/crates.io-index" -checksum = "b97acb4c28a254fd7a4aeec976c46a7fa404eac4d7c134b30c75144846d7cb8f" -dependencies = [ - "base64", - "chunked_transfer", - "flate2", - "log", - "once_cell", - "rustls", - "url", - "webpki", - "webpki-roots", -] - [[package]] name = "url" version = "2.2.2" @@ -307,6 +803,28 @@ dependencies = [ "percent-encoding", ] +[[package]] +name = "vcpkg" +version = "0.2.15" +source = "registry+https://github.com/rust-lang/crates.io-index" +checksum = "accd4ea62f7bb7a82fe23066fb0957d48ef677f6eeb8215f372f52e48bb32426" + +[[package]] +name = "want" +version = "0.3.0" +source = "registry+https://github.com/rust-lang/crates.io-index" +checksum = "1ce8a968cb1cd110d136ff8b819a556d6fb6d919363c61534f6860c7eb172ba0" +dependencies = [ + "log", + "try-lock", +] + +[[package]] +name = "wasi" +version = "0.11.0+wasi-snapshot-preview1" +source = "registry+https://github.com/rust-lang/crates.io-index" +checksum = "9c8d87e72b64a3b4db28d11ce29237c246188f4f51057d65a7eab63b7987e423" + [[package]] name = "wasm-bindgen" version = "0.2.81" @@ -332,6 +850,18 @@ dependencies = [ "wasm-bindgen-shared", ] +[[package]] +name = "wasm-bindgen-futures" +version = "0.4.31" +source = "registry+https://github.com/rust-lang/crates.io-index" +checksum = "de9a9cec1733468a8c657e57fa2413d2ae2c0129b95e87c5b72b8ace4d13f31f" +dependencies = [ + "cfg-if", + "js-sys", + "wasm-bindgen", + "web-sys", +] + [[package]] name = "wasm-bindgen-macro" version = "0.2.81" @@ -371,25 +901,6 @@ dependencies = [ "wasm-bindgen", ] -[[package]] -name = "webpki" -version = "0.22.0" -source = "registry+https://github.com/rust-lang/crates.io-index" -checksum = "f095d78192e208183081cc07bc5515ef55216397af48b873e5edcd72637fa1bd" -dependencies = [ - "ring", - "untrusted", -] - -[[package]] -name = "webpki-roots" -version = "0.22.4" -source = "registry+https://github.com/rust-lang/crates.io-index" -checksum = "f1c760f0d366a6c24a02ed7816e23e691f5d92291f94d15e836006fd11b04daf" -dependencies = [ - "webpki", -] - [[package]] name = "winapi" version = "0.3.9" @@ -411,3 +922,55 @@ name = "winapi-x86_64-pc-windows-gnu" version = "0.4.0" source = "registry+https://github.com/rust-lang/crates.io-index" checksum = "712e227841d057c1ee1cd2fb22fa7e5a5461ae8e48fa2ca79ec42cfc1931183f" + +[[package]] +name = "windows-sys" +version = "0.36.1" +source = "registry+https://github.com/rust-lang/crates.io-index" +checksum = "ea04155a16a59f9eab786fe12a4a450e75cdb175f9e0d80da1e17db09f55b8d2" +dependencies = [ + "windows_aarch64_msvc", + "windows_i686_gnu", + "windows_i686_msvc", + "windows_x86_64_gnu", + "windows_x86_64_msvc", +] + +[[package]] +name = "windows_aarch64_msvc" +version = "0.36.1" +source = "registry+https://github.com/rust-lang/crates.io-index" +checksum = "9bb8c3fd39ade2d67e9874ac4f3db21f0d710bee00fe7cab16949ec184eeaa47" + +[[package]] +name = "windows_i686_gnu" +version = "0.36.1" +source = "registry+https://github.com/rust-lang/crates.io-index" +checksum = "180e6ccf01daf4c426b846dfc66db1fc518f074baa793aa7d9b9aaeffad6a3b6" + +[[package]] +name = "windows_i686_msvc" +version = "0.36.1" +source = "registry+https://github.com/rust-lang/crates.io-index" +checksum = "e2e7917148b2812d1eeafaeb22a97e4813dfa60a3f8f78ebe204bcc88f12f024" + +[[package]] +name = "windows_x86_64_gnu" +version = "0.36.1" +source = "registry+https://github.com/rust-lang/crates.io-index" +checksum = "4dcd171b8776c41b97521e5da127a2d86ad280114807d0b2ab1e462bc764d9e1" + +[[package]] +name = "windows_x86_64_msvc" +version = "0.36.1" +source = "registry+https://github.com/rust-lang/crates.io-index" +checksum = "c811ca4a8c853ef420abd8592ba53ddbbac90410fab6903b3e79972a631f7680" + +[[package]] +name = "winreg" +version = "0.10.1" +source = "registry+https://github.com/rust-lang/crates.io-index" +checksum = "80d0f4e272c85def139476380b12f9ac60926689dd2e01d4923222f40580869d" +dependencies = [ + "winapi", +] diff --git a/examples/interactive/cli-platform/Cargo.toml b/examples/interactive/cli-platform/Cargo.toml index e4100ac485..d8c9b475d6 100644 --- a/examples/interactive/cli-platform/Cargo.toml +++ b/examples/interactive/cli-platform/Cargo.toml @@ -19,6 +19,6 @@ path = "src/main.rs" [dependencies] roc_std = { path = "../../../crates/roc_std" } libc = "0.2" -ureq = "2.5.0" +reqwest = {version="0.11.11", features=["blocking"]} [workspace] diff --git a/examples/interactive/cli-platform/Http.roc b/examples/interactive/cli-platform/Http.roc index 3368c35a39..c170153d74 100644 --- a/examples/interactive/cli-platform/Http.roc +++ b/examples/interactive/cli-platform/Http.roc @@ -3,7 +3,7 @@ interface Http Request, Method, Header, - Timeout, + TimeoutConfig, ProgressTracking, Body, Response, @@ -23,7 +23,7 @@ interface Http Request : InternalHttp.Request Method : InternalHttp.Method Header : InternalHttp.Header -Timeout : InternalHttp.Timeout +TimeoutConfig : InternalHttp.TimeoutConfig ProgressTracking : InternalHttp.ProgressTracking Body : InternalHttp.Body Response : InternalHttp.Response diff --git a/examples/interactive/cli-platform/InternalHttp.roc b/examples/interactive/cli-platform/InternalHttp.roc index 1811702ffc..b19481a1ec 100644 --- a/examples/interactive/cli-platform/InternalHttp.roc +++ b/examples/interactive/cli-platform/InternalHttp.roc @@ -1,5 +1,5 @@ interface InternalHttp - exposes [Request, Method, Header, Timeout, ProgressTracking, Part, Body, Response, Metadata, Error] + exposes [Request, Method, Header, TimeoutConfig, ProgressTracking, Part, Body, Response, Metadata, Error] imports [] Request : { @@ -7,7 +7,7 @@ Request : { headers : List Header, url : Str, body : Body, - timeout : Timeout, + timeout : TimeoutConfig, progressTracking : ProgressTracking, allowCookiesFromOtherDomains : Bool, } @@ -16,7 +16,8 @@ Method : [Options, Get, Post, Put, Delete, Head, Trace, Connect, Patch] Header : [Header Str Str] -Timeout : [Timeout F64, NoTimeout] +# Name is distinguished from the Timeout tag used in Response and Error +TimeoutConfig : [TimeoutMilliseconds U64, NoTimeout] ProgressTracking : [ProgressTrackingId Str, NoProgressTracking] diff --git a/examples/interactive/cli-platform/src/glue.rs b/examples/interactive/cli-platform/src/glue.rs index 444112716e..dd9d315640 100644 --- a/examples/interactive/cli-platform/src/glue.rs +++ b/examples/interactive/cli-platform/src/glue.rs @@ -45,39 +45,6 @@ pub union Error { _sizer: [u8; 16], } -#[cfg(any( - target_arch = "arm", - target_arch = "aarch64", - target_arch = "wasm32", - target_arch = "x86", - target_arch = "x86_64" -))] -#[derive(Clone, Copy, Eq, Ord, Hash, PartialEq, PartialOrd)] -#[repr(u8)] -pub enum discriminant_Part { - Part = 0, -} - -impl core::fmt::Debug for discriminant_Part { - fn fmt(&self, f: &mut core::fmt::Formatter<'_>) -> core::fmt::Result { - match self { - Self::Part => f.write_str("discriminant_Part::Part"), - } - } -} - -#[cfg(any( - target_arch = "arm", - target_arch = "aarch64", - target_arch = "wasm32", - target_arch = "x86", - target_arch = "x86_64" -))] -#[repr(C)] -pub union Part { - Part: core::mem::ManuallyDrop, -} - #[cfg(any( target_arch = "arm", target_arch = "aarch64", @@ -120,14 +87,14 @@ pub union Header { ))] #[derive(Clone, Copy, Eq, Ord, Hash, PartialEq, PartialOrd)] #[repr(u8)] -pub enum discriminant_U5 { +pub enum discriminant_U4 { MimeType = 0, } -impl core::fmt::Debug for discriminant_U5 { +impl core::fmt::Debug for discriminant_U4 { fn fmt(&self, f: &mut core::fmt::Formatter<'_>) -> core::fmt::Result { match self { - Self::MimeType => f.write_str("discriminant_U5::MimeType"), + Self::MimeType => f.write_str("discriminant_U4::MimeType"), } } } @@ -140,7 +107,7 @@ impl core::fmt::Debug for discriminant_U5 { target_arch = "x86_64" ))] #[repr(C)] -pub union U5 { +pub union U4 { MimeType: core::mem::ManuallyDrop, } @@ -183,14 +150,14 @@ pub union Body { ))] #[derive(Clone, Copy, Eq, Ord, Hash, PartialEq, PartialOrd)] #[repr(u8)] -pub enum discriminant_U3 { +pub enum discriminant_U2 { MimeType = 0, } -impl core::fmt::Debug for discriminant_U3 { +impl core::fmt::Debug for discriminant_U2 { fn fmt(&self, f: &mut core::fmt::Formatter<'_>) -> core::fmt::Result { match self { - Self::MimeType => f.write_str("discriminant_U3::MimeType"), + Self::MimeType => f.write_str("discriminant_U2::MimeType"), } } } @@ -203,7 +170,7 @@ impl core::fmt::Debug for discriminant_U3 { target_arch = "x86_64" ))] #[repr(C)] -pub union U3 { +pub union U2 { MimeType: core::mem::ManuallyDrop, } @@ -245,57 +212,19 @@ pub union Response { _sizer: [u8; 56], } -#[cfg(any( - target_arch = "arm", - target_arch = "aarch64", - target_arch = "x86", - target_arch = "x86_64" -))] -#[derive(Clone, Debug, PartialEq, PartialOrd)] +#[cfg(any(target_arch = "arm", target_arch = "wasm32"))] +#[derive(Clone, Debug, Eq, Ord, Hash, PartialEq, PartialOrd)] #[repr(C)] pub struct Request { + pub timeout: TimeoutConfig, pub body: Body, pub headers: roc_std::RocList
, pub progressTracking: ProgressTracking, - pub timeout: Timeout, pub url: roc_std::RocStr, pub allowCookiesFromOtherDomains: bool, pub method: Method, } -#[cfg(any( - target_arch = "arm", - target_arch = "aarch64", - target_arch = "wasm32", - target_arch = "x86", - target_arch = "x86_64" -))] -#[derive(Clone, Copy, Eq, Ord, Hash, PartialEq, PartialOrd)] -#[repr(u8)] -pub enum discriminant_U8 { - MimeType = 0, -} - -impl core::fmt::Debug for discriminant_U8 { - fn fmt(&self, f: &mut core::fmt::Formatter<'_>) -> core::fmt::Result { - match self { - Self::MimeType => f.write_str("discriminant_U8::MimeType"), - } - } -} - -#[cfg(any( - target_arch = "arm", - target_arch = "aarch64", - target_arch = "wasm32", - target_arch = "x86", - target_arch = "x86_64" -))] -#[repr(C)] -pub union U8 { - MimeType: core::mem::ManuallyDrop, -} - #[cfg(any( target_arch = "arm", target_arch = "aarch64", @@ -371,14 +300,14 @@ pub union U6 { ))] #[derive(Clone, Copy, Eq, Ord, Hash, PartialEq, PartialOrd)] #[repr(u8)] -pub enum discriminant_U4 { +pub enum discriminant_U5 { MimeType = 0, } -impl core::fmt::Debug for discriminant_U4 { +impl core::fmt::Debug for discriminant_U5 { fn fmt(&self, f: &mut core::fmt::Formatter<'_>) -> core::fmt::Result { match self { - Self::MimeType => f.write_str("discriminant_U4::MimeType"), + Self::MimeType => f.write_str("discriminant_U5::MimeType"), } } } @@ -391,7 +320,7 @@ impl core::fmt::Debug for discriminant_U4 { target_arch = "x86_64" ))] #[repr(C)] -pub union U4 { +pub union U5 { MimeType: core::mem::ManuallyDrop, } @@ -404,14 +333,14 @@ pub union U4 { ))] #[derive(Clone, Copy, Eq, Ord, Hash, PartialEq, PartialOrd)] #[repr(u8)] -pub enum discriminant_U2 { +pub enum discriminant_U3 { MimeType = 0, } -impl core::fmt::Debug for discriminant_U2 { +impl core::fmt::Debug for discriminant_U3 { fn fmt(&self, f: &mut core::fmt::Formatter<'_>) -> core::fmt::Result { match self { - Self::MimeType => f.write_str("discriminant_U2::MimeType"), + Self::MimeType => f.write_str("discriminant_U3::MimeType"), } } } @@ -424,24 +353,10 @@ impl core::fmt::Debug for discriminant_U2 { target_arch = "x86_64" ))] #[repr(C)] -pub union U2 { +pub union U3 { MimeType: core::mem::ManuallyDrop, } -#[cfg(any( - target_arch = "arm", - target_arch = "aarch64", - target_arch = "wasm32", - target_arch = "x86", - target_arch = "x86_64" -))] -#[derive(Clone, Debug, Default, Eq, Ord, Hash, PartialEq, PartialOrd)] -#[repr(C)] -struct Part_Part { - pub f0: roc_std::RocStr, - pub f1: roc_std::RocList, -} - #[cfg(any( target_arch = "arm", target_arch = "aarch64", @@ -523,36 +438,6 @@ impl core::fmt::Debug for Method { } } -#[cfg(any( - target_arch = "arm", - target_arch = "aarch64", - target_arch = "wasm32", - target_arch = "x86", - target_arch = "x86_64" -))] -#[derive(Clone, Copy, Eq, Ord, Hash, PartialEq, PartialOrd)] -#[repr(u8)] -pub enum discriminant_Timeout { - NoTimeout = 0, - Timeout = 1, -} - -impl core::fmt::Debug for discriminant_Timeout { - fn fmt(&self, f: &mut core::fmt::Formatter<'_>) -> core::fmt::Result { - match self { - Self::NoTimeout => f.write_str("discriminant_Timeout::NoTimeout"), - Self::Timeout => f.write_str("discriminant_Timeout::Timeout"), - } - } -} - -#[cfg(any(target_arch = "arm", target_arch = "x86"))] -#[repr(C)] -pub union Timeout { - Timeout: f64, - _sizer: [u8; 12], -} - #[cfg(any( target_arch = "arm", target_arch = "aarch64", @@ -648,6 +533,43 @@ pub union U1 { MimeType: core::mem::ManuallyDrop, } +#[cfg(any( + target_arch = "arm", + target_arch = "aarch64", + target_arch = "wasm32", + target_arch = "x86", + target_arch = "x86_64" +))] +#[derive(Clone, Copy, Eq, Ord, Hash, PartialEq, PartialOrd)] +#[repr(u8)] +pub enum discriminant_TimeoutConfig { + NoTimeout = 0, + TimeoutMilliseconds = 1, +} + +impl core::fmt::Debug for discriminant_TimeoutConfig { + fn fmt(&self, f: &mut core::fmt::Formatter<'_>) -> core::fmt::Result { + match self { + Self::NoTimeout => f.write_str("discriminant_TimeoutConfig::NoTimeout"), + Self::TimeoutMilliseconds => { + f.write_str("discriminant_TimeoutConfig::TimeoutMilliseconds") + } + } + } +} + +#[cfg(any( + target_arch = "arm", + target_arch = "aarch64", + target_arch = "wasm32", + target_arch = "x86_64" +))] +#[repr(C)] +pub union TimeoutConfig { + TimeoutMilliseconds: u64, + _sizer: [u8; 16], +} + #[cfg(any(target_arch = "aarch64", target_arch = "x86_64"))] #[repr(C)] pub union Error { @@ -673,15 +595,17 @@ pub union Response { _sizer: [u8; 112], } -#[cfg(any( - target_arch = "aarch64", - target_arch = "wasm32", - target_arch = "x86_64" -))] +#[cfg(any(target_arch = "aarch64", target_arch = "x86", target_arch = "x86_64"))] +#[derive(Clone, Debug, Eq, Ord, Hash, PartialEq, PartialOrd)] #[repr(C)] -pub union Timeout { - Timeout: f64, - _sizer: [u8; 16], +pub struct Request { + pub body: Body, + pub headers: roc_std::RocList
, + pub progressTracking: ProgressTracking, + pub timeout: TimeoutConfig, + pub url: roc_std::RocStr, + pub allowCookiesFromOtherDomains: bool, + pub method: Method, } #[cfg(any(target_arch = "aarch64", target_arch = "x86_64"))] @@ -691,17 +615,11 @@ pub union ProgressTracking { _sizer: [u8; 32], } -#[cfg(target_arch = "wasm32")] -#[derive(Clone, Debug, PartialEq, PartialOrd)] +#[cfg(target_arch = "x86")] #[repr(C)] -pub struct Request { - pub timeout: Timeout, - pub body: Body, - pub headers: roc_std::RocList
, - pub progressTracking: ProgressTracking, - pub url: roc_std::RocStr, - pub allowCookiesFromOtherDomains: bool, - pub method: Method, +pub union TimeoutConfig { + TimeoutMilliseconds: u64, + _sizer: [u8; 12], } impl Error { @@ -1194,249 +1112,6 @@ impl core::fmt::Debug for Error { } } -impl Part { - #[cfg(any(target_arch = "arm", target_arch = "wasm32", target_arch = "x86"))] - /// Returns which variant this tag union holds. Note that this never includes a payload! - pub fn discriminant(&self) -> discriminant_Part { - unsafe { - let bytes = core::mem::transmute::<&Self, &[u8; core::mem::size_of::()]>(self); - - core::mem::transmute::(*bytes.as_ptr().add(23)) - } - } - - #[cfg(any(target_arch = "arm", target_arch = "wasm32", target_arch = "x86"))] - /// Internal helper - fn set_discriminant(&mut self, discriminant: discriminant_Part) { - let discriminant_ptr: *mut discriminant_Part = (self as *mut Part).cast(); - - unsafe { - *(discriminant_ptr.add(23)) = discriminant; - } - } - - #[cfg(any( - target_arch = "arm", - target_arch = "aarch64", - target_arch = "wasm32", - target_arch = "x86", - target_arch = "x86_64" - ))] - /// Construct a tag named `Part`, with the appropriate payload - pub fn Part(arg0: roc_std::RocStr, arg1: roc_std::RocList) -> Self { - let mut answer = Self { - Part: core::mem::ManuallyDrop::new(Part_Part { f0: arg0, f1: arg1 }), - }; - - answer.set_discriminant(discriminant_Part::Part); - - answer - } - - #[cfg(any( - target_arch = "arm", - target_arch = "aarch64", - target_arch = "wasm32", - target_arch = "x86", - target_arch = "x86_64" - ))] - /// Unsafely assume the given `Part` has a `.discriminant()` of `Part` and convert it to `Part`'s payload. - /// (Always examine `.discriminant()` first to make sure this is the correct variant!) - /// Panics in debug builds if the `.discriminant()` doesn't return `Part`. - pub unsafe fn into_Part(mut self) -> (roc_std::RocStr, roc_std::RocList) { - debug_assert_eq!(self.discriminant(), discriminant_Part::Part); - - let payload = core::mem::ManuallyDrop::take(&mut self.Part); - - (payload.f0, payload.f1) - } - - #[cfg(any( - target_arch = "arm", - target_arch = "aarch64", - target_arch = "wasm32", - target_arch = "x86", - target_arch = "x86_64" - ))] - /// Unsafely assume the given `Part` has a `.discriminant()` of `Part` and return its payload. - /// (Always examine `.discriminant()` first to make sure this is the correct variant!) - /// Panics in debug builds if the `.discriminant()` doesn't return `Part`. - pub unsafe fn as_Part(&self) -> (&roc_std::RocStr, &roc_std::RocList) { - debug_assert_eq!(self.discriminant(), discriminant_Part::Part); - - let payload = &self.Part; - - (&payload.f0, &payload.f1) - } - - #[cfg(any(target_arch = "aarch64", target_arch = "x86_64"))] - /// Returns which variant this tag union holds. Note that this never includes a payload! - pub fn discriminant(&self) -> discriminant_Part { - unsafe { - let bytes = core::mem::transmute::<&Self, &[u8; core::mem::size_of::()]>(self); - - core::mem::transmute::(*bytes.as_ptr().add(47)) - } - } - - #[cfg(any(target_arch = "aarch64", target_arch = "x86_64"))] - /// Internal helper - fn set_discriminant(&mut self, discriminant: discriminant_Part) { - let discriminant_ptr: *mut discriminant_Part = (self as *mut Part).cast(); - - unsafe { - *(discriminant_ptr.add(47)) = discriminant; - } - } -} - -impl Drop for Part { - #[cfg(any( - target_arch = "arm", - target_arch = "aarch64", - target_arch = "wasm32", - target_arch = "x86", - target_arch = "x86_64" - ))] - fn drop(&mut self) { - // Drop the payloads - match self.discriminant() { - discriminant_Part::Part => unsafe { core::mem::ManuallyDrop::drop(&mut self.Part) }, - } - } -} - -impl Eq for Part {} - -impl PartialEq for Part { - #[cfg(any( - target_arch = "arm", - target_arch = "aarch64", - target_arch = "wasm32", - target_arch = "x86", - target_arch = "x86_64" - ))] - fn eq(&self, other: &Self) -> bool { - if self.discriminant() != other.discriminant() { - return false; - } - - unsafe { - match self.discriminant() { - discriminant_Part::Part => self.Part == other.Part, - } - } - } -} - -impl PartialOrd for Part { - #[cfg(any( - target_arch = "arm", - target_arch = "aarch64", - target_arch = "wasm32", - target_arch = "x86", - target_arch = "x86_64" - ))] - fn partial_cmp(&self, other: &Self) -> Option { - match self.discriminant().partial_cmp(&other.discriminant()) { - Some(core::cmp::Ordering::Equal) => {} - not_eq => return not_eq, - } - - unsafe { - match self.discriminant() { - discriminant_Part::Part => self.Part.partial_cmp(&other.Part), - } - } - } -} - -impl Ord for Part { - #[cfg(any( - target_arch = "arm", - target_arch = "aarch64", - target_arch = "wasm32", - target_arch = "x86", - target_arch = "x86_64" - ))] - fn cmp(&self, other: &Self) -> core::cmp::Ordering { - match self.discriminant().cmp(&other.discriminant()) { - core::cmp::Ordering::Equal => {} - not_eq => return not_eq, - } - - unsafe { - match self.discriminant() { - discriminant_Part::Part => self.Part.cmp(&other.Part), - } - } - } -} - -impl Clone for Part { - #[cfg(any( - target_arch = "arm", - target_arch = "aarch64", - target_arch = "wasm32", - target_arch = "x86", - target_arch = "x86_64" - ))] - fn clone(&self) -> Self { - let mut answer = unsafe { - match self.discriminant() { - discriminant_Part::Part => Self { - Part: self.Part.clone(), - }, - } - }; - - answer.set_discriminant(self.discriminant()); - - answer - } -} - -impl core::hash::Hash for Part { - #[cfg(any( - target_arch = "arm", - target_arch = "aarch64", - target_arch = "wasm32", - target_arch = "x86", - target_arch = "x86_64" - ))] - fn hash(&self, state: &mut H) { - match self.discriminant() { - discriminant_Part::Part => unsafe { - discriminant_Part::Part.hash(state); - self.Part.hash(state); - }, - } - } -} - -impl core::fmt::Debug for Part { - #[cfg(any( - target_arch = "arm", - target_arch = "aarch64", - target_arch = "wasm32", - target_arch = "x86", - target_arch = "x86_64" - ))] - fn fmt(&self, f: &mut core::fmt::Formatter<'_>) -> core::fmt::Result { - f.write_str("Part::")?; - - unsafe { - match self.discriminant() { - discriminant_Part::Part => f - .debug_tuple("Part") - .field(&(&*self.Part).f0) - .field(&(&*self.Part).f1) - .finish(), - } - } - } -} - impl Header { #[cfg(any(target_arch = "arm", target_arch = "wasm32", target_arch = "x86"))] /// Returns which variant this tag union holds. Note that this never includes a payload! @@ -1682,21 +1357,21 @@ impl core::fmt::Debug for Header { } } -impl U5 { +impl U4 { #[cfg(any(target_arch = "arm", target_arch = "wasm32", target_arch = "x86"))] /// Returns which variant this tag union holds. Note that this never includes a payload! - pub fn discriminant(&self) -> discriminant_U5 { + pub fn discriminant(&self) -> discriminant_U4 { unsafe { let bytes = core::mem::transmute::<&Self, &[u8; core::mem::size_of::()]>(self); - core::mem::transmute::(*bytes.as_ptr().add(11)) + core::mem::transmute::(*bytes.as_ptr().add(11)) } } #[cfg(any(target_arch = "arm", target_arch = "wasm32", target_arch = "x86"))] /// Internal helper - fn set_discriminant(&mut self, discriminant: discriminant_U5) { - let discriminant_ptr: *mut discriminant_U5 = (self as *mut U5).cast(); + fn set_discriminant(&mut self, discriminant: discriminant_U4) { + let discriminant_ptr: *mut discriminant_U4 = (self as *mut U4).cast(); unsafe { *(discriminant_ptr.add(11)) = discriminant; @@ -1716,7 +1391,7 @@ impl U5 { MimeType: core::mem::ManuallyDrop::new(arg), }; - answer.set_discriminant(discriminant_U5::MimeType); + answer.set_discriminant(discriminant_U4::MimeType); answer } @@ -1728,11 +1403,11 @@ impl U5 { target_arch = "x86", target_arch = "x86_64" ))] - /// Unsafely assume the given `U5` has a `.discriminant()` of `MimeType` and convert it to `MimeType`'s payload. + /// Unsafely assume the given `U4` has a `.discriminant()` of `MimeType` and convert it to `MimeType`'s payload. /// (Always examine `.discriminant()` first to make sure this is the correct variant!) /// Panics in debug builds if the `.discriminant()` doesn't return `MimeType`. pub unsafe fn into_MimeType(mut self) -> roc_std::RocStr { - debug_assert_eq!(self.discriminant(), discriminant_U5::MimeType); + debug_assert_eq!(self.discriminant(), discriminant_U4::MimeType); let payload = core::mem::ManuallyDrop::take(&mut self.MimeType); @@ -1746,11 +1421,11 @@ impl U5 { target_arch = "x86", target_arch = "x86_64" ))] - /// Unsafely assume the given `U5` has a `.discriminant()` of `MimeType` and return its payload. + /// Unsafely assume the given `U4` has a `.discriminant()` of `MimeType` and return its payload. /// (Always examine `.discriminant()` first to make sure this is the correct variant!) /// Panics in debug builds if the `.discriminant()` doesn't return `MimeType`. pub unsafe fn as_MimeType(&self) -> &roc_std::RocStr { - debug_assert_eq!(self.discriminant(), discriminant_U5::MimeType); + debug_assert_eq!(self.discriminant(), discriminant_U4::MimeType); let payload = &self.MimeType; @@ -1759,18 +1434,18 @@ impl U5 { #[cfg(any(target_arch = "aarch64", target_arch = "x86_64"))] /// Returns which variant this tag union holds. Note that this never includes a payload! - pub fn discriminant(&self) -> discriminant_U5 { + pub fn discriminant(&self) -> discriminant_U4 { unsafe { let bytes = core::mem::transmute::<&Self, &[u8; core::mem::size_of::()]>(self); - core::mem::transmute::(*bytes.as_ptr().add(23)) + core::mem::transmute::(*bytes.as_ptr().add(23)) } } #[cfg(any(target_arch = "aarch64", target_arch = "x86_64"))] /// Internal helper - fn set_discriminant(&mut self, discriminant: discriminant_U5) { - let discriminant_ptr: *mut discriminant_U5 = (self as *mut U5).cast(); + fn set_discriminant(&mut self, discriminant: discriminant_U4) { + let discriminant_ptr: *mut discriminant_U4 = (self as *mut U4).cast(); unsafe { *(discriminant_ptr.add(23)) = discriminant; @@ -1778,7 +1453,7 @@ impl U5 { } } -impl Drop for U5 { +impl Drop for U4 { #[cfg(any( target_arch = "arm", target_arch = "aarch64", @@ -1789,16 +1464,16 @@ impl Drop for U5 { fn drop(&mut self) { // Drop the payloads match self.discriminant() { - discriminant_U5::MimeType => unsafe { + discriminant_U4::MimeType => unsafe { core::mem::ManuallyDrop::drop(&mut self.MimeType) }, } } } -impl Eq for U5 {} +impl Eq for U4 {} -impl PartialEq for U5 { +impl PartialEq for U4 { #[cfg(any( target_arch = "arm", target_arch = "aarch64", @@ -1813,13 +1488,13 @@ impl PartialEq for U5 { unsafe { match self.discriminant() { - discriminant_U5::MimeType => self.MimeType == other.MimeType, + discriminant_U4::MimeType => self.MimeType == other.MimeType, } } } } -impl PartialOrd for U5 { +impl PartialOrd for U4 { #[cfg(any( target_arch = "arm", target_arch = "aarch64", @@ -1835,13 +1510,13 @@ impl PartialOrd for U5 { unsafe { match self.discriminant() { - discriminant_U5::MimeType => self.MimeType.partial_cmp(&other.MimeType), + discriminant_U4::MimeType => self.MimeType.partial_cmp(&other.MimeType), } } } } -impl Ord for U5 { +impl Ord for U4 { #[cfg(any( target_arch = "arm", target_arch = "aarch64", @@ -1857,13 +1532,13 @@ impl Ord for U5 { unsafe { match self.discriminant() { - discriminant_U5::MimeType => self.MimeType.cmp(&other.MimeType), + discriminant_U4::MimeType => self.MimeType.cmp(&other.MimeType), } } } } -impl Clone for U5 { +impl Clone for U4 { #[cfg(any( target_arch = "arm", target_arch = "aarch64", @@ -1874,7 +1549,7 @@ impl Clone for U5 { fn clone(&self) -> Self { let mut answer = unsafe { match self.discriminant() { - discriminant_U5::MimeType => Self { + discriminant_U4::MimeType => Self { MimeType: self.MimeType.clone(), }, } @@ -1886,7 +1561,7 @@ impl Clone for U5 { } } -impl core::hash::Hash for U5 { +impl core::hash::Hash for U4 { #[cfg(any( target_arch = "arm", target_arch = "aarch64", @@ -1896,15 +1571,15 @@ impl core::hash::Hash for U5 { ))] fn hash(&self, state: &mut H) { match self.discriminant() { - discriminant_U5::MimeType => unsafe { - discriminant_U5::MimeType.hash(state); + discriminant_U4::MimeType => unsafe { + discriminant_U4::MimeType.hash(state); self.MimeType.hash(state); }, } } } -impl core::fmt::Debug for U5 { +impl core::fmt::Debug for U4 { #[cfg(any( target_arch = "arm", target_arch = "aarch64", @@ -1913,11 +1588,11 @@ impl core::fmt::Debug for U5 { target_arch = "x86_64" ))] fn fmt(&self, f: &mut core::fmt::Formatter<'_>) -> core::fmt::Result { - f.write_str("U5::")?; + f.write_str("U4::")?; unsafe { match self.discriminant() { - discriminant_U5::MimeType => { + discriminant_U4::MimeType => { f.debug_tuple("MimeType").field(&*self.MimeType).finish() } } @@ -2224,21 +1899,21 @@ impl core::fmt::Debug for Body { } } -impl U3 { +impl U2 { #[cfg(any(target_arch = "arm", target_arch = "wasm32", target_arch = "x86"))] /// Returns which variant this tag union holds. Note that this never includes a payload! - pub fn discriminant(&self) -> discriminant_U3 { + pub fn discriminant(&self) -> discriminant_U2 { unsafe { let bytes = core::mem::transmute::<&Self, &[u8; core::mem::size_of::()]>(self); - core::mem::transmute::(*bytes.as_ptr().add(11)) + core::mem::transmute::(*bytes.as_ptr().add(11)) } } #[cfg(any(target_arch = "arm", target_arch = "wasm32", target_arch = "x86"))] /// Internal helper - fn set_discriminant(&mut self, discriminant: discriminant_U3) { - let discriminant_ptr: *mut discriminant_U3 = (self as *mut U3).cast(); + fn set_discriminant(&mut self, discriminant: discriminant_U2) { + let discriminant_ptr: *mut discriminant_U2 = (self as *mut U2).cast(); unsafe { *(discriminant_ptr.add(11)) = discriminant; @@ -2258,7 +1933,7 @@ impl U3 { MimeType: core::mem::ManuallyDrop::new(arg), }; - answer.set_discriminant(discriminant_U3::MimeType); + answer.set_discriminant(discriminant_U2::MimeType); answer } @@ -2270,11 +1945,11 @@ impl U3 { target_arch = "x86", target_arch = "x86_64" ))] - /// Unsafely assume the given `U3` has a `.discriminant()` of `MimeType` and convert it to `MimeType`'s payload. + /// Unsafely assume the given `U2` has a `.discriminant()` of `MimeType` and convert it to `MimeType`'s payload. /// (Always examine `.discriminant()` first to make sure this is the correct variant!) /// Panics in debug builds if the `.discriminant()` doesn't return `MimeType`. pub unsafe fn into_MimeType(mut self) -> roc_std::RocStr { - debug_assert_eq!(self.discriminant(), discriminant_U3::MimeType); + debug_assert_eq!(self.discriminant(), discriminant_U2::MimeType); let payload = core::mem::ManuallyDrop::take(&mut self.MimeType); @@ -2288,11 +1963,11 @@ impl U3 { target_arch = "x86", target_arch = "x86_64" ))] - /// Unsafely assume the given `U3` has a `.discriminant()` of `MimeType` and return its payload. + /// Unsafely assume the given `U2` has a `.discriminant()` of `MimeType` and return its payload. /// (Always examine `.discriminant()` first to make sure this is the correct variant!) /// Panics in debug builds if the `.discriminant()` doesn't return `MimeType`. pub unsafe fn as_MimeType(&self) -> &roc_std::RocStr { - debug_assert_eq!(self.discriminant(), discriminant_U3::MimeType); + debug_assert_eq!(self.discriminant(), discriminant_U2::MimeType); let payload = &self.MimeType; @@ -2301,18 +1976,18 @@ impl U3 { #[cfg(any(target_arch = "aarch64", target_arch = "x86_64"))] /// Returns which variant this tag union holds. Note that this never includes a payload! - pub fn discriminant(&self) -> discriminant_U3 { + pub fn discriminant(&self) -> discriminant_U2 { unsafe { let bytes = core::mem::transmute::<&Self, &[u8; core::mem::size_of::()]>(self); - core::mem::transmute::(*bytes.as_ptr().add(23)) + core::mem::transmute::(*bytes.as_ptr().add(23)) } } #[cfg(any(target_arch = "aarch64", target_arch = "x86_64"))] /// Internal helper - fn set_discriminant(&mut self, discriminant: discriminant_U3) { - let discriminant_ptr: *mut discriminant_U3 = (self as *mut U3).cast(); + fn set_discriminant(&mut self, discriminant: discriminant_U2) { + let discriminant_ptr: *mut discriminant_U2 = (self as *mut U2).cast(); unsafe { *(discriminant_ptr.add(23)) = discriminant; @@ -2320,7 +1995,7 @@ impl U3 { } } -impl Drop for U3 { +impl Drop for U2 { #[cfg(any( target_arch = "arm", target_arch = "aarch64", @@ -2331,16 +2006,16 @@ impl Drop for U3 { fn drop(&mut self) { // Drop the payloads match self.discriminant() { - discriminant_U3::MimeType => unsafe { + discriminant_U2::MimeType => unsafe { core::mem::ManuallyDrop::drop(&mut self.MimeType) }, } } } -impl Eq for U3 {} +impl Eq for U2 {} -impl PartialEq for U3 { +impl PartialEq for U2 { #[cfg(any( target_arch = "arm", target_arch = "aarch64", @@ -2355,13 +2030,13 @@ impl PartialEq for U3 { unsafe { match self.discriminant() { - discriminant_U3::MimeType => self.MimeType == other.MimeType, + discriminant_U2::MimeType => self.MimeType == other.MimeType, } } } } -impl PartialOrd for U3 { +impl PartialOrd for U2 { #[cfg(any( target_arch = "arm", target_arch = "aarch64", @@ -2377,13 +2052,13 @@ impl PartialOrd for U3 { unsafe { match self.discriminant() { - discriminant_U3::MimeType => self.MimeType.partial_cmp(&other.MimeType), + discriminant_U2::MimeType => self.MimeType.partial_cmp(&other.MimeType), } } } } -impl Ord for U3 { +impl Ord for U2 { #[cfg(any( target_arch = "arm", target_arch = "aarch64", @@ -2399,13 +2074,13 @@ impl Ord for U3 { unsafe { match self.discriminant() { - discriminant_U3::MimeType => self.MimeType.cmp(&other.MimeType), + discriminant_U2::MimeType => self.MimeType.cmp(&other.MimeType), } } } } -impl Clone for U3 { +impl Clone for U2 { #[cfg(any( target_arch = "arm", target_arch = "aarch64", @@ -2416,7 +2091,7 @@ impl Clone for U3 { fn clone(&self) -> Self { let mut answer = unsafe { match self.discriminant() { - discriminant_U3::MimeType => Self { + discriminant_U2::MimeType => Self { MimeType: self.MimeType.clone(), }, } @@ -2428,7 +2103,7 @@ impl Clone for U3 { } } -impl core::hash::Hash for U3 { +impl core::hash::Hash for U2 { #[cfg(any( target_arch = "arm", target_arch = "aarch64", @@ -2438,15 +2113,15 @@ impl core::hash::Hash for U3 { ))] fn hash(&self, state: &mut H) { match self.discriminant() { - discriminant_U3::MimeType => unsafe { - discriminant_U3::MimeType.hash(state); + discriminant_U2::MimeType => unsafe { + discriminant_U2::MimeType.hash(state); self.MimeType.hash(state); }, } } } -impl core::fmt::Debug for U3 { +impl core::fmt::Debug for U2 { #[cfg(any( target_arch = "arm", target_arch = "aarch64", @@ -2455,11 +2130,11 @@ impl core::fmt::Debug for U3 { target_arch = "x86_64" ))] fn fmt(&self, f: &mut core::fmt::Formatter<'_>) -> core::fmt::Result { - f.write_str("U3::")?; + f.write_str("U2::")?; unsafe { match self.discriminant() { - discriminant_U3::MimeType => { + discriminant_U2::MimeType => { f.debug_tuple("MimeType").field(&*self.MimeType).finish() } } @@ -2968,249 +2643,6 @@ impl core::fmt::Debug for Response { } } -impl U8 { - #[cfg(any(target_arch = "arm", target_arch = "wasm32", target_arch = "x86"))] - /// Returns which variant this tag union holds. Note that this never includes a payload! - pub fn discriminant(&self) -> discriminant_U8 { - unsafe { - let bytes = core::mem::transmute::<&Self, &[u8; core::mem::size_of::()]>(self); - - core::mem::transmute::(*bytes.as_ptr().add(11)) - } - } - - #[cfg(any(target_arch = "arm", target_arch = "wasm32", target_arch = "x86"))] - /// Internal helper - fn set_discriminant(&mut self, discriminant: discriminant_U8) { - let discriminant_ptr: *mut discriminant_U8 = (self as *mut U8).cast(); - - unsafe { - *(discriminant_ptr.add(11)) = discriminant; - } - } - - #[cfg(any( - target_arch = "arm", - target_arch = "aarch64", - target_arch = "wasm32", - target_arch = "x86", - target_arch = "x86_64" - ))] - /// Construct a tag named `MimeType`, with the appropriate payload - pub fn MimeType(arg: roc_std::RocStr) -> Self { - let mut answer = Self { - MimeType: core::mem::ManuallyDrop::new(arg), - }; - - answer.set_discriminant(discriminant_U8::MimeType); - - answer - } - - #[cfg(any( - target_arch = "arm", - target_arch = "aarch64", - target_arch = "wasm32", - target_arch = "x86", - target_arch = "x86_64" - ))] - /// Unsafely assume the given `U8` has a `.discriminant()` of `MimeType` and convert it to `MimeType`'s payload. - /// (Always examine `.discriminant()` first to make sure this is the correct variant!) - /// Panics in debug builds if the `.discriminant()` doesn't return `MimeType`. - pub unsafe fn into_MimeType(mut self) -> roc_std::RocStr { - debug_assert_eq!(self.discriminant(), discriminant_U8::MimeType); - - let payload = core::mem::ManuallyDrop::take(&mut self.MimeType); - - payload - } - - #[cfg(any( - target_arch = "arm", - target_arch = "aarch64", - target_arch = "wasm32", - target_arch = "x86", - target_arch = "x86_64" - ))] - /// Unsafely assume the given `U8` has a `.discriminant()` of `MimeType` and return its payload. - /// (Always examine `.discriminant()` first to make sure this is the correct variant!) - /// Panics in debug builds if the `.discriminant()` doesn't return `MimeType`. - pub unsafe fn as_MimeType(&self) -> &roc_std::RocStr { - debug_assert_eq!(self.discriminant(), discriminant_U8::MimeType); - - let payload = &self.MimeType; - - &payload - } - - #[cfg(any(target_arch = "aarch64", target_arch = "x86_64"))] - /// Returns which variant this tag union holds. Note that this never includes a payload! - pub fn discriminant(&self) -> discriminant_U8 { - unsafe { - let bytes = core::mem::transmute::<&Self, &[u8; core::mem::size_of::()]>(self); - - core::mem::transmute::(*bytes.as_ptr().add(23)) - } - } - - #[cfg(any(target_arch = "aarch64", target_arch = "x86_64"))] - /// Internal helper - fn set_discriminant(&mut self, discriminant: discriminant_U8) { - let discriminant_ptr: *mut discriminant_U8 = (self as *mut U8).cast(); - - unsafe { - *(discriminant_ptr.add(23)) = discriminant; - } - } -} - -impl Drop for U8 { - #[cfg(any( - target_arch = "arm", - target_arch = "aarch64", - target_arch = "wasm32", - target_arch = "x86", - target_arch = "x86_64" - ))] - fn drop(&mut self) { - // Drop the payloads - match self.discriminant() { - discriminant_U8::MimeType => unsafe { - core::mem::ManuallyDrop::drop(&mut self.MimeType) - }, - } - } -} - -impl Eq for U8 {} - -impl PartialEq for U8 { - #[cfg(any( - target_arch = "arm", - target_arch = "aarch64", - target_arch = "wasm32", - target_arch = "x86", - target_arch = "x86_64" - ))] - fn eq(&self, other: &Self) -> bool { - if self.discriminant() != other.discriminant() { - return false; - } - - unsafe { - match self.discriminant() { - discriminant_U8::MimeType => self.MimeType == other.MimeType, - } - } - } -} - -impl PartialOrd for U8 { - #[cfg(any( - target_arch = "arm", - target_arch = "aarch64", - target_arch = "wasm32", - target_arch = "x86", - target_arch = "x86_64" - ))] - fn partial_cmp(&self, other: &Self) -> Option { - match self.discriminant().partial_cmp(&other.discriminant()) { - Some(core::cmp::Ordering::Equal) => {} - not_eq => return not_eq, - } - - unsafe { - match self.discriminant() { - discriminant_U8::MimeType => self.MimeType.partial_cmp(&other.MimeType), - } - } - } -} - -impl Ord for U8 { - #[cfg(any( - target_arch = "arm", - target_arch = "aarch64", - target_arch = "wasm32", - target_arch = "x86", - target_arch = "x86_64" - ))] - fn cmp(&self, other: &Self) -> core::cmp::Ordering { - match self.discriminant().cmp(&other.discriminant()) { - core::cmp::Ordering::Equal => {} - not_eq => return not_eq, - } - - unsafe { - match self.discriminant() { - discriminant_U8::MimeType => self.MimeType.cmp(&other.MimeType), - } - } - } -} - -impl Clone for U8 { - #[cfg(any( - target_arch = "arm", - target_arch = "aarch64", - target_arch = "wasm32", - target_arch = "x86", - target_arch = "x86_64" - ))] - fn clone(&self) -> Self { - let mut answer = unsafe { - match self.discriminant() { - discriminant_U8::MimeType => Self { - MimeType: self.MimeType.clone(), - }, - } - }; - - answer.set_discriminant(self.discriminant()); - - answer - } -} - -impl core::hash::Hash for U8 { - #[cfg(any( - target_arch = "arm", - target_arch = "aarch64", - target_arch = "wasm32", - target_arch = "x86", - target_arch = "x86_64" - ))] - fn hash(&self, state: &mut H) { - match self.discriminant() { - discriminant_U8::MimeType => unsafe { - discriminant_U8::MimeType.hash(state); - self.MimeType.hash(state); - }, - } - } -} - -impl core::fmt::Debug for U8 { - #[cfg(any( - target_arch = "arm", - target_arch = "aarch64", - target_arch = "wasm32", - target_arch = "x86", - target_arch = "x86_64" - ))] - fn fmt(&self, f: &mut core::fmt::Formatter<'_>) -> core::fmt::Result { - f.write_str("U8::")?; - - unsafe { - match self.discriminant() { - discriminant_U8::MimeType => { - f.debug_tuple("MimeType").field(&*self.MimeType).finish() - } - } - } - } -} - impl U7 { #[cfg(any(target_arch = "arm", target_arch = "wasm32", target_arch = "x86"))] /// Returns which variant this tag union holds. Note that this never includes a payload! @@ -3697,21 +3129,21 @@ impl core::fmt::Debug for U6 { } } -impl U4 { +impl U5 { #[cfg(any(target_arch = "arm", target_arch = "wasm32", target_arch = "x86"))] /// Returns which variant this tag union holds. Note that this never includes a payload! - pub fn discriminant(&self) -> discriminant_U4 { + pub fn discriminant(&self) -> discriminant_U5 { unsafe { let bytes = core::mem::transmute::<&Self, &[u8; core::mem::size_of::()]>(self); - core::mem::transmute::(*bytes.as_ptr().add(11)) + core::mem::transmute::(*bytes.as_ptr().add(11)) } } #[cfg(any(target_arch = "arm", target_arch = "wasm32", target_arch = "x86"))] /// Internal helper - fn set_discriminant(&mut self, discriminant: discriminant_U4) { - let discriminant_ptr: *mut discriminant_U4 = (self as *mut U4).cast(); + fn set_discriminant(&mut self, discriminant: discriminant_U5) { + let discriminant_ptr: *mut discriminant_U5 = (self as *mut U5).cast(); unsafe { *(discriminant_ptr.add(11)) = discriminant; @@ -3731,7 +3163,7 @@ impl U4 { MimeType: core::mem::ManuallyDrop::new(arg), }; - answer.set_discriminant(discriminant_U4::MimeType); + answer.set_discriminant(discriminant_U5::MimeType); answer } @@ -3743,11 +3175,11 @@ impl U4 { target_arch = "x86", target_arch = "x86_64" ))] - /// Unsafely assume the given `U4` has a `.discriminant()` of `MimeType` and convert it to `MimeType`'s payload. + /// Unsafely assume the given `U5` has a `.discriminant()` of `MimeType` and convert it to `MimeType`'s payload. /// (Always examine `.discriminant()` first to make sure this is the correct variant!) /// Panics in debug builds if the `.discriminant()` doesn't return `MimeType`. pub unsafe fn into_MimeType(mut self) -> roc_std::RocStr { - debug_assert_eq!(self.discriminant(), discriminant_U4::MimeType); + debug_assert_eq!(self.discriminant(), discriminant_U5::MimeType); let payload = core::mem::ManuallyDrop::take(&mut self.MimeType); @@ -3761,11 +3193,11 @@ impl U4 { target_arch = "x86", target_arch = "x86_64" ))] - /// Unsafely assume the given `U4` has a `.discriminant()` of `MimeType` and return its payload. + /// Unsafely assume the given `U5` has a `.discriminant()` of `MimeType` and return its payload. /// (Always examine `.discriminant()` first to make sure this is the correct variant!) /// Panics in debug builds if the `.discriminant()` doesn't return `MimeType`. pub unsafe fn as_MimeType(&self) -> &roc_std::RocStr { - debug_assert_eq!(self.discriminant(), discriminant_U4::MimeType); + debug_assert_eq!(self.discriminant(), discriminant_U5::MimeType); let payload = &self.MimeType; @@ -3774,18 +3206,18 @@ impl U4 { #[cfg(any(target_arch = "aarch64", target_arch = "x86_64"))] /// Returns which variant this tag union holds. Note that this never includes a payload! - pub fn discriminant(&self) -> discriminant_U4 { + pub fn discriminant(&self) -> discriminant_U5 { unsafe { let bytes = core::mem::transmute::<&Self, &[u8; core::mem::size_of::()]>(self); - core::mem::transmute::(*bytes.as_ptr().add(23)) + core::mem::transmute::(*bytes.as_ptr().add(23)) } } #[cfg(any(target_arch = "aarch64", target_arch = "x86_64"))] /// Internal helper - fn set_discriminant(&mut self, discriminant: discriminant_U4) { - let discriminant_ptr: *mut discriminant_U4 = (self as *mut U4).cast(); + fn set_discriminant(&mut self, discriminant: discriminant_U5) { + let discriminant_ptr: *mut discriminant_U5 = (self as *mut U5).cast(); unsafe { *(discriminant_ptr.add(23)) = discriminant; @@ -3793,7 +3225,7 @@ impl U4 { } } -impl Drop for U4 { +impl Drop for U5 { #[cfg(any( target_arch = "arm", target_arch = "aarch64", @@ -3804,16 +3236,16 @@ impl Drop for U4 { fn drop(&mut self) { // Drop the payloads match self.discriminant() { - discriminant_U4::MimeType => unsafe { + discriminant_U5::MimeType => unsafe { core::mem::ManuallyDrop::drop(&mut self.MimeType) }, } } } -impl Eq for U4 {} +impl Eq for U5 {} -impl PartialEq for U4 { +impl PartialEq for U5 { #[cfg(any( target_arch = "arm", target_arch = "aarch64", @@ -3828,13 +3260,13 @@ impl PartialEq for U4 { unsafe { match self.discriminant() { - discriminant_U4::MimeType => self.MimeType == other.MimeType, + discriminant_U5::MimeType => self.MimeType == other.MimeType, } } } } -impl PartialOrd for U4 { +impl PartialOrd for U5 { #[cfg(any( target_arch = "arm", target_arch = "aarch64", @@ -3850,13 +3282,13 @@ impl PartialOrd for U4 { unsafe { match self.discriminant() { - discriminant_U4::MimeType => self.MimeType.partial_cmp(&other.MimeType), + discriminant_U5::MimeType => self.MimeType.partial_cmp(&other.MimeType), } } } } -impl Ord for U4 { +impl Ord for U5 { #[cfg(any( target_arch = "arm", target_arch = "aarch64", @@ -3872,13 +3304,13 @@ impl Ord for U4 { unsafe { match self.discriminant() { - discriminant_U4::MimeType => self.MimeType.cmp(&other.MimeType), + discriminant_U5::MimeType => self.MimeType.cmp(&other.MimeType), } } } } -impl Clone for U4 { +impl Clone for U5 { #[cfg(any( target_arch = "arm", target_arch = "aarch64", @@ -3889,7 +3321,7 @@ impl Clone for U4 { fn clone(&self) -> Self { let mut answer = unsafe { match self.discriminant() { - discriminant_U4::MimeType => Self { + discriminant_U5::MimeType => Self { MimeType: self.MimeType.clone(), }, } @@ -3901,7 +3333,7 @@ impl Clone for U4 { } } -impl core::hash::Hash for U4 { +impl core::hash::Hash for U5 { #[cfg(any( target_arch = "arm", target_arch = "aarch64", @@ -3911,15 +3343,15 @@ impl core::hash::Hash for U4 { ))] fn hash(&self, state: &mut H) { match self.discriminant() { - discriminant_U4::MimeType => unsafe { - discriminant_U4::MimeType.hash(state); + discriminant_U5::MimeType => unsafe { + discriminant_U5::MimeType.hash(state); self.MimeType.hash(state); }, } } } -impl core::fmt::Debug for U4 { +impl core::fmt::Debug for U5 { #[cfg(any( target_arch = "arm", target_arch = "aarch64", @@ -3928,11 +3360,11 @@ impl core::fmt::Debug for U4 { target_arch = "x86_64" ))] fn fmt(&self, f: &mut core::fmt::Formatter<'_>) -> core::fmt::Result { - f.write_str("U4::")?; + f.write_str("U5::")?; unsafe { match self.discriminant() { - discriminant_U4::MimeType => { + discriminant_U5::MimeType => { f.debug_tuple("MimeType").field(&*self.MimeType).finish() } } @@ -3940,21 +3372,21 @@ impl core::fmt::Debug for U4 { } } -impl U2 { +impl U3 { #[cfg(any(target_arch = "arm", target_arch = "wasm32", target_arch = "x86"))] /// Returns which variant this tag union holds. Note that this never includes a payload! - pub fn discriminant(&self) -> discriminant_U2 { + pub fn discriminant(&self) -> discriminant_U3 { unsafe { let bytes = core::mem::transmute::<&Self, &[u8; core::mem::size_of::()]>(self); - core::mem::transmute::(*bytes.as_ptr().add(11)) + core::mem::transmute::(*bytes.as_ptr().add(11)) } } #[cfg(any(target_arch = "arm", target_arch = "wasm32", target_arch = "x86"))] /// Internal helper - fn set_discriminant(&mut self, discriminant: discriminant_U2) { - let discriminant_ptr: *mut discriminant_U2 = (self as *mut U2).cast(); + fn set_discriminant(&mut self, discriminant: discriminant_U3) { + let discriminant_ptr: *mut discriminant_U3 = (self as *mut U3).cast(); unsafe { *(discriminant_ptr.add(11)) = discriminant; @@ -3974,7 +3406,7 @@ impl U2 { MimeType: core::mem::ManuallyDrop::new(arg), }; - answer.set_discriminant(discriminant_U2::MimeType); + answer.set_discriminant(discriminant_U3::MimeType); answer } @@ -3986,11 +3418,11 @@ impl U2 { target_arch = "x86", target_arch = "x86_64" ))] - /// Unsafely assume the given `U2` has a `.discriminant()` of `MimeType` and convert it to `MimeType`'s payload. + /// Unsafely assume the given `U3` has a `.discriminant()` of `MimeType` and convert it to `MimeType`'s payload. /// (Always examine `.discriminant()` first to make sure this is the correct variant!) /// Panics in debug builds if the `.discriminant()` doesn't return `MimeType`. pub unsafe fn into_MimeType(mut self) -> roc_std::RocStr { - debug_assert_eq!(self.discriminant(), discriminant_U2::MimeType); + debug_assert_eq!(self.discriminant(), discriminant_U3::MimeType); let payload = core::mem::ManuallyDrop::take(&mut self.MimeType); @@ -4004,11 +3436,11 @@ impl U2 { target_arch = "x86", target_arch = "x86_64" ))] - /// Unsafely assume the given `U2` has a `.discriminant()` of `MimeType` and return its payload. + /// Unsafely assume the given `U3` has a `.discriminant()` of `MimeType` and return its payload. /// (Always examine `.discriminant()` first to make sure this is the correct variant!) /// Panics in debug builds if the `.discriminant()` doesn't return `MimeType`. pub unsafe fn as_MimeType(&self) -> &roc_std::RocStr { - debug_assert_eq!(self.discriminant(), discriminant_U2::MimeType); + debug_assert_eq!(self.discriminant(), discriminant_U3::MimeType); let payload = &self.MimeType; @@ -4017,18 +3449,18 @@ impl U2 { #[cfg(any(target_arch = "aarch64", target_arch = "x86_64"))] /// Returns which variant this tag union holds. Note that this never includes a payload! - pub fn discriminant(&self) -> discriminant_U2 { + pub fn discriminant(&self) -> discriminant_U3 { unsafe { let bytes = core::mem::transmute::<&Self, &[u8; core::mem::size_of::()]>(self); - core::mem::transmute::(*bytes.as_ptr().add(23)) + core::mem::transmute::(*bytes.as_ptr().add(23)) } } #[cfg(any(target_arch = "aarch64", target_arch = "x86_64"))] /// Internal helper - fn set_discriminant(&mut self, discriminant: discriminant_U2) { - let discriminant_ptr: *mut discriminant_U2 = (self as *mut U2).cast(); + fn set_discriminant(&mut self, discriminant: discriminant_U3) { + let discriminant_ptr: *mut discriminant_U3 = (self as *mut U3).cast(); unsafe { *(discriminant_ptr.add(23)) = discriminant; @@ -4036,7 +3468,7 @@ impl U2 { } } -impl Drop for U2 { +impl Drop for U3 { #[cfg(any( target_arch = "arm", target_arch = "aarch64", @@ -4047,16 +3479,16 @@ impl Drop for U2 { fn drop(&mut self) { // Drop the payloads match self.discriminant() { - discriminant_U2::MimeType => unsafe { + discriminant_U3::MimeType => unsafe { core::mem::ManuallyDrop::drop(&mut self.MimeType) }, } } } -impl Eq for U2 {} +impl Eq for U3 {} -impl PartialEq for U2 { +impl PartialEq for U3 { #[cfg(any( target_arch = "arm", target_arch = "aarch64", @@ -4071,13 +3503,13 @@ impl PartialEq for U2 { unsafe { match self.discriminant() { - discriminant_U2::MimeType => self.MimeType == other.MimeType, + discriminant_U3::MimeType => self.MimeType == other.MimeType, } } } } -impl PartialOrd for U2 { +impl PartialOrd for U3 { #[cfg(any( target_arch = "arm", target_arch = "aarch64", @@ -4093,13 +3525,13 @@ impl PartialOrd for U2 { unsafe { match self.discriminant() { - discriminant_U2::MimeType => self.MimeType.partial_cmp(&other.MimeType), + discriminant_U3::MimeType => self.MimeType.partial_cmp(&other.MimeType), } } } } -impl Ord for U2 { +impl Ord for U3 { #[cfg(any( target_arch = "arm", target_arch = "aarch64", @@ -4115,13 +3547,13 @@ impl Ord for U2 { unsafe { match self.discriminant() { - discriminant_U2::MimeType => self.MimeType.cmp(&other.MimeType), + discriminant_U3::MimeType => self.MimeType.cmp(&other.MimeType), } } } } -impl Clone for U2 { +impl Clone for U3 { #[cfg(any( target_arch = "arm", target_arch = "aarch64", @@ -4132,7 +3564,7 @@ impl Clone for U2 { fn clone(&self) -> Self { let mut answer = unsafe { match self.discriminant() { - discriminant_U2::MimeType => Self { + discriminant_U3::MimeType => Self { MimeType: self.MimeType.clone(), }, } @@ -4144,7 +3576,7 @@ impl Clone for U2 { } } -impl core::hash::Hash for U2 { +impl core::hash::Hash for U3 { #[cfg(any( target_arch = "arm", target_arch = "aarch64", @@ -4154,15 +3586,15 @@ impl core::hash::Hash for U2 { ))] fn hash(&self, state: &mut H) { match self.discriminant() { - discriminant_U2::MimeType => unsafe { - discriminant_U2::MimeType.hash(state); + discriminant_U3::MimeType => unsafe { + discriminant_U3::MimeType.hash(state); self.MimeType.hash(state); }, } } } -impl core::fmt::Debug for U2 { +impl core::fmt::Debug for U3 { #[cfg(any( target_arch = "arm", target_arch = "aarch64", @@ -4171,11 +3603,11 @@ impl core::fmt::Debug for U2 { target_arch = "x86_64" ))] fn fmt(&self, f: &mut core::fmt::Formatter<'_>) -> core::fmt::Result { - f.write_str("U2::")?; + f.write_str("U3::")?; unsafe { match self.discriminant() { - discriminant_U2::MimeType => { + discriminant_U3::MimeType => { f.debug_tuple("MimeType").field(&*self.MimeType).finish() } } @@ -4183,306 +3615,6 @@ impl core::fmt::Debug for U2 { } } -impl Timeout { - #[cfg(any( - target_arch = "arm", - target_arch = "aarch64", - target_arch = "wasm32", - target_arch = "x86", - target_arch = "x86_64" - ))] - /// Returns which variant this tag union holds. Note that this never includes a payload! - pub fn discriminant(&self) -> discriminant_Timeout { - unsafe { - let bytes = core::mem::transmute::<&Self, &[u8; core::mem::size_of::()]>(self); - - core::mem::transmute::(*bytes.as_ptr().add(8)) - } - } - - #[cfg(any( - target_arch = "arm", - target_arch = "aarch64", - target_arch = "wasm32", - target_arch = "x86", - target_arch = "x86_64" - ))] - /// Internal helper - fn set_discriminant(&mut self, discriminant: discriminant_Timeout) { - let discriminant_ptr: *mut discriminant_Timeout = (self as *mut Timeout).cast(); - - unsafe { - *(discriminant_ptr.add(8)) = discriminant; - } - } - - #[cfg(any( - target_arch = "arm", - target_arch = "aarch64", - target_arch = "wasm32", - target_arch = "x86", - target_arch = "x86_64" - ))] - /// A tag named NoTimeout, which has no payload. - pub const NoTimeout: Self = unsafe { - let mut bytes = [0; core::mem::size_of::()]; - - bytes[8] = discriminant_Timeout::NoTimeout as u8; - - core::mem::transmute::<[u8; core::mem::size_of::()], Timeout>(bytes) - }; - - #[cfg(any( - target_arch = "arm", - target_arch = "aarch64", - target_arch = "wasm32", - target_arch = "x86", - target_arch = "x86_64" - ))] - /// Other `into_` methods return a payload, but since the NoTimeout tag - /// has no payload, this does nothing and is only here for completeness. - pub fn into_NoTimeout(self) { - () - } - - #[cfg(any( - target_arch = "arm", - target_arch = "aarch64", - target_arch = "wasm32", - target_arch = "x86", - target_arch = "x86_64" - ))] - /// Other `as` methods return a payload, but since the NoTimeout tag - /// has no payload, this does nothing and is only here for completeness. - pub unsafe fn as_NoTimeout(&self) { - () - } - - #[cfg(any( - target_arch = "arm", - target_arch = "aarch64", - target_arch = "wasm32", - target_arch = "x86", - target_arch = "x86_64" - ))] - /// Construct a tag named `Timeout`, with the appropriate payload - pub fn Timeout(arg: f64) -> Self { - let mut answer = Self { Timeout: arg }; - - answer.set_discriminant(discriminant_Timeout::Timeout); - - answer - } - - #[cfg(any( - target_arch = "arm", - target_arch = "aarch64", - target_arch = "wasm32", - target_arch = "x86", - target_arch = "x86_64" - ))] - /// Unsafely assume the given `Timeout` has a `.discriminant()` of `Timeout` and convert it to `Timeout`'s payload. - /// (Always examine `.discriminant()` first to make sure this is the correct variant!) - /// Panics in debug builds if the `.discriminant()` doesn't return `Timeout`. - pub unsafe fn into_Timeout(self) -> f64 { - debug_assert_eq!(self.discriminant(), discriminant_Timeout::Timeout); - - let payload = self.Timeout; - - payload - } - - #[cfg(any( - target_arch = "arm", - target_arch = "aarch64", - target_arch = "wasm32", - target_arch = "x86", - target_arch = "x86_64" - ))] - /// Unsafely assume the given `Timeout` has a `.discriminant()` of `Timeout` and return its payload. - /// (Always examine `.discriminant()` first to make sure this is the correct variant!) - /// Panics in debug builds if the `.discriminant()` doesn't return `Timeout`. - pub unsafe fn as_Timeout(&self) -> &f64 { - debug_assert_eq!(self.discriminant(), discriminant_Timeout::Timeout); - - let payload = &self.Timeout; - - &payload - } -} - -impl Drop for Timeout { - #[cfg(any( - target_arch = "arm", - target_arch = "aarch64", - target_arch = "wasm32", - target_arch = "x86", - target_arch = "x86_64" - ))] - fn drop(&mut self) { - // Drop the payloads - match self.discriminant() { - discriminant_Timeout::NoTimeout => {} - discriminant_Timeout::Timeout => {} - } - } -} - -impl PartialEq for Timeout { - #[cfg(any( - target_arch = "arm", - target_arch = "aarch64", - target_arch = "wasm32", - target_arch = "x86", - target_arch = "x86_64" - ))] - fn eq(&self, other: &Self) -> bool { - if self.discriminant() != other.discriminant() { - return false; - } - - unsafe { - match self.discriminant() { - discriminant_Timeout::NoTimeout => true, - discriminant_Timeout::Timeout => self.Timeout == other.Timeout, - } - } - } -} - -impl PartialOrd for Timeout { - #[cfg(any( - target_arch = "arm", - target_arch = "aarch64", - target_arch = "wasm32", - target_arch = "x86", - target_arch = "x86_64" - ))] - fn partial_cmp(&self, other: &Self) -> Option { - match self.discriminant().partial_cmp(&other.discriminant()) { - Some(core::cmp::Ordering::Equal) => {} - not_eq => return not_eq, - } - - unsafe { - match self.discriminant() { - discriminant_Timeout::NoTimeout => Some(core::cmp::Ordering::Equal), - discriminant_Timeout::Timeout => self.Timeout.partial_cmp(&other.Timeout), - } - } - } -} - -// error[E0184]: the trait `Copy` may not be implemented for this type; the type has a destructor -// --> src/glue.rs:4399:1 -// | -// 4399 | impl Copy for Timeout {} -// | ^^^^^^^^^^^^^^^^^^^^^^^^ Copy not allowed on types with destructors -// -// For more information about this error, try `rustc --explain E0184`. -// -// impl Ord for Timeout { -// #[cfg(any( -// target_arch = "arm", -// target_arch = "aarch64", -// target_arch = "wasm32", -// target_arch = "x86", -// target_arch = "x86_64" -// ))] -// fn cmp(&self, other: &Self) -> core::cmp::Ordering { -// match self.discriminant().cmp(&other.discriminant()) { -// core::cmp::Ordering::Equal => {} -// not_eq => return not_eq, -// } - -// unsafe { -// match self.discriminant() { -// discriminant_Timeout::NoTimeout => core::cmp::Ordering::Equal, -// discriminant_Timeout::Timeout => self.Timeout.cmp(&other.Timeout), -// } -// } -// } -// } - -// impl Copy for Timeout {} - -impl Clone for Timeout { - #[cfg(any( - target_arch = "arm", - target_arch = "aarch64", - target_arch = "wasm32", - target_arch = "x86", - target_arch = "x86_64" - ))] - fn clone(&self) -> Self { - let mut answer = unsafe { - match self.discriminant() { - discriminant_Timeout::NoTimeout => { - core::mem::transmute::, Timeout>( - core::mem::MaybeUninit::uninit(), - ) - } - discriminant_Timeout::Timeout => Self { - Timeout: self.Timeout.clone(), - }, - } - }; - - answer.set_discriminant(self.discriminant()); - - answer - } -} - -// error[E0599]: no method named `hash` found for type `f64` in the current scope -// --> src/glue.rs:4450:30 -// | -// 4450 | self.Timeout.hash(state); -// | ^^^^ method not found in `f64` -// -// For more information about this error, try `rustc --explain E0599`. -// -// impl core::hash::Hash for Timeout { -// #[cfg(any( -// target_arch = "arm", -// target_arch = "aarch64", -// target_arch = "wasm32", -// target_arch = "x86", -// target_arch = "x86_64" -// ))] -// fn hash(&self, state: &mut H) { -// match self.discriminant() { -// discriminant_Timeout::NoTimeout => discriminant_Timeout::NoTimeout.hash(state), -// discriminant_Timeout::Timeout => unsafe { -// discriminant_Timeout::Timeout.hash(state); -// self.Timeout.hash(state); -// }, -// } -// } -// } - -impl core::fmt::Debug for Timeout { - #[cfg(any( - target_arch = "arm", - target_arch = "aarch64", - target_arch = "wasm32", - target_arch = "x86", - target_arch = "x86_64" - ))] - fn fmt(&self, f: &mut core::fmt::Formatter<'_>) -> core::fmt::Result { - f.write_str("Timeout::")?; - - unsafe { - match self.discriminant() { - discriminant_Timeout::NoTimeout => f.write_str("NoTimeout"), - discriminant_Timeout::Timeout => { - f.debug_tuple("Timeout").field(&self.Timeout).finish() - } - } - } - } -} - impl ProgressTracking { #[cfg(any(target_arch = "arm", target_arch = "wasm32", target_arch = "x86"))] /// Returns which variant this tag union holds. Note that this never includes a payload! @@ -5050,3 +4182,306 @@ impl core::fmt::Debug for U1 { } } } + +impl TimeoutConfig { + #[cfg(any( + target_arch = "arm", + target_arch = "aarch64", + target_arch = "wasm32", + target_arch = "x86", + target_arch = "x86_64" + ))] + /// Returns which variant this tag union holds. Note that this never includes a payload! + pub fn discriminant(&self) -> discriminant_TimeoutConfig { + unsafe { + let bytes = core::mem::transmute::<&Self, &[u8; core::mem::size_of::()]>(self); + + core::mem::transmute::(*bytes.as_ptr().add(8)) + } + } + + #[cfg(any( + target_arch = "arm", + target_arch = "aarch64", + target_arch = "wasm32", + target_arch = "x86", + target_arch = "x86_64" + ))] + /// Internal helper + fn set_discriminant(&mut self, discriminant: discriminant_TimeoutConfig) { + let discriminant_ptr: *mut discriminant_TimeoutConfig = (self as *mut TimeoutConfig).cast(); + + unsafe { + *(discriminant_ptr.add(8)) = discriminant; + } + } + + #[cfg(any( + target_arch = "arm", + target_arch = "aarch64", + target_arch = "wasm32", + target_arch = "x86", + target_arch = "x86_64" + ))] + /// A tag named NoTimeout, which has no payload. + pub const NoTimeout: Self = unsafe { + let mut bytes = [0; core::mem::size_of::()]; + + bytes[8] = discriminant_TimeoutConfig::NoTimeout as u8; + + core::mem::transmute::<[u8; core::mem::size_of::()], TimeoutConfig>(bytes) + }; + + #[cfg(any( + target_arch = "arm", + target_arch = "aarch64", + target_arch = "wasm32", + target_arch = "x86", + target_arch = "x86_64" + ))] + /// Other `into_` methods return a payload, but since the NoTimeout tag + /// has no payload, this does nothing and is only here for completeness. + pub fn into_NoTimeout(self) { + () + } + + #[cfg(any( + target_arch = "arm", + target_arch = "aarch64", + target_arch = "wasm32", + target_arch = "x86", + target_arch = "x86_64" + ))] + /// Other `as` methods return a payload, but since the NoTimeout tag + /// has no payload, this does nothing and is only here for completeness. + pub unsafe fn as_NoTimeout(&self) { + () + } + + #[cfg(any( + target_arch = "arm", + target_arch = "aarch64", + target_arch = "wasm32", + target_arch = "x86", + target_arch = "x86_64" + ))] + /// Construct a tag named `TimeoutMilliseconds`, with the appropriate payload + pub fn TimeoutMilliseconds(arg: u64) -> Self { + let mut answer = Self { + TimeoutMilliseconds: arg, + }; + + answer.set_discriminant(discriminant_TimeoutConfig::TimeoutMilliseconds); + + answer + } + + #[cfg(any( + target_arch = "arm", + target_arch = "aarch64", + target_arch = "wasm32", + target_arch = "x86", + target_arch = "x86_64" + ))] + /// Unsafely assume the given `TimeoutConfig` has a `.discriminant()` of `TimeoutMilliseconds` and convert it to `TimeoutMilliseconds`'s payload. + /// (Always examine `.discriminant()` first to make sure this is the correct variant!) + /// Panics in debug builds if the `.discriminant()` doesn't return `TimeoutMilliseconds`. + pub unsafe fn into_TimeoutMilliseconds(self) -> u64 { + debug_assert_eq!( + self.discriminant(), + discriminant_TimeoutConfig::TimeoutMilliseconds + ); + + let payload = self.TimeoutMilliseconds; + + payload + } + + #[cfg(any( + target_arch = "arm", + target_arch = "aarch64", + target_arch = "wasm32", + target_arch = "x86", + target_arch = "x86_64" + ))] + /// Unsafely assume the given `TimeoutConfig` has a `.discriminant()` of `TimeoutMilliseconds` and return its payload. + /// (Always examine `.discriminant()` first to make sure this is the correct variant!) + /// Panics in debug builds if the `.discriminant()` doesn't return `TimeoutMilliseconds`. + pub unsafe fn as_TimeoutMilliseconds(&self) -> &u64 { + debug_assert_eq!( + self.discriminant(), + discriminant_TimeoutConfig::TimeoutMilliseconds + ); + + let payload = &self.TimeoutMilliseconds; + + &payload + } +} + +impl Drop for TimeoutConfig { + #[cfg(any( + target_arch = "arm", + target_arch = "aarch64", + target_arch = "wasm32", + target_arch = "x86", + target_arch = "x86_64" + ))] + fn drop(&mut self) { + // Drop the payloads + match self.discriminant() { + discriminant_TimeoutConfig::NoTimeout => {} + discriminant_TimeoutConfig::TimeoutMilliseconds => {} + } + } +} + +impl Eq for TimeoutConfig {} + +impl PartialEq for TimeoutConfig { + #[cfg(any( + target_arch = "arm", + target_arch = "aarch64", + target_arch = "wasm32", + target_arch = "x86", + target_arch = "x86_64" + ))] + fn eq(&self, other: &Self) -> bool { + if self.discriminant() != other.discriminant() { + return false; + } + + unsafe { + match self.discriminant() { + discriminant_TimeoutConfig::NoTimeout => true, + discriminant_TimeoutConfig::TimeoutMilliseconds => { + self.TimeoutMilliseconds == other.TimeoutMilliseconds + } + } + } + } +} + +impl PartialOrd for TimeoutConfig { + #[cfg(any( + target_arch = "arm", + target_arch = "aarch64", + target_arch = "wasm32", + target_arch = "x86", + target_arch = "x86_64" + ))] + fn partial_cmp(&self, other: &Self) -> Option { + match self.discriminant().partial_cmp(&other.discriminant()) { + Some(core::cmp::Ordering::Equal) => {} + not_eq => return not_eq, + } + + unsafe { + match self.discriminant() { + discriminant_TimeoutConfig::NoTimeout => Some(core::cmp::Ordering::Equal), + discriminant_TimeoutConfig::TimeoutMilliseconds => self + .TimeoutMilliseconds + .partial_cmp(&other.TimeoutMilliseconds), + } + } + } +} + +impl Ord for TimeoutConfig { + #[cfg(any( + target_arch = "arm", + target_arch = "aarch64", + target_arch = "wasm32", + target_arch = "x86", + target_arch = "x86_64" + ))] + fn cmp(&self, other: &Self) -> core::cmp::Ordering { + match self.discriminant().cmp(&other.discriminant()) { + core::cmp::Ordering::Equal => {} + not_eq => return not_eq, + } + + unsafe { + match self.discriminant() { + discriminant_TimeoutConfig::NoTimeout => core::cmp::Ordering::Equal, + discriminant_TimeoutConfig::TimeoutMilliseconds => { + self.TimeoutMilliseconds.cmp(&other.TimeoutMilliseconds) + } + } + } + } +} + +// impl Copy for TimeoutConfig {} + +impl Clone for TimeoutConfig { + #[cfg(any( + target_arch = "arm", + target_arch = "aarch64", + target_arch = "wasm32", + target_arch = "x86", + target_arch = "x86_64" + ))] + fn clone(&self) -> Self { + let mut answer = unsafe { + match self.discriminant() { + discriminant_TimeoutConfig::NoTimeout => { + core::mem::transmute::, TimeoutConfig>( + core::mem::MaybeUninit::uninit(), + ) + } + discriminant_TimeoutConfig::TimeoutMilliseconds => Self { + TimeoutMilliseconds: self.TimeoutMilliseconds.clone(), + }, + } + }; + + answer.set_discriminant(self.discriminant()); + + answer + } +} + +impl core::hash::Hash for TimeoutConfig { + #[cfg(any( + target_arch = "arm", + target_arch = "aarch64", + target_arch = "wasm32", + target_arch = "x86", + target_arch = "x86_64" + ))] + fn hash(&self, state: &mut H) { + match self.discriminant() { + discriminant_TimeoutConfig::NoTimeout => { + discriminant_TimeoutConfig::NoTimeout.hash(state) + } + discriminant_TimeoutConfig::TimeoutMilliseconds => unsafe { + discriminant_TimeoutConfig::TimeoutMilliseconds.hash(state); + self.TimeoutMilliseconds.hash(state); + }, + } + } +} + +impl core::fmt::Debug for TimeoutConfig { + #[cfg(any( + target_arch = "arm", + target_arch = "aarch64", + target_arch = "wasm32", + target_arch = "x86", + target_arch = "x86_64" + ))] + fn fmt(&self, f: &mut core::fmt::Formatter<'_>) -> core::fmt::Result { + f.write_str("TimeoutConfig::")?; + + unsafe { + match self.discriminant() { + discriminant_TimeoutConfig::NoTimeout => f.write_str("NoTimeout"), + discriminant_TimeoutConfig::TimeoutMilliseconds => f + .debug_tuple("TimeoutMilliseconds") + .field(&self.TimeoutMilliseconds) + .finish(), + } + } + } +} diff --git a/examples/interactive/cli-platform/src/lib.rs b/examples/interactive/cli-platform/src/lib.rs index 2f52dbc1f1..2bdf2901e8 100644 --- a/examples/interactive/cli-platform/src/lib.rs +++ b/examples/interactive/cli-platform/src/lib.rs @@ -10,7 +10,7 @@ use libc; use roc_std::{RocList, RocStr}; use std::ffi::CStr; use std::os::raw::c_char; -use ureq::Error; +use std::time::Duration; extern "C" { #[link_name = "roc__mainForHost_1_exposed_generic"] @@ -128,60 +128,48 @@ pub extern "C" fn roc_fx_putLine(line: &RocStr) { println!("{}", string); } -const BODY_MAX_BYTES: usize = 10 * 1024 * 1024; - #[no_mangle] pub extern "C" fn roc_fx_sendRequest(roc_request: &glue::Request) -> glue::Response { - use std::io::Read; + let mut builder = reqwest::blocking::ClientBuilder::new(); + + if roc_request.timeout.discriminant() == glue::discriminant_TimeoutConfig::TimeoutMilliseconds { + let ms: &u64 = unsafe { roc_request.timeout.as_TimeoutMilliseconds() }; + builder = builder.timeout(Duration::from_millis(*ms)); + } let url = roc_request.url.as_str(); - match ureq::get(url).call() { + match reqwest::blocking::get(url) { Ok(response) => { - let statusCode = response.status(); - - let len: usize = response - .header("Content-Length") - .and_then(|val| val.parse::().ok()) - .map(|val| val.max(BODY_MAX_BYTES)) - .unwrap_or(BODY_MAX_BYTES); - - let bytes_iter = response - .into_reader() - .bytes() - .take(len) - .filter_map(|result| result.ok()); - - let body: RocList = RocList::from_iter(bytes_iter); + let bytes = response.bytes().unwrap_or_default(); + let body: RocList = RocList::from_iter(bytes.into_iter()); + let status = response.status(); + let status_str = status.canonical_reason().unwrap_or_else(|| status.as_str()); let metadata = Metadata { - headers: RocList::empty(), // TODO - statusText: RocStr::empty(), // TODO - url: RocStr::empty(), // TODO - statusCode, + headers: RocList::empty(), // TODO + statusText: RocStr::from(status_str), + url: RocStr::from(url), + statusCode: status.as_u16(), }; - glue::Response::GoodStatus(metadata, body) } - Err(Error::Status(statusCode, response)) => { - let mut buffer: Vec = vec![]; - let mut reader = response.into_reader(); - reader.read(&mut buffer).expect("can't read response"); - let body = RocList::from_slice(&buffer); - - let metadata = Metadata { - headers: RocList::empty(), // TODO - statusText: RocStr::empty(), // TODO - url: RocStr::empty(), // TODO - statusCode, - }; - - glue::Response::BadStatus(metadata, body) - } - Err(transportError) => { - use ureq::ErrorKind::*; - match transportError.kind() { - InvalidUrl | UnknownScheme => glue::Response::BadUrl(RocStr::from(url)), - _ => glue::Response::NetworkError, + Err(err) => { + if err.is_timeout() { + glue::Response::Timeout + } else if let Some(status) = err.status() { + let body = RocList::empty(); // TODO + let status_str = status.canonical_reason().unwrap_or_else(|| status.as_str()); + let metadata = Metadata { + headers: RocList::empty(), // TODO + statusText: RocStr::from(status_str), + url: RocStr::from(url), + statusCode: status.as_u16(), + }; + glue::Response::BadStatus(metadata, body) + } else if err.is_request() { + glue::Response::BadUrl(RocStr::from(url)) + } else { + glue::Response::NetworkError } } }