Opinionated format on Vector<32, Uint<5>>

[faculerena]

I have a fold that wants to be a zip:

circuit foo(input: Bytes<32>, t: Uint<32>,): Boolean {
  return fold((acc: Boolean, byte: Uint<8>, i: Uint<8>): Boolean =>
    ...,
    true,
    input,
    [0,1,2,3,4,5,6,7,8,9,10,11,12,13,14,15,16,17,18,19,20,21,22,23,24,25,26,27,28,29,30,31];
}

Running compact-format over this causes it to be... ugly.

circuit foo(input: Bytes<32>, t: Uint<32>,): Boolean {
  return fold((acc: Boolean, byte: Uint<8>, i: Uint<8>): Boolean =>
    ...,
    true,
    input,
    [0,
     1,
     2,
     3,
     4,
     5,
     6,
     7,
     8,
     9,
     10,
     11,
     12,
     13,
     14,
     15,
     16,
     17,
     18,
     19,
     20,
     21,
     22,
     23,
     24,
     25,
     26,
     27,
     28,
     29,
     30,
     31];
}

Moving it to another function makes it less annoying

circuit zero_to_31(): Vector<32, Uint<5>> {
  return [0,
          1,
          2,
          3,
          4,
          5,
          6,
          7,
          8,
          9,
          10,
          11,
          12,
          13,
          14,
          15,
          16,
          17,
          18,
          19,
          20,
          21,
          22,
          23,
          24,
          25,
          26,
          27,
          28,
          29,
          30,
          31];
}

Could something like this be an exception, or maybe get some kind of directive like #[no_format] or something like that? I really like having format-on-save.

[kmillikin]

We don't want format directives, we'd just prefer that the formatter does what you want.

I think here, we might consider that multiple elements on the same line is a signal that you want them densely packed and produce something like:

circuit foo(input: Bytes<32>, t: Uint<32>,): Boolean {
  return fold((acc: Boolean, byte: Uint<8>, i: Uint<8>): Boolean =>
    ...,
    true,
    input,
    [0, 1, 2, 3, 4, 5, 6, 7, 8, 9, 10, 11, 12, 13, 14, 15, 16, 17, 18, 19, 20,
     21, 22, 23, 24, 25, 26, 27, 28, 29, 30, 31];
}

For this specific code, it would be kind of nice to have a syntax for spreading a range of elements like [...0..32]. That seems like a possible feature request.

You can also accumulate the counter if it's more convenient, though that will have a cast in the loop which (I think) currently generates a constraint per iteration in circuit (untested):

circuit foo(input: Bytes<32>, t: Uint<32>,): Boolean {
  const [acc, i] = fold(([acc: Boolean, i: Uint<8>]: [Boolean, Uint<8>], byte: Uint<8>) => {
      ...
      return [acc, i + 1 as Uint<8>];
    }, [true, 0], input);
  return acc;
}

[faculerena]

For the first one, I agree. Something like 1..=32 or [...1..=32] (or 1..33 or [...1..33]) if following that concatenation of ranges shouln't have twice the last/first, or 1..32 or [...1..32] if don't caring about that.

The second one I'll try. If it generates a new constraint then it'll stay as it is now.

Also, aside from the ranges, could something like a zip function be implemented in the language?

[kmillikin]

map can take multiple input array-likes. zip is just map of tuple construction:

// zip a pair of vectors v0 and v1 into a vector of pairs:
map((x0, x1) => [x0, x1], v0, v1)

[faculerena]

I think I was referring more to a zipWith :: (a -> b -> c) -> [a] -> [b] -> [c] function instead of the tuple-making zip. I would like to have some kind of lib/utils for these kind of functions that are maybe useful, but I don't know if creating variadic circuits without using some kind of generics (accepting as input a tuple of the inputs) would be possible. I don't think this issue is the place to discuss this. Do you use discussions?

[kmillikin]

What I'm telling you is that map is "zip with".

[faculerena]

I forgot map was also variadic, sorry!