.gitlab-ci.yml

@@ -6,7 +6,7 @@ stages:
 
 variables:
   NUSHELL_ARCH: "x86_64-unknown-linux-musl"
-  NUSHELL_VERSION: "0.91.0"
+  NUSHELL_VERSION: "0.93.0"
 
 workflow:
   rules:

.nushell/color.nu

@@ -67,10 +67,16 @@ export def "color from-ints" [
 }
 
 def try-string-to-int []: string -> int {
+    let s = $in
     try {
-        $"0x($in)" | into int
-    } catch {
-        get debug | parse --regex 'CantConvert { to_type: "(?<to>.*)", from_type: "(?<from>.*)", span: Span { (?<span>.*) }, help: Some\("(?<help>.*)"\) }' | into record | error make --unspanned { msg: ($in.help | str replace --all '\"' '"') }
+        $"0x($s)" | into int
+    } catch { |e|
+        let err = $e.debug
+            | parse --regex 'CantConvert { to_type: "(?<to>.*)", from_type: "(?<from>.*)", span: Span { (?<span>.*) }, help: Some\("(?<help>.*)"\) }'
+            | into record
+
+        let msg = $err.help | str replace --all '\"' '"'
+        error make --unspanned { msg: $"($msg), found ($s)" }
     }
 }
 

Makefile

@@ -19,6 +19,7 @@ test:
 	cargo test --examples --verbose
 	nu tests/cli.nu
 	nu tests/binary.nu
+	nu tests/color.nu
 
 example:
 	nu examples/cli.nu

README.md

@@ -13,7 +13,7 @@ below is an example of how to use the binary application with Nushell:
 ```
 
 > **Note**  
-> requires Nushell 0.89.0 or later
+> requires Nushell 0.93.0 or later
 
 tests for the binary application can also be run with
 ```bash

bins/inbreeding/src/environment.rs

-use rand::{seq::SliceRandom, Rng, RngCore};
+use rand::{Rng, RngCore};
+
+use crate::random::draw_unique_elements;
 
 #[derive(Debug, PartialEq)]
 pub(super) enum Environment {
@@ -14,28 +16,23 @@ impl Environment {
     /// `update(things, rng)` is `things` with some elements potentially removed according to the
     /// [`Environment`] type
     pub(super) fn update<T: Clone>(&self, things: &[T], rng: &mut impl RngCore) -> Vec<T> {
-        let mut things = things.to_vec();
-        things.shuffle(rng);
-
-        match self {
-            Environment::Fixed { n } => things.iter().take(things.len() - n),
+        let nb_to_take = match self {
+            Environment::Fixed { n } => things.len() - n,
             Environment::RandomFixed { p, n } => {
                 if rng.gen::<f64>() > *p {
-                    return things;
+                    return things.to_vec();
                 }
-                things.iter().take(things.len() - n)
+                things.len() - n
             }
             Environment::RandomDynamic { p, q } => {
                 if rng.gen::<f64>() > *p {
-                    return things;
+                    return things.to_vec();
                 }
-                things
-                    .iter()
-                    .take((things.len() as f64 * (1.0 - q)) as usize)
+                (things.len() as f64 * (1.0 - q)) as usize
             }
-        }
-        .cloned()
-        .collect()
+        };
+
+        draw_unique_elements(things, nb_to_take, rng)
     }
 
     pub(super) fn from_str(s: &str) -> Result<Self, String> {

bins/inbreeding/src/main.rs

@@ -9,9 +9,11 @@ use komodo::{
     fec::{self, Shard},
     linalg::Matrix,
 };
-use rand::{rngs::StdRng, seq::SliceRandom, Rng, RngCore, SeedableRng};
+use rand::{rngs::StdRng, Rng, RngCore, SeedableRng};
+use random::draw_unique_elements;
 
 mod environment;
+mod random;
 mod strategy;
 
 use crate::{environment::Environment, strategy::Strategy};
@@ -38,16 +40,13 @@ fn measure_inbreeding<F: PrimeField>(
     sty: &ProgressStyle,
     rng: &mut impl RngCore,
 ) -> f64 {
-    let mut s: Vec<_> = shards.to_vec();
     let mut count = 0;
 
     let pb = mp.add(ProgressBar::new(nb_measurements as u64));
     pb.set_style(sty.clone());
     pb.set_message("measure");
     for _ in 0..nb_measurements {
-        // get any k of the shards
-        s.shuffle(rng);
-        if fec::decode(s.iter().take(k).cloned().collect()).is_ok() {
+        if fec::decode(draw_unique_elements(shards, k, rng)).is_ok() {
             count += 1;
         }
         pb.inc(1);

bins/inbreeding/src/random.rs

+use rand::{Rng, RngCore};
+use std::collections::HashSet;
+
+fn draw_unique_indices(n: usize, vec_len: usize, rng: &mut impl RngCore) -> HashSet<usize> {
+    let mut indices = HashSet::new();
+
+    while indices.len() < n {
+        let idx = rng.gen_range(0..vec_len);
+        indices.insert(idx);
+    }
+
+    indices
+}
+
+pub(super) fn draw_unique_elements<T: Clone>(
+    things: &[T],
+    n: usize,
+    rng: &mut impl RngCore,
+) -> Vec<T> {
+    let mut res = vec![];
+    for i in draw_unique_indices(n, things.len(), rng) {
+        res.push(things[i].clone());
+    }
+    res
+}

bins/inbreeding/src/strategy.rs

-use rand::{seq::SliceRandom, Rng, RngCore};
+use rand::{Rng, RngCore};
+
+use crate::random::draw_unique_elements;
 
 #[derive(Debug, PartialEq)]
 pub(super) enum Strategy {
@@ -8,9 +10,6 @@ pub(super) enum Strategy {
 
 impl Strategy {
     pub(super) fn draw<T: Clone>(&self, things: &[T], rng: &mut impl RngCore) -> Vec<T> {
-        let mut things = things.to_vec();
-        things.shuffle(rng);
-
         let nb_to_take = match self {
             Self::Single { n } => *n,
             Self::Double { p, n, m } => {
@@ -22,7 +21,7 @@ impl Strategy {
             }
         };
 
-        things.iter().take(nb_to_take).cloned().collect()
+        draw_unique_elements(things, nb_to_take, rng)
     }
 
     pub(super) fn from_str(s: &str) -> Result<Self, String> {

tests/color.nu

+use ../.nushell/color.nu [
+    "color from-floats",
+    "color from-ints",
+    "color from-string",
+    "color mix",
+    "color to-hex",
+    RED,
+    GREEN,
+]
+
+use std assert
+
+def "assert error" [code: closure, --msg: string, --body: string] {
+    try {
+        do $code
+    } catch { |e|
+        if $msg != null and ($e.msg | ansi strip) != $msg {
+            error make {
+                msg: $"(ansi red_bold)assertion: bad error message(ansi reset)",
+                label: {
+                    text: $"error should have message '($msg)'",
+                    span: (metadata $code).span,
+                },
+                help: $"actual: ($e.msg | ansi strip)",
+            }
+        }
+        if $body != null and not ($e.debug | ansi strip | str contains $body) {
+            let actual = $e.debug | ansi strip | parse "{foo}text: {text}, span: {bar}" | into record | get text
+            error make {
+                msg: $"(ansi red_bold)assertion: bad error body(ansi reset)",
+                label: {
+                    text: $"error should contain '($body)'",
+                    span: (metadata $code).span,
+                },
+                help: $"actual: ($actual)",
+            }
+        }
+        return
+    }
+
+    error make --unspanned { msg: "should error" }
+}
+
+assert error { || color from-floats 2 1 1 } --msg "invalid RGB channel" --body "should be between 0 and 1, found 2"
+assert error { || color from-floats 1 (-2 | into float) 1 } --msg "invalid RGB channel" --body "should be between 0 and 1, found -2"
+assert error { || color from-floats 1 1 3.4 } --msg "invalid RGB channel" --body "should be between 0 and 1, found 3.4"
+
+assert error { || color from-ints 256 0 0 } --msg "invalid RGB channel" --body "should be between 0 and 255, found 256"
+assert error { || color from-ints 0 256 0 } --msg "invalid RGB channel" --body "should be between 0 and 255, found 256"
+assert error { || color from-ints 0 0 256 } --msg "invalid RGB channel" --body "should be between 0 and 255, found 256"
+
+assert error { || color from-string "foo" } --msg "invalid HEX color format" --body "format should be '#RRGGBB', found foo"
+assert error { || color from-string "#foo" } --msg "invalid HEX color format" --body "format should be '#RRGGBB', found #foo"
+
+assert error { || color from-string "#xxxxxx" } --msg "hexadecimal digits following \"0x\" should be in 0-9, a-f, or A-F, found xx"
+assert error { || color from-string "#0123yy" } --msg "hexadecimal digits following \"0x\" should be in 0-9, a-f, or A-F, found yy"
+
+assert equal (color from-floats 0.1 0.2 0.3) { r: 0.1, g: 0.2, b: 0.3 }
+assert equal (color from-ints 1 2 3) { r: (1 / 255), g: (2 / 255), b: (3 / 255) }
+assert equal (color from-string "#010203") { r: (1 / 255), g: (2 / 255), b: (3 / 255) }
+
+assert equal (color from-string "#010203" | color to-hex) "#010203"
+
+assert equal (color mix $RED $GREEN 0.5) (color from-floats 0.5 0.5 0.0)