the return type here is “a pointer to an array of 8-bit unsigned ints” ?

@rough-minister-58256: yep! referred to as a "slice" (for some reason)

and rather than "pointer", generally rust calls them "references"

(there are pointer types, but they are very rare, and basically only used in ffi)

ah, k. I’m a little … rusty on this stuff 😉

(...so you'll see them in

<http://lib.rs|lib.rs>

and

<http://externs.rs|externs.rs>

for interfacing with python)

heh

aha makes sense

@rough-minister-58256: a bit more about slices: they are a "fat pointer", in the sense that they also always carry their own length

so you could do

get_stdout_raw().len()

, for example

which is part of why rust is (more) memory safe than C

how would I deref that to get e.g.

bytes::Bytes

?

Bytes has a method to take ownership of a slice

sec.

ah, ok

::bytes::Bytes::borrow

?

hm, slightly challenging to link to, but: `Bytes::from`: https://carllerche.github.io/bytes/bytes/struct.Bytes.html

ah

find in page for

fn from

, and then keep skipping until you see one that is the right shape

sweet, thx

i'm figuring out how to map (strings in a

globs()

) => (

PathGlobs

) => (an error which the

hydrate_sources()

method can catch and interpret). (1) is there a reason a

PathGlob

needs to expand to only a set of `PathStat`s or only a set of `PathGlob`s? because i'm thinking if that's relaxed (so a

DirWildcard

can then expand into `PathStat`s and `PathGlob`s instead of having to go through a

Wildcard

first) then we can go 1:1

String -> PathGlob

instead of having the

spread_filespecs()

stuff. the answer is almost definitely no i think (2) how do i / can i catch a

Throw

from a

Get

within an

@rule

? i'm assuming that's how the failure to expand a glob would propagate back to the python side

to clarify, (1) would involve having

parse_globs()

just return a single

DirWildcard

, which would then have a potentially non-empty

path_stats

field in the return value for

expand_single()

instead of having to have a wildcard spawned as well

"is there a reason a

PathGlob

needs to expand to only a set of `PathStat`s or only a set of `PathGlob`s"

no... it can expand to both. some of the architecture is there because we used to memoize individual glob expansions.

how do i / can i catch a

Throw

from a

Get

within an

@rule

? i'm assuming that's how the failure to expand a glob would propagate back to the python side

you don't: error handling is explicitly not supported.

ok, so i would still want to keep the extra

SnapshotWithMatchData

intrinsic probably?

hm, no

ok

if someone does not want to fail, they should not create a failing PathGlobs

the idea behind "error handling" is really just to lift all errors into the type system

which is what i thought the extra intrinsic was doing