* Include schema version in backup and use vacuum into
* Allow specifying not to backup on migration
* Add ability to copy codebase safely (for share migrations)
* Set migration strategies
* Create dir to copy into if missing
* Ormolu
* ormolu
- The existing code was assuming that only references involved in `Pack`
instructions were relevant, but this only preserves data type and
request information. We need to remember types used in handlers, or
else we will think that remote requests are coming from distinct
abilities than the ones we are handling.
In certain cases this will change the failure message from something
like `resolve: unhandled ability request: 1561` to `resolve: unhandled
ability request: #ifg08` where `#ifg08` is the has of the ability that
was unhandled. At this stage we don't have convenient access to the
actual constructor within the ability that was not handled.
I haven't added tests because I don't really know how to set them up.
But it's not really a big deal if there's a regression in this error
message, so I'm not sure whether they'd be worth the trouble.
Resolves#3791
Delegate to the runtime's Socket equality, which I believe uses pointer
equality.
I tested this by running the following code, which no longer gives an
error after this change:
```
main = do
socket = Socket.client (HostName "www.google.com") (Port "http")
socket === socket
```
This improves the error message when there is a type mismatch in
equality checks of `Foreign`. The `Eq.==` error message now matches the
style of error message provided for `compare` on the `Ord` instance.
- Renames callProcess to process.call since there will be several
related functions now.
- Adds a ProcessHandle type for references to asynchronous processes
- Add start, kill, wait and exitCode for interactive processes.
* start spawns a new process with the given command and arguments,
returning Handles for the in, out and error streams of the process,
and a ProcessHandle referencing it
* kill kills a process given a ProcessHandle
* wait blocks on a process to finish and returns the exit code
* exitCode does a non-blocking query for the exit code of the process.
It returns `None` if the process is still running.
- This allows calling out to an external executable with specified
arguments. The executable is searched for in the path according to
some platform specific rules. The call is blocking, and the exit
code is returned.
- Note: this is _not_ the sort of external call that involves a shell
as an intermediary.
- This sort of call is supported by both Haskell and racket. Chez seems
to only have the shell-based external call, so it might be necessary
to wrap a foreign library for it (otherwise the arguments would have
to be escaped, which seems like a bad idea). Nevertheless, it seems
like the right API to expose.
- Opening a fully interactive, asynchronous process is left for future
work.
