The BSDs let you pass path names longer than sizeof(s.sun_path), they read past the end when socklen > sizeof(struct sockaddr_un) up to a limit¹. Let's support that.

¹ I'm 80% sure it's 255 on all BSDs but it certainly is on Darwin and FreeBSD.

Currently in our docs for open_signal_receiver, we have an example of catching SIGHUP and using it to reload the application configuration. While talking to @wgwz today re: python-trio/snekomatic#41, I discovered that this example is maybe not so great, because readers who aren't already steeped in Unix tr

Looking at the code vs the document I see that:

1. chipID listed in docs is actually not used for SPI
2. bus is not listed in docs
3. slaveselect is not listed in docs

This needs to be corrected to avoid confusing users.

Also, please note information from #781 and incorporate it as well.

🐛 Bug

In order to enable inversion of an STFT via the inverse STFT in istft, it is sufficient that the signal windowing obeys the constraint of “Constant OverLap Add” (COLA). This ensures that every point in the input data is equally weighted, thereby avoiding aliasing and allowing full reconstruction.
https://docs.scipy.org/doc/scipy/reference/generated/scipy.signal.check_COLA.html

Le

there are a lot of work need to about the documentation.

From https://discuss.ocaml.org/t/lwt-how-to-catch-exceptions-raised-by-signal-handlers/565:

open Lwt.Infix

let () =
  Lwt_unix.on_signal
    Sys.sigint
    (fun _ ->
      failwith "Caught SIGINT")
  |> ignore;

  let p =
    Lwt.finalize
      (fun () ->
        Lwt_unix.sleep 2. >>= fun () ->
        raise Pervasives.Exit)
      (fun () -

I think it will be a good idea to specify a standard for import methods in the CONTRIBUTING.md. For standard I mean argument names such as path, which and header because there are two "standards" for these arguments:

1. base functions use file, which and header
2. readxl uses path, sheet and col_names

By reading the code, rio is using file, which and header but I thi

Please make a tutorial and docs: how to create in-memory (off-heap) objects, how to allocate, how to serialize/deserialize (if need, i can't understand) this to byte array (located off-heap), how to change it fields.
For example now (in current system) I have class
User
{
long Id;
List[ItemA] ItemsA; // class ItemA { .. }
List[ItemB] ItemsB; // class ItemB { .. }
// and many more field
}

// and g

go func() {
	ctx := context.Background()
	progressChan := progress.NewTicker(ctx, r, size, 1*time.Second)
	for p := range progressChan {
		fmt.Printf("\r%v remaining...", p.Remaining().Round(time.Second))
	}
	fmt.Println("\rdownload is completed")
}()

I guess the line ctx := context.Background() should be deleted since ctx is already defined outer goroutine.

Analogous to dict.get but with extra "add" kwarg.

SectionItems.get should accept strings or HeaderItem objects for the "default" arg. If it is a string, it should be converted to a HeaderItem with the appropriate mnemonic.

Always returns a HeaderItem.

If add is True, the returned value should also be appended to the SectionItems instance.

How do we handle CurveItems? Set the data attribute to

Luv.Loop.run returns a boolean value whose meaning does not seem to be documented and, judging by the examples, in most cases is not used, but usually just ignored.

I would argue that using ignore without any type annotation is very error-prone because it sets the trap for accidental partial application. It should be considered bad style IMO, and therefore should be avoided particularly i