Skip to content

Instantly share code, notes, and snippets.

Embed
What would you like to do?
// GOAL: Implements(?0: ServiceFactory<TcpStream>)
trait ServiceFactory<Stream> {
type NewService;
}
impl<F, T, I> ServiceFactory<I> for F where F: Fn<{unknown}>, T: NewService, <T as NewService>::Config = ServerConfig, <T as NewService>::Request = Io<I, {unknown}>, I: FromStream {
type NewService = T;
}
struct TcpStream;
trait FromStream {}
impl FromStream for UnixStream {}
impl FromStream for TcpStream {}
impl<F, C, R, S, E> NewService for FnNewServiceNoConfig<F, C, R, S, E> where F: Fn<{unknown}>, R: IntoFuture, <R as IntoFuture>::Item = S, <R as IntoFuture>::Error = E, S: Service {
type Request = {unknown};
type Response = {unknown};
type Error = {unknown};
type Service = S;
type Config = C;
type InitError = E;
type Future = {unknown};
}
impl<F, C, T, R, S> NewService for ApplyConfigService<F, C, T, R, S> where F: FnMut<{unknown}>, T: Service, R: IntoFuture, {unknown}: IntoService<S>, S: Service {
type Config = C;
type Request = {unknown};
type Response = {unknown};
type Error = {unknown};
type Service = S;
type InitError = {unknown};
type Future = FnNewServiceConfigFut<R, S>;
}
impl<T> NewService for ResolverFactory<T> where T: Address {
type Request = Connect<T>;
type Response = Connect<T>;
type Error = ConnectError;
type Config = ();
type Service = Resolver<T>;
type InitError = ();
type Future = FutureResult<{unknown}, {unknown}>;
}
impl<R, E, F> NewService for KeepAlive<R, E, F> where F: Fn<{unknown}> {
type Request = R;
type Response = R;
type Error = E;
type InitError = Infallible;
type Config = ();
type Service = KeepAliveService<R, E, F>;
type Future = FutureResult<{unknown}, {unknown}>;
}
impl<T, P, S, B, X, U> NewService for H1Service<T, P, S, B, X, U> where T: IoStream, S: NewService, <S as NewService>::Config = ServerConfig, <S as NewService>::Request = Request<Box<dyn Stream<Item = Bytes, Error = PayloadError>>>, {unknown}: Into<Error>, {unknown}: Into<Response<B>>, {unknown}: Debug, B: MessageBody, X: NewService, <X as NewService>::Config = ServerConfig, <X as NewService>::Request = Request<Box<dyn Stream<Item = Bytes, Error = PayloadError>>>, <X as NewService>::Response = Request<Box<dyn Stream<Item = Bytes, Error = PayloadError>>>, {unknown}: Into<Error>, {unknown}: Debug, U: NewService, <U as NewService>::Config = ServerConfig, <U as NewService>::Request = (Request<Box<dyn Stream<Item = Bytes, Error = PayloadError>>>, Framed<T, Codec>), <U as NewService>::Response = (), {unknown}: Display, {unknown}: Debug {
type Config = ServerConfig;
type Request = Io<T, P>;
type Response = ();
type Error = DispatchError;
type InitError = ();
type Service = H1ServiceHandler<T, P, {unknown}, B, {unknown}, {unknown}>;
type Future = H1ServiceResponse<T, P, S, B, X, U>;
}
impl NewService for ExpectHandler {
type Config = ServerConfig;
type Request = Request<Box<dyn Stream<Item = Bytes, Error = PayloadError>>>;
type Response = Request<Box<dyn Stream<Item = Bytes, Error = PayloadError>>>;
type Error = Error;
type Service = ExpectHandler;
type InitError = Error;
type Future = FutureResult<{unknown}, {unknown}>;
}
impl<A, C> NewService for UnitConfig<A, C> where A: NewService, <A as NewService>::Config = () {
type Request = {unknown};
type Response = {unknown};
type Error = {unknown};
type Config = C;
type Service = {unknown};
type InitError = {unknown};
type Future = {unknown};
}
impl NewService for AppRoutingFactory {
type Config = ();
type Request = ServiceRequest;
type Response = ServiceResponse<Body>;
type Error = Error;
type InitError = ();
type Service = AppRouting;
type Future = AppRoutingFactoryResponse;
}
impl NewService for AppEntry {
type Config = ();
type Request = ServiceRequest;
type Response = ServiceResponse<Body>;
type Error = Error;
type InitError = ();
type Service = AppRouting;
type Future = AppRoutingFactoryResponse;
}
impl<R, E1, E2> NewService for BlankNewService<R, E1, E2> {
type Request = R;
type Response = R;
type Error = E1;
type Config = ();
type Service = Blank<R, E1>;
type InitError = E2;
type Future = FutureResult<{unknown}, {unknown}>;
}
impl NewService for ResourceFactory {
type Config = ();
type Request = ServiceRequest;
type Response = ServiceResponse<Body>;
type Error = Error;
type InitError = ();
type Service = ResourceService;
type Future = CreateResourceService;
}
impl<T, U> NewService for OpensslConnector<T, U> where T: Address, U: AsyncRead, U: AsyncWrite, U: Debug {
type Request = Connection<T, U>;
type Response = Connection<T, SslStream<U>>;
type Error = HandshakeError<U>;
type Config = ();
type Service = OpensslConnectorService<T, U>;
type InitError = ();
type Future = FutureResult<{unknown}, {unknown}>;
}
impl NewService for ResourceEndpoint {
type Config = ();
type Request = ServiceRequest;
type Response = ServiceResponse<Body>;
type Error = Error;
type InitError = ();
type Service = ResourceService;
type Future = CreateResourceService;
}
impl<A, B> NewService for Either<A, B> where A: NewService, B: NewService, <B as NewService>::Config = {unknown}, <B as NewService>::Response = {unknown}, <B as NewService>::Error = {unknown}, <B as NewService>::InitError = {unknown} {
type Request = Either<{unknown}, {unknown}>;
type Response = {unknown};
type Error = {unknown};
type InitError = {unknown};
type Config = {unknown};
type Service = EitherService<{unknown}, {unknown}>;
type Future = EitherNewService<A, B>;
}
impl<T, P> NewService for OneRequest<T, P> where T: IoStream {
type Config = ServerConfig;
type Request = Io<T, P>;
type Response = (Request<Box<dyn Stream<Item = Bytes, Error = PayloadError>>>, Framed<T, Codec>);
type Error = ParseError;
type InitError = ();
type Service = OneRequestService<T, P>;
type Future = FutureResult<{unknown}, {unknown}>;
}
impl<F, Req, Out, Cfg> NewService for NewServiceFn<F, Req, Out, Cfg> where F: FnMut<{unknown}>, Out: IntoFuture {
type Request = Req;
type Response = {unknown};
type Error = {unknown};
type Config = Cfg;
type Service = ServiceFn<F, Req, Out>;
type InitError = ();
type Future = FutureResult<{unknown}, {unknown}>;
}
impl<A, B> NewService for AndThenNewService<A, B> where A: NewService, B: NewService, <B as NewService>::Config = {unknown}, <B as NewService>::Request = {unknown}, <B as NewService>::Error = {unknown}, <B as NewService>::InitError = {unknown} {
type Request = {unknown};
type Response = {unknown};
type Error = {unknown};
type Config = {unknown};
type Service = AndThen<{unknown}, {unknown}>;
type InitError = {unknown};
type Future = AndThenNewServiceFuture<A, B>;
}
impl<F, C, R, S, E> NewService for FnNewServiceConfig<F, C, R, S, E> where F: Fn<{unknown}>, R: IntoFuture, <R as IntoFuture>::Error = E, {unknown}: IntoService<S>, S: Service {
type Request = {unknown};
type Response = {unknown};
type Error = {unknown};
type Config = C;
type Service = S;
type InitError = E;
type Future = FnNewServiceConfigFut<R, S, E>;
}
impl<T, U> NewService for RustlsConnector<T, U> where T: Address, U: AsyncRead, U: AsyncWrite, U: Debug {
type Request = Connection<T, U>;
type Response = Connection<T, TlsStream<U, ClientSession>>;
type Error = Error;
type Config = ();
type Service = RustlsConnectorService<T, U>;
type InitError = ();
type Future = FutureResult<{unknown}, {unknown}>;
}
impl<C, T, Req, Res, Err, InitErr> NewService for NewServiceWrapper<C, T> where {error}, {error}, {error}, {error}, T: NewService, <T as NewService>::Config = C, <T as NewService>::Request = Req, <T as NewService>::Response = Res, <T as NewService>::Error = Err, <T as NewService>::InitError = InitErr, {error}, {error}, {error} {
type Request = Req;
type Response = Res;
type Error = Err;
type InitError = InitErr;
type Config = C;
type Service = Box<dyn Service<Request = Req, Response = Res, Error = Err, Future = Either<FutureResult<Res, Err>, Box<dyn Future<Item = Res, Error = Err>>>>>;
type Future = Box<dyn Future<Item = {unknown}, Error = {unknown}>>;
}
impl<T> NewService for UpgradeHandler<T> {
type Config = ServerConfig;
type Request = (Request<Box<dyn Stream<Item = Bytes, Error = PayloadError>>>, Framed<T, Codec>);
type Response = ();
type Error = Error;
type Service = UpgradeHandler<T>;
type InitError = Error;
type Future = FutureResult<{unknown}, {unknown}>;
}
impl<T, P> NewService for OpensslAcceptor<T, P> where T: AsyncRead, T: AsyncWrite {
type Request = Io<T, P>;
type Response = Io<SslStream<T>, P>;
type Error = HandshakeError<T>;
type Config = ServerConfig;
type Service = OpensslAcceptorService<T, P>;
type InitError = ();
type Future = FutureResult<{unknown}, {unknown}>;
}
impl<T> NewService for TcpConnectorFactory<T> where T: Address {
type Request = Connect<T>;
type Response = Connection<T, TcpStream>;
type Error = ConnectError;
type Config = ();
type Service = TcpConnector<T>;
type InitError = ();
type Future = FutureResult<{unknown}, {unknown}>;
}
impl<F, C, T, R, S> NewService for ApplyConfigNewService<F, C, T, R, S> where C: Clone, F: FnMut<{unknown}>, T: NewService, <T as NewService>::Config = (), {unknown}: From<{unknown}>, R: IntoFuture, <R as IntoFuture>::Error = {unknown}, {unknown}: IntoService<S>, S: Service {
type Config = C;
type Request = {unknown};
type Response = {unknown};
type Error = {unknown};
type Service = S;
type InitError = {unknown};
type Future = ApplyConfigNewServiceFut<F, C, T, R, S>;
}
impl<T, A, B> NewService for AndThenTransform<T, A, B> where A: NewService, B: NewService, <B as NewService>::Config = {unknown}, <B as NewService>::InitError = {unknown}, T: Transform<{unknown}>, <T as Transform<{unknown}>>::Request = {unknown}, <T as Transform<{unknown}>>::InitError = {unknown}, {unknown}: From<{unknown}> {
type Request = {unknown};
type Response = {unknown};
type Error = {unknown};
type Config = {unknown};
type InitError = {unknown};
type Service = AndThen<FromErr<{unknown}, {unknown}>, {unknown}>;
type Future = AndThenTransformFuture<T, A, B>;
}
impl<A, B, F, Out> NewService for AndThenApplyNewService<A, B, F, Out> where A: NewService, B: NewService, <B as NewService>::Config = {unknown}, <B as NewService>::Error = {unknown}, <B as NewService>::InitError = {unknown}, F: FnMut<{unknown}>, Out: IntoFuture, {unknown}: Into<{unknown}> {
type Request = {unknown};
type Response = {unknown};
type Error = {unknown};
type Service = AndThenApply<{unknown}, {unknown}, F, Out>;
type Config = {unknown};
type InitError = {unknown};
type Future = AndThenApplyNewServiceFuture<A, B, F, Out>;
}
impl<A, E> NewService for FromErrNewService<A, E> where A: NewService, E: From<{unknown}> {
type Request = {unknown};
type Response = {unknown};
type Error = E;
type Config = {unknown};
type Service = FromErr<{unknown}, E>;
type InitError = {unknown};
type Future = FromErrNewServiceFuture<A, E>;
}
impl<T, S> NewService for ApplyTransform<T, S> where S: NewService, T: Transform<{unknown}>, <T as Transform<{unknown}>>::InitError = {unknown} {
type Request = {unknown};
type Response = {unknown};
type Error = {unknown};
type Config = {unknown};
type Service = {unknown};
type InitError = {unknown};
type Future = ApplyTransformFuture<T, S>;
}
impl<C, Req, Res, Err, InitErr> NewService for BoxedNewService<C, Req, Res, Err, InitErr> where {error}, {error}, {error}, {error} {
type Request = Req;
type Response = Res;
type Error = Err;
type InitError = InitErr;
type Config = C;
type Service = Box<dyn Service<Request = Req, Response = Res, Error = Err, Future = Either<FutureResult<Res, Err>, Box<dyn Future<Item = Res, Error = Err>>>>>;
type Future = Box<dyn Future<Item = {unknown}, Error = {unknown}>>;
}
impl<T, B> NewService for AppInit<T, B> where T: NewService, <T as NewService>::Config = (), <T as NewService>::Request = ServiceRequest, <T as NewService>::Response = ServiceResponse<B>, <T as NewService>::Error = Error, <T as NewService>::InitError = () {
type Config = ServerConfig;
type Request = Request<Box<dyn Stream<Item = Bytes, Error = PayloadError>>>;
type Response = ServiceResponse<B>;
type Error = {unknown};
type InitError = {unknown};
type Service = AppInitService<{unknown}, B>;
type Future = AppInitResult<T, B>;
}
impl<T> NewService for RouteNewService<T> where T: NewService, <T as NewService>::Config = (), <T as NewService>::Request = ServiceRequest, <T as NewService>::Response = ServiceResponse<Body>, <T as NewService>::Error = (Error, ServiceRequest), {error}, {error}, {error} {
type Config = ();
type Request = ServiceRequest;
type Response = ServiceResponse<Body>;
type Error = Error;
type InitError = ();
type Service = Box<dyn Service<Request = ServiceRequest, Response = {unknown}, Error = Error, Future = Either<FutureResult<{unknown}, Error>, Box<dyn Future<Item = {unknown}, Error = Error>>>>>;
type Future = Box<dyn Future<Item = {unknown}, Error = {unknown}>>;
}
impl NewService for ScopeFactory {
type Config = ();
type Request = ServiceRequest;
type Response = ServiceResponse<Body>;
type Error = Error;
type InitError = ();
type Service = ScopeService;
type Future = ScopeFactoryResponse;
}
impl<S> NewService for Arc<S> where S: NewService {
type Request = {unknown};
type Response = {unknown};
type Error = {unknown};
type Config = {unknown};
type Service = {unknown};
type InitError = {unknown};
type Future = {unknown};
}
impl<A, F, E> NewService for MapInitErr<A, F, E> where A: NewService, F: Fn<{unknown}> {
type Request = {unknown};
type Response = {unknown};
type Error = {unknown};
type Config = {unknown};
type Service = {unknown};
type InitError = E;
type Future = MapInitErrFuture<A, F, E>;
}
impl<A, F, Res> NewService for MapNewService<A, F, Res> where A: NewService, F: FnMut<{unknown}> {
type Request = {unknown};
type Response = Res;
type Error = {unknown};
type Config = {unknown};
type Service = Map<{unknown}, F, Res>;
type InitError = {unknown};
type Future = MapNewServiceFuture<A, F, Res>;
}
impl<T, P> NewService for NativeTlsAcceptor<T, P> where T: AsyncRead, T: AsyncWrite {
type Request = Io<T, P>;
type Response = Io<TlsStream<T>, P>;
type Error = {unknown};
type Config = ServerConfig;
type Service = NativeTlsAcceptorService<T, P>;
type InitError = ();
type Future = FutureResult<{unknown}, {unknown}>;
}
impl<A, F, C> NewService for MapConfig<A, F, C> where A: NewService, F: Fn<{unknown}> {
type Request = {unknown};
type Response = {unknown};
type Error = {unknown};
type Config = C;
type Service = {unknown};
type InitError = {unknown};
type Future = {unknown};
}
impl<A, F, E> NewService for MapErrNewService<A, F, E> where A: NewService, F: Fn<{unknown}> {
type Request = {unknown};
type Response = {unknown};
type Error = E;
type Config = {unknown};
type Service = MapErr<{unknown}, F, E>;
type InitError = {unknown};
type Future = MapErrNewServiceFuture<A, F, E>;
}
impl<T> NewService for ConnectServiceFactory<T> where T: Address {
type Request = Connect<T>;
type Response = Connection<T, TcpStream>;
type Error = ConnectError;
type Config = ();
type Service = ConnectService<T>;
type InitError = ();
type Future = FutureResult<{unknown}, {unknown}>;
}
impl<T, P, S, B, X, U> NewService for HttpService<T, P, S, B, X, U> where T: IoStream, S: NewService, <S as NewService>::Config = ServerConfig, <S as NewService>::Request = Request<Box<dyn Stream<Item = Bytes, Error = PayloadError>>>, {unknown}: Into<Error>, {unknown}: Debug, {unknown}: Into<Response<B>>, {error}, B: MessageBody, {error}, X: NewService, <X as NewService>::Config = ServerConfig, <X as NewService>::Request = Request<Box<dyn Stream<Item = Bytes, Error = PayloadError>>>, <X as NewService>::Response = Request<Box<dyn Stream<Item = Bytes, Error = PayloadError>>>, {unknown}: Into<Error>, {unknown}: Debug, U: NewService, <U as NewService>::Config = ServerConfig, <U as NewService>::Request = (Request<Box<dyn Stream<Item = Bytes, Error = PayloadError>>>, Framed<T, Codec>), <U as NewService>::Response = (), {unknown}: Display, {unknown}: Debug {
type Config = ServerConfig;
type Request = Io<T, P>;
type Response = ();
type Error = DispatchError;
type InitError = ();
type Service = HttpServiceHandler<T, P, {unknown}, B, {unknown}, {unknown}>;
type Future = HttpServiceResponse<T, P, S, B, X, U>;
}
impl<S> NewService for Rc<S> where S: NewService {
type Request = {unknown};
type Response = {unknown};
type Error = {unknown};
type Config = {unknown};
type Service = {unknown};
type InitError = {unknown};
type Future = {unknown};
}
impl<A, B> NewService for ThenNewService<A, B> where A: NewService, B: NewService, <B as NewService>::Config = {unknown}, <B as NewService>::Request = Result<{unknown}, {unknown}>, <B as NewService>::Error = {unknown}, <B as NewService>::InitError = {unknown} {
type Request = {unknown};
type Response = {unknown};
type Error = {unknown};
type Config = {unknown};
type Service = Then<{unknown}, {unknown}>;
type InitError = {unknown};
type Future = ThenNewServiceFuture<A, B>;
}
impl<T, F, In, Out> NewService for ApplyNewService<T, F, In, Out> where T: NewService, F: FnMut<{unknown}>, Out: IntoFuture, {unknown}: From<{unknown}> {
type Request = In;
type Response = {unknown};
type Error = {unknown};
type Config = {unknown};
type Service = Apply<{unknown}, F, In, Out>;
type InitError = {unknown};
type Future = ApplyNewServiceFuture<T, F, In, Out>;
}
impl NewService for ScopeEndpoint {
type Config = ();
type Request = ServiceRequest;
type Response = ServiceResponse<Body>;
type Error = Error;
type InitError = ();
type Service = ScopeService;
type Future = ScopeFactoryResponse;
}
impl<T> NewService for ServiceFactory<T> where T: NewService, <T as NewService>::Config = ServerConfig, <T as NewService>::Request = Io<TcpStream, {unknown}>, {error}, {error}, {error}, {unknown}: Debug, {error} {
type Request = (Option<CounterGuard>, ServerMessage);
type Response = ();
type Error = ();
type InitError = ();
type Config = ServerConfig;
type Service = Box<dyn Service<Request = (Option<CounterGuard>, ServerMessage), Response = (), Error = (), Future = FutureResult<(), ()>>>;
type Future = Box<dyn Future<Item = Box<dyn Service<Request = (Option<CounterGuard>, ServerMessage), Response = (), Error = (), Future = FutureResult<(), ()>>>, Error = ()>>;
}
impl NewService for Route {
type Config = ();
type Request = ServiceRequest;
type Response = ServiceResponse<Body>;
type Error = Error;
type InitError = ();
type Service = RouteService;
type Future = CreateRouteService;
}
impl NewService for LowResTime {
type Request = ();
type Response = Instant;
type Error = Infallible;
type InitError = Infallible;
type Config = ();
type Service = LowResTimeService;
type Future = FutureResult<{unknown}, {unknown}>;
}
impl<T> NewService for OpensslConnectServiceFactory<T> where T: Address {
type Request = Connect<T>;
type Response = SslStream<TcpStream>;
type Error = ConnectError;
type Config = ();
type Service = OpensslConnectService<T>;
type InitError = ();
type Future = FutureResult<{unknown}, {unknown}>;
}
impl<T, S> NewService for Extract<T, S> where T: FromRequest, S: Service, <S as Service>::Request = (T, HttpRequest), <S as Service>::Response = ServiceResponse<Body>, <S as Service>::Error = Infallible, S: Clone {
type Config = ();
type Request = ServiceRequest;
type Response = ServiceResponse<Body>;
type Error = (Error, ServiceRequest);
type InitError = ();
type Service = ExtractService<T, S>;
type Future = FutureResult<{unknown}, ()>;
}
impl<T, P> NewService for RustlsAcceptor<T, P> where T: AsyncRead, T: AsyncWrite {
type Request = Io<T, P>;
type Response = Io<TlsStream<T, ServerSession>, P>;
type Error = Error;
type Config = ServerConfig;
type Service = RustlsAcceptorService<T, P>;
type InitError = ();
type Future = FutureResult<{unknown}, {unknown}>;
}
impl<T, P, S, B> NewService for H2Service<T, P, S, B> where T: IoStream, S: NewService, <S as NewService>::Config = ServerConfig, <S as NewService>::Request = Request<Box<dyn Stream<Item = Bytes, Error = PayloadError>>>, {unknown}: Into<Error>, {unknown}: Into<Response<B>>, {error}, B: MessageBody, {error} {
type Config = ServerConfig;
type Request = Io<T, P>;
type Response = ();
type Error = DispatchError;
type InitError = {unknown};
type Service = H2ServiceHandler<T, P, {unknown}, B>;
type Future = H2ServiceResponse<T, P, S, B>;
}
trait NewService {
type Request;
type Response;
type Error;
type Config;
type Service;
type InitError;
type Future;
}
struct OneRequest<T, P>;
trait Service {
type Request;
type Response;
type Error;
type Future;
}
impl<T, P, S, B, X, U> Service for H1ServiceHandler<T, P, S, B, X, U> where T: IoStream, S: Service, <S as Service>::Request = Request<Box<dyn Stream<Item = Bytes, Error = PayloadError>>>, {unknown}: Into<Error>, {unknown}: Into<Response<B>>, B: MessageBody, X: Service, <X as Service>::Request = Request<Box<dyn Stream<Item = Bytes, Error = PayloadError>>>, <X as Service>::Response = Request<Box<dyn Stream<Item = Bytes, Error = PayloadError>>>, {unknown}: Into<Error>, U: Service, <U as Service>::Request = (Request<Box<dyn Stream<Item = Bytes, Error = PayloadError>>>, Framed<T, Codec>), <U as Service>::Response = (), {unknown}: Display {
type Request = Io<T, P>;
type Response = ();
type Error = DispatchError;
type Future = Dispatcher<T, S, B, X, U>;
}
impl<A, B> Service for AndThen<A, B> where A: Service, B: Service, <B as Service>::Request = {unknown}, <B as Service>::Error = {unknown} {
type Request = {unknown};
type Response = {unknown};
type Error = {unknown};
type Future = AndThenFuture<A, B>;
}
impl Service for ExpectHandler {
type Request = Request<Box<dyn Stream<Item = Bytes, Error = PayloadError>>>;
type Response = Request<Box<dyn Stream<Item = Bytes, Error = PayloadError>>>;
type Error = Error;
type Future = FutureResult<{unknown}, {unknown}>;
}
impl Service for SleepService {
type Request = ();
type Response = ();
type Error = ();
type Future = Box<{unknown}>;
}
impl Service for Srv {
type Request = ();
type Response = ();
type Error = ();
type Future = FutureResult<(), ()>;
}
impl Service for RouteService {
type Request = ServiceRequest;
type Response = ServiceResponse<Body>;
type Error = Error;
type Future = Either<FutureResult<{unknown}, {unknown}>, Box<dyn Future<Item = {unknown}, Error = {unknown}>>>;
}
impl<T, S> Service for ExtractService<T, S> where T: FromRequest, S: Service, <S as Service>::Request = (T, HttpRequest), <S as Service>::Response = ServiceResponse<Body>, <S as Service>::Error = Infallible, S: Clone {
type Request = ServiceRequest;
type Response = ServiceResponse<Body>;
type Error = (Error, ServiceRequest);
type Future = ExtractResponse<T, S>;
}
impl<S> Service for TimeoutService<S> where S: Service {
type Request = {unknown};
type Response = {unknown};
type Error = TimeoutError<{unknown}>;
type Future = TimeoutServiceResponse<S>;
}
impl<T> Service for InFlightService<T> where T: Service {
type Request = {unknown};
type Response = {unknown};
type Error = {unknown};
type Future = InFlightServiceResponse<T>;
}
impl<T, P> Service for OneRequestService<T, P> where T: IoStream {
type Request = Io<T, P>;
type Response = (Request<Box<dyn Stream<Item = Bytes, Error = PayloadError>>>, Framed<T, Codec>);
type Error = ParseError;
type Future = OneRequestServiceResponse<T>;
}
impl<T, P> Service for RustlsAcceptorService<T, P> where T: AsyncRead, T: AsyncWrite {
type Request = Io<T, P>;
type Response = Io<TlsStream<T, ServerSession>, P>;
type Error = Error;
type Future = RustlsAcceptorServiceFut<T, P>;
}
impl<S, B> Service for DefaultHeadersMiddleware<S> where S: Service, <S as Service>::Request = ServiceRequest, <S as Service>::Response = ServiceResponse<B>, <S as Service>::Error = Error, {error} {
type Request = ServiceRequest;
type Response = ServiceResponse<B>;
type Error = Error;
type Future = Box<dyn Future<Item = {unknown}, Error = {unknown}>>;
}
impl<A, F, Response> Service for Map<A, F, Response> where A: Service, F: FnMut<{unknown}> {
type Request = {unknown};
type Response = Response;
type Error = {unknown};
type Future = MapFuture<A, F, Response>;
}
impl<A, B> Service for Then<A, B> where A: Service, B: Service, <B as Service>::Request = Result<{unknown}, {unknown}>, <B as Service>::Error = {unknown} {
type Request = {unknown};
type Response = {unknown};
type Error = {unknown};
type Future = ThenFuture<A, B>;
}
impl Service for ScopeService {
type Request = ServiceRequest;
type Response = ServiceResponse<Body>;
type Error = Error;
type Future = Either<Either<FutureResult<ServiceResponse<Body>, Error>, Box<dyn Future<Item = ServiceResponse<Body>, Error = Error>>>, FutureResult<{unknown}, {unknown}>>;
}
impl<A, E> Service for FromErr<A, E> where A: Service, E: From<{unknown}> {
type Request = {unknown};
type Response = {unknown};
type Error = E;
type Future = FromErrFuture<A, E>;
}
impl<S, T, E> Service for StreamService<S, T, E> where S: IntoStream, {error}, T: NewService, <T as NewService>::Request = Result<<S as IntoStream>::Item, <S as IntoStream>::Error>, <T as NewService>::Response = (), <T as NewService>::Error = E, <T as NewService>::InitError = E, {error}, {error}, {error} {
type Request = S;
type Response = ();
type Error = E;
type Future = Box<{unknown}>;
}
impl Service for LowResTimeService {
type Request = ();
type Response = Instant;
type Error = Infallible;
type Future = FutureResult<{unknown}, {unknown}>;
}
impl<T> Service for ConnectService<T> where T: Address {
type Request = Connect<T>;
type Response = Connection<T, TcpStream>;
type Error = ConnectError;
type Future = ConnectServiceResponse<T>;
}
impl<T, U> Service for OpensslConnectorService<T, U> where T: Address, U: AsyncRead, U: AsyncWrite, U: Debug {
type Request = Connection<T, U>;
type Response = Connection<T, SslStream<U>>;
type Error = HandshakeError<U>;
type Future = ConnectAsyncExt<T, U>;
}
impl<S> Service for &mut S where S: Service, {error} {
type Request = {unknown};
type Response = {unknown};
type Error = {unknown};
type Future = {unknown};
}
impl<T, P, S, B, X, U> Service for HttpServiceHandler<T, P, S, B, X, U> where T: IoStream, S: Service, <S as Service>::Request = Request<Box<dyn Stream<Item = Bytes, Error = PayloadError>>>, {unknown}: Into<Error>, {error}, {unknown}: Into<Response<B>>, B: MessageBody, {error}, X: Service, <X as Service>::Request = Request<Box<dyn Stream<Item = Bytes, Error = PayloadError>>>, <X as Service>::Response = Request<Box<dyn Stream<Item = Bytes, Error = PayloadError>>>, {unknown}: Into<Error>, U: Service, <U as Service>::Request = (Request<Box<dyn Stream<Item = Bytes, Error = PayloadError>>>, Framed<T, Codec>), <U as Service>::Response = (), {unknown}: Display {
type Request = Io<T, P>;
type Response = ();
type Error = DispatchError;
type Future = HttpServiceHandlerResponse<T, S, B, X, U>;
}
impl<S, B> Service for ErrorHandlersMiddleware<S, B> where S: Service, <S as Service>::Request = ServiceRequest, <S as Service>::Response = ServiceResponse<B>, <S as Service>::Error = Error, {error}, {error} {
type Request = ServiceRequest;
type Response = ServiceResponse<B>;
type Error = Error;
type Future = Box<dyn Future<Item = {unknown}, Error = {unknown}>>;
}
impl Service for Srv2 {
type Request = Result<&str, ()>;
type Response = (&str, &str);
type Error = ();
type Future = FutureResult<{unknown}, ()>;
}
impl<T> Service for RouteServiceWrapper<T> where {error}, T: Service, <T as Service>::Request = ServiceRequest, <T as Service>::Response = ServiceResponse<Body>, <T as Service>::Error = (Error, ServiceRequest) {
type Request = ServiceRequest;
type Response = ServiceResponse<Body>;
type Error = Error;
type Future = Either<FutureResult<{unknown}, {unknown}>, Box<dyn Future<Item = {unknown}, Error = {unknown}>>>;
}
impl<T> Service for OpensslConnectService<T> where T: Address {
type Request = Connect<T>;
type Response = SslStream<TcpStream>;
type Error = ConnectError;
type Future = OpensslConnectServiceResponse<T>;
}
impl<F, T, R> Service for AsyncHandler<F, T, R> where F: AsyncFactory<T, R>, R: IntoFuture, {unknown}: Responder, {unknown}: Into<Error> {
type Request = (T, HttpRequest);
type Response = ServiceResponse<Body>;
type Error = Infallible;
type Future = AsyncHandlerServiceResponse<{unknown}>;
}
impl Service for Srv {
type Request = ();
type Response = ();
type Error = ();
type Future = FutureResult<(), ()>;
}
impl<S, B> Service for LoggerMiddleware<S> where S: Service, <S as Service>::Request = ServiceRequest, <S as Service>::Response = ServiceResponse<B>, <S as Service>::Error = Error, B: MessageBody {
type Request = ServiceRequest;
type Response = ServiceResponse<StreamLog<B>>;
type Error = Error;
type Future = LoggerResponse<S, B>;
}
impl<T, I> Service for StreamService<T> where T: Service, <T as Service>::Request = Io<I, {unknown}>, {error}, {error}, I: FromStream {
type Request = (Option<CounterGuard>, ServerMessage);
type Response = ();
type Error = ();
type Future = FutureResult<(), ()>;
}
impl Service for Srv {
type Request = Receiver<usize>;
type Response = usize;
type Error = ();
type Future = Box<{unknown}>;
}
impl<T, P, S, B> Service for H2ServiceHandler<T, P, S, B> where T: IoStream, S: Service, <S as Service>::Request = Request<Box<dyn Stream<Item = Bytes, Error = PayloadError>>>, {unknown}: Into<Error>, {error}, {unknown}: Into<Response<B>>, B: MessageBody, {error} {
type Request = Io<T, P>;
type Response = ();
type Error = DispatchError;
type Future = H2ServiceHandlerResponse<T, S, B>;
}
impl Service for Srv {
type Request = ();
type Response = ();
type Error = ();
type Future = FutureResult<(), ()>;
}
impl Service for Srv1 {
type Request = Result<&str, &str>;
type Response = &str;
type Error = ();
type Future = FutureResult<{unknown}, {unknown}>;
}
impl<S, B> Service for NormalizePathNormalization<S> where S: Service, <S as Service>::Request = ServiceRequest, <S as Service>::Response = ServiceResponse<B>, <S as Service>::Error = Error, {error} {
type Request = ServiceRequest;
type Response = ServiceResponse<B>;
type Error = Error;
type Future = {unknown};
}
impl<T1, T2, Io1, Io2> Service for InnerConnector<T1, T2, Io1, Io2> where Io1: AsyncRead, Io1: AsyncWrite, {error}, Io2: AsyncRead, Io2: AsyncWrite, {error}, T1: Service, <T1 as Service>::Request = Connect, <T1 as Service>::Response = (Io1, Protocol), <T1 as Service>::Error = ConnectError, T1: Clone, {error}, T2: Service, <T2 as Service>::Request = Connect, <T2 as Service>::Response = (Io2, Protocol), <T2 as Service>::Error = ConnectError, T2: Clone, {error} {
type Request = Connect;
type Response = EitherConnection<Io1, Io2>;
type Error = ConnectError;
type Future = Either<FutureResult<{unknown}, {unknown}>, Either<InnerConnectorResponseA<T1, Io1, Io2>, InnerConnectorResponseB<T2, Io1, Io2>>>;
}
impl Service for AppRouting {
type Request = ServiceRequest;
type Response = ServiceResponse<Body>;
type Error = Error;
type Future = Either<FutureResult<ServiceResponse<Body>, Error>, Box<dyn Future<Item = ServiceResponse<Body>, Error = Error>>>;
}
impl<T> Service for UpgradeHandler<T> {
type Request = (Request<Box<dyn Stream<Item = Bytes, Error = PayloadError>>>, Framed<T, Codec>);
type Response = ();
type Error = Error;
type Future = FutureResult<{unknown}, {unknown}>;
}
impl Service for ResourceService {
type Request = ServiceRequest;
type Response = ServiceResponse<Body>;
type Error = Error;
type Future = Either<FutureResult<ServiceResponse<Body>, Error>, Box<dyn Future<Item = ServiceResponse<Body>, Error = Error>>>;
}
impl<R, E> Service for Blank<R, E> {
type Request = R;
type Response = R;
type Error = E;
type Future = FutureResult<R, E>;
}
impl<S> Service for Rc<RefCell<S>> where S: Service {
type Request = {unknown};
type Response = {unknown};
type Error = {unknown};
type Future = {unknown};
}
impl<T, P> Service for OpensslAcceptorService<T, P> where T: AsyncRead, T: AsyncWrite {
type Request = Io<T, P>;
type Response = Io<SslStream<T>, P>;
type Error = HandshakeError<T>;
type Future = OpensslAcceptorServiceFut<T, P>;
}
impl<F, T, R> Service for Handler<F, T, R> where F: Factory<T, R>, R: Responder {
type Request = (T, HttpRequest);
type Response = ServiceResponse<Body>;
type Error = Infallible;
type Future = HandlerServiceResponse<<{unknown} as IntoFuture>::Future>;
}
impl<A, B> Service for EitherService<A, B> where A: Service, B: Service, <B as Service>::Response = {unknown}, <B as Service>::Error = {unknown} {
type Request = Either<{unknown}, {unknown}>;
type Response = {unknown};
type Error = {unknown};
type Future = Either<{unknown}, {unknown}>;
}
impl<T, F, In, Out> Service for Apply<T, F, In, Out> where T: Service, F: FnMut<{unknown}>, Out: IntoFuture, {unknown}: From<{unknown}> {
type Request = In;
type Response = {unknown};
type Error = {unknown};
type Future = {unknown};
}
impl<F, Req, Out> Service for ServiceFn<F, Req, Out> where F: FnMut<{unknown}>, Out: IntoFuture {
type Request = Req;
type Response = {unknown};
type Error = {unknown};
type Future = {unknown};
}
impl<T, Io> Service for ConnectionPool<T, Io> where Io: AsyncRead, Io: AsyncWrite, {error}, T: Service, <T as Service>::Request = Connect, <T as Service>::Response = (Io, Protocol), <T as Service>::Error = ConnectError, T: Clone, {error} {
type Request = Connect;
type Response = IoConnection<Io>;
type Error = ConnectError;
type Future = Either<FutureResult<{unknown}, {unknown}>, Either<WaitForConnection<Io>, OpenConnection<{unknown}, Io>>>;
}
impl<T> Service for TcpConnector<T> where T: Address {
type Request = Connect<T>;
type Response = Connection<T, TcpStream>;
type Error = ConnectError;
type Future = Either<TcpConnectorResponse<T>, FutureResult<{unknown}, {unknown}>>;
}
impl<T> Service for Resolver<T> where T: Address {
type Request = Connect<T>;
type Response = Connect<T>;
type Error = ConnectError;
type Future = Either<ResolverFuture<T>, FutureResult<Connect<T>, {unknown}>>;
}
impl<S> Service for InOrderService<S> where S: Service, {error}, {error}, {error} {
type Request = {unknown};
type Response = {unknown};
type Error = InOrderError<{unknown}>;
type Future = InOrderServiceResponse<S>;
}
impl<T, Req, Res, Err> Service for ServiceWrapper<T> where T: Service, <T as Service>::Request = Req, <T as Service>::Response = Res, <T as Service>::Error = Err, {error} {
type Request = Req;
type Response = Res;
type Error = Err;
type Future = Either<FutureResult<{unknown}, {unknown}>, Box<dyn Future<Item = {unknown}, Error = {unknown}>>>;
}
impl<S, B> Service for CompressMiddleware<S> where B: MessageBody, S: Service, <S as Service>::Request = ServiceRequest, <S as Service>::Response = ServiceResponse<B>, <S as Service>::Error = Error {
type Request = ServiceRequest;
type Response = ServiceResponse<Encoder<B>>;
type Error = Error;
type Future = CompressResponse<S, B>;
}
impl Service for Srv {
type Request = ();
type Response = ();
type Error = ();
type Future = FutureResult<(), ()>;
}
impl<R, E, F> Service for KeepAliveService<R, E, F> where F: Fn<{unknown}> {
type Request = R;
type Response = R;
type Error = E;
type Future = FutureResult<R, E>;
}
impl<S> Service for Box<S> where S: Service {
type Request = {unknown};
type Response = {unknown};
type Error = {unknown};
type Future = {unknown};
}
impl Service for Srv2 {
type Request = &str;
type Response = (&str, &str);
type Error = ();
type Future = FutureResult<{unknown}, ()>;
}
impl Service for SleepService {
type Request = ();
type Response = ();
type Error = ();
type Future = Box<{unknown}>;
}
impl<T, P> Service for NativeTlsAcceptorService<T, P> where T: AsyncRead, T: AsyncWrite {
type Request = Io<T, P>;
type Response = Io<TlsStream<T>, P>;
type Error = {unknown};
type Future = Accept<T, P>;
}
impl<A, B, F, Out> Service for AndThenApply<A, B, F, Out> where A: Service, B: Service, <B as Service>::Error = {unknown}, F: FnMut<{unknown}>, Out: IntoFuture, {unknown}: Into<{unknown}> {
type Request = {unknown};
type Response = {unknown};
type Error = {unknown};
type Future = AndThenApplyFuture<A, B, F, Out>;
}
impl<T, U> Service for RustlsConnectorService<T, U> where T: Address, U: AsyncRead, U: AsyncWrite, U: Debug {
type Request = Connection<T, U>;
type Response = Connection<T, TlsStream<U, ClientSession>>;
type Error = Error;
type Future = ConnectAsyncExt<T, U>;
}
impl<T, B> Service for AppInitService<T, B> where T: Service, <T as Service>::Request = ServiceRequest, <T as Service>::Response = ServiceResponse<B>, <T as Service>::Error = Error {
type Request = Request<Box<dyn Stream<Item = Bytes, Error = PayloadError>>>;
type Response = ServiceResponse<B>;
type Error = {unknown};
type Future = {unknown};
}
impl<A, F, E> Service for MapErr<A, F, E> where A: Service, F: Fn<{unknown}> {
type Request = {unknown};
type Response = {unknown};
type Error = E;
type Future = MapErrFuture<A, F, E>;
}
impl Service for Srv {
type Request = ();
type Response = ();
type Error = ();
type Future = FutureResult<(), ()>;
}
impl<T> Service for CloneableService<T> where T: Service {
type Request = {unknown};
type Response = {unknown};
type Error = {unknown};
type Future = {unknown};
}
impl Service for Srv1 {
type Request = &str;
type Response = &str;
type Error = ();
type Future = FutureResult<{unknown}, ()>;
}
impl Service for Srv {
type Request = ();
type Response = ();
type Error = ();
type Future = FutureResult<(), ()>;
}
struct NewServiceWrapper<C, T>;
struct OpensslAcceptor<T, P>;
struct NativeTlsAcceptor<T, P>;
trait Address {}
impl Address for String {}
impl Address for Uri {}
impl Address for &str {}
trait Fn<Args> {}
impl<A, F> Fn<A> for &F where F: Fn<A> {}
struct RustlsAcceptor<T, P>;
trait Debug {}
impl Debug for Clock {}
impl<H> Debug for EventLoop<H> where H: Handler {}
impl Debug for Literals {}
impl<T> Debug for Query<T> where T: Debug {}
impl<T, P> Debug for RSplit<T, P> where T: Debug, P: FnMut<{unknown}> {}
impl<P> Debug for Entered<P> where P: Park {}
impl<K, V> Debug for IterMut<K, V> where K: Debug, V: Debug {}
impl<T> Debug for Iter<T> {}
impl<T> Debug for Wrapping<T> where T: Debug {}
impl<W> Debug for BufWriter<W> where W: Write, W: Debug {}
impl Debug for ConnectAddrsIter {}
impl Debug for IsaacCore {}
impl Debug for RangeFull {}
impl Debug for Ipv4Addr {}
impl Debug for LexError {}
impl<T> Debug for Rc<T> where T: Debug {}
impl<I> Debug for JoinAll<I> where I: IntoIterator, {error}, {unknown}: Debug, {unknown}: Debug {}
impl<P> Debug for SplitNInternal<P> where P: Pattern, {unknown}: Debug {}
impl Debug for Stdio {}
impl Debug for UdpBuilder {}
impl Debug for Transitions {}
impl Debug for ClassInduct {}
impl<E> Debug for TimeoutError<E> where E: Debug {}
impl<T> Debug for *mut T {}
impl<K, V, S> Debug for RawEntryBuilderMut<K, V, S> {}
impl<F> Debug for Inner<F> where {error}, F: Debug, {unknown}: Debug, {unknown}: Debug {}
impl Debug for Program {}
impl<Tz> Debug for DateTime<Tz> where Tz: TimeZone {}
impl Debug for RandomState {}
impl Debug for ArgsOs {}
impl<T> Debug for LocalKey<T> where {error} {}
impl<T, B> Debug for Handshaking<T, B> where B: IntoBuf {}
impl Debug for Registration {}
impl<T> Debug for IntoIter<T> where T: Debug {}
impl<K, V> Debug for BTreeMap<K, V> where K: Debug, V: Debug {}
impl<T> Debug for RwLock<T> where T: Debug {}
impl<K, V> Debug for ValuesMut<K, V> where K: Debug, V: Debug {}
impl Debug for X509VerifyResult {}
impl Debug for Iter {}
impl Debug for {unknown} {}
impl Debug for ServerSessionImpl {}
impl Debug for Utc {}
impl<S> Debug for UniCase<S> where S: Debug {}
impl<T> Debug for TrySendError<T> {}
impl Debug for Error {}
impl<K, V, S> Debug for HashMap<K, V, S> where K: Eq, K: Hash, K: Debug, V: Debug, S: BuildHasher {}
impl Debug for Headers {}
impl Debug for ChildStdin {}
impl Debug for UdpSocket {}
impl Debug for {unknown} {}
impl<T> Debug for IntoParIter<T> where T: Debug {}
impl<T> Debug for SendError<T> {}
impl<T> Debug for Path<T> where T: Debug {}
impl<T> Debug for SendError<T> {}
impl Debug for ParseWeekdayError {}
impl Debug for Path {}
impl<F> Debug for Execute<F> where {error}, F: Debug {}
impl Debug for Literal {}
impl<K, V> Debug for Iter<K, V> where K: Debug, V: Debug {}
impl Debug for Value {}
impl Debug for Stdin {}
impl<T, U> Debug for Framed<T, U> where T: Debug, U: Debug {}
impl Debug for OsRng {}
impl<T> Debug for *const T {}
impl Debug for SourceFile {}
impl Debug for SessionID {}
impl Debug for TcpStream {}
impl<O, T> Debug for OwningRef<O, T> where O: Debug, T: Debug {}
impl Debug for Never {}
impl Debug for ViolationFn {}
impl Debug for Char {}
impl<T, U> Debug for FramedWrite<T, U> where T: Debug, U: Debug {}
impl Debug for Sink {}
impl Debug for Utf8Lossy {}
impl<K, V> Debug for ParKeys<K, V> where K: Debug {}
impl Debug for CapturesDebug {}
impl Debug for Method {}
impl<Idx> Debug for RangeInclusive<Idx> where Idx: Debug {}
impl Debug for FrameTooBig {}
impl Debug for OsRng {}
impl Debug for IoSlice {}
impl<T> Debug for EcKey<T> {}
impl Debug for AtomicTask {}
impl<A> Debug for WeakAddressSender<A> where A: Actor {}
impl Debug for HeadersFlag {}
impl Debug for Parts {}
impl Debug for ChildStdout {}
impl Debug for Punct {}
impl<H> Debug for BuildHasherDefault<H> {}
impl<T> Debug for BinaryHeap<T> where T: Debug {}
impl Debug for Params {}
impl<T, S> Debug for IndexSet<T, S> where T: Debug, T: Hash, T: Eq, S: BuildHasher {}
impl<T> Debug for Receiver<T> {}
impl Debug for TcpListener {}
impl<K, V> Debug for IntoIter<K, V> where K: Debug, V: Debug {}
impl Debug for HandlePriv {}
impl<T> Debug for Frame<T> {}
impl<T> Debug for UnboundedSender<T> {}
impl Debug for DataFlags {}
impl<E> Debug for PollEvented<E> where E: Evented, E: Debug {}
impl Debug for YearFlags {}
impl Debug for Child {}
impl Debug for EncodingOverride {}
impl<K, V> Debug for IntoIter<K, V> where K: Debug, V: Debug {}
impl Debug for ClassUnicodeRange {}
impl<A, C> Debug for ContextFut<A, C> where C: AsyncContextParts<A>, A: Actor, <A as Actor>::Context = C {}
impl Debug for Error {}
impl<T> Debug for Drain<T> where T: Debug {}
impl Debug for Extensions {}
impl Debug for BsDebug {}
impl Debug for File {}
impl<I, F> Debug for FilterMap<I, F> where I: Debug {}
impl<T> Debug for LinkedList<T> where T: Debug {}
impl<T> Debug for Empty<T> {}
impl Debug for Condvar {}
impl Debug for ChildStderr {}
impl<T, U> Debug for Framed<T, U> where T: Debug, U: Debug {}
impl<T, P> Debug for SplitN<T, P> where T: Debug, P: FnMut<{unknown}> {}
impl<T> Debug for Iter<T> where T: Debug {}
impl<T> Debug for UnsafeCell<T> where T: Debug {}
impl<F> Debug for Shared<F> where {error}, F: Debug, {unknown}: Debug, {unknown}: Debug {}
impl Debug for Version {}
impl<T> Debug for IoConnection<T> where T: Debug {}
impl<F> Debug for CharPredicateSearcher<F> where F: FnMut<{unknown}> {}
impl Debug for State {}
impl<T> Debug for Array64<T> {}
impl<S> Debug for Execute<S> where {error} {}
impl<T> Debug for Tx<T> {}
impl<T> Debug for NonNull<T> {}
impl Debug for Pattern {}
impl Debug for {unknown} {}
impl Debug for Literal {}
impl Debug for Span {}
impl Debug for Stdout {}
impl<T, S> Debug for Difference<T, S> where T: Debug, T: Eq, T: Hash, S: BuildHasher {}
impl<K, V> Debug for OccupiedEntry<K, V> where {error}, K: Debug, {error}, V: Debug {}
impl Debug for char {}
impl Debug for VaListImpl {}
impl Debug for String {}
impl<K, V> Debug for Keys<K, V> where K: Debug {}
impl Debug for Scheme {}
impl<T> Debug for Sender<T> {}
impl<T> Debug for String<T> where T: AsRef<[u8]> {}
impl Debug for VarsOs {}
impl Debug for Ident {}
impl Debug for EscapeDefault {}
impl Debug for TcpListener {}
impl Debug for CString {}
impl<T> Debug for Receiver<T> {}
impl Debug for Pos {}
impl<T> Debug for Intersection<T> where T: Debug {}
impl<K, V> Debug for OccupiedEntry<K, V> where K: Debug, K: Ord, V: Debug {}
impl Debug for EnterError {}
impl Debug for OpaqueStreamRef {}
impl Debug for TransitionsRow {}
impl Debug for Output {}
impl<T> Debug for IterMut<T> where T: Debug {}
impl<T> Debug for SendError<T> {}
impl Debug for StatusCode {}
impl Debug for SemState {}
impl<T> Debug for RefMut<T> where T: Debug {}
impl<K, V> Debug for Entry<K, V> where K: Debug, V: Debug {}
impl Debug for Builder {}
impl<T> Debug for SendTimeoutError<T> {}
impl Debug for {unknown} {}
impl Debug for Authority {}
impl<T> Debug for RwLockReadGuard<T> where T: Debug {}
impl Debug for OsStr {}
impl Debug for Utf8Range {}
impl Debug for SystemTime {}
impl<C, P> Debug for NameServer<C, P> where C: DnsHandle, P: ConnectionProvider, <P as ConnectionProvider>::ConnHandle = C {}
impl Debug for NaiveDate {}
impl Debug for dyn Any {}
impl<T> Debug for BTreeSet<T> where T: Debug {}
impl Debug for VaListImpl {}
impl<T> Debug for Unique<T> {}
impl<T, E> Debug for SpawnHandle<T, E> where T: Debug, E: Debug {}
impl Debug for PushPromise {}
impl Debug for Context {}
impl<T> Debug for ParIter<T> where T: Debug {}
impl<P> Debug for CurrentThread<P> where P: Park {}
impl Debug for Encoding {}
impl<T> Debug for InternalError<T> where T: Debug, {error} {}
impl<T> Debug for TryIter<T> {}
impl Debug for Wtf8Buf {}
impl Debug for Duration {}
impl<T, E> Debug for SpawnHandle<T, E> where T: Debug, E: Debug {}
impl<M> Debug for NotifyError<M> {}
impl Debug for UnixReady {}
impl Debug for Builder {}
impl<T> Debug for TryLockError<T> {}
impl Debug for TcpStream {}
impl<T> Debug for IntoIter<T> where T: Debug {}
impl<A> Debug for Mailbox<A> where A: Actor, {unknown}: AsyncContext<A> {}
impl Debug for TokenStream {}
impl<T> Debug for Iter<T> where T: Debug {}
impl<S> Debug for NFA<S> where S: StateID {}
impl Debug for Inner {}
impl<T> Debug for ReentrantMutex<T> where T: Debug, {error} {}
impl<W> Debug for EncoderWriter<W> where W: Write {}
impl<P> Debug for MatchIndicesInternal<P> where P: Pattern, {unknown}: Debug {}
impl Debug for Command {}
impl<K, V> Debug for Iter<K, V> where K: Debug, V: Debug {}
impl<T> Debug for IterMut<T> where T: Debug {}
impl<T, F, S> Debug for ScopeGuard<T, F, S> where T: Debug, F: FnMut<{unknown}>, S: Strategy, S: Debug {}
impl Debug for () {}
impl<K, V> Debug for RawOccupiedEntryMut<K, V> where K: Debug, V: Debug {}
impl<U> Debug for Notify<U> {}
impl Debug for HttpRequest {}
impl Debug for ClientSessionImpl {}
impl<T, S> Debug for Chan<T, S> where S: Debug {}
impl Debug for TokenStream {}
impl<T, U> Debug for Connection<T, U> where U: Debug {}
impl Debug for Ptr {}
impl Debug for StdinLock {}
impl Debug for UdpSocket {}
impl<T, B> Debug for Connection<T, B> where T: AsyncRead, T: AsyncWrite, T: Debug, B: Debug, B: IntoBuf, {unknown}: Debug {}
impl Debug for HandlePriv {}
impl Debug for ! {}
impl<T> Debug for Arc<T> where T: Debug {}
impl Debug for Group {}
impl Debug for Once {}
impl Debug for MZODeflate {}
impl Debug for UdpSocket {}
impl Debug for Number {}
impl<T> Debug for Iter<T> where T: Debug {}
impl Debug for Run {}
impl Debug for Compiler {}
impl<Idx> Debug for Range<Idx> where Idx: Debug {}
impl Debug for BarrierWaitResult {}
impl<T> Debug for Response<T> where T: Debug {}
impl Debug for SockAddr {}
impl<T> Debug for ReuniteError<T> {}
impl<S> Debug for SslStream<S> where S: Debug {}
impl Debug for State {}
impl Debug for PushPromiseFlag {}
impl<T, S1, S2> Debug for SymmetricDifference<T, S1, S2> where T: Debug, T: Eq, T: Hash, S1: BuildHasher, S2: BuildHasher {}
impl Debug for Handle {}
impl Debug for ClassFrame {}
impl<T> Debug for [T] where T: Debug {}
impl<T> Debug for Cell<T> where T: Debug {}
impl Debug for Span {}
impl Debug for Label {}
impl Debug for Repr {}
impl Debug for AccessError {}
impl Debug for zx_guest_packet_t {}
impl<P> Debug for Request<P> {}
impl<T, P> Debug for SplitNMut<T, P> where T: Debug, P: FnMut<{unknown}> {}
impl Debug for Uri {}
impl Debug for HeaderValue {}
impl Debug for Repeat {}
impl<E, U> Debug for FramedTransportError<E, U> where U: Encoder, U: Decoder, E: Debug, <U as Encoder>::Error: Debug, <U as Decoder>::Error: Debug {}
impl Debug for Wtf8 {}
impl Debug for Error {}
impl Debug for DigestBytes {}
impl Debug for Instant {}
impl<T, F> Debug for Successors<T, F> where T: Debug {}
impl Debug for Map<String, Value> {}
impl Debug for EncodeUtf16 {}
impl<T> Debug for SyncSender<T> {}
impl<Idx> Debug for RangeToInclusive<Idx> where Idx: Debug {}
impl<T, B> Debug for FramedWrite<T, B> where B: IntoBuf, T: Debug, {unknown}: Debug {}
impl Debug for Events {}
impl<T, S> Debug for Union<T, S> where T: Debug, T: Eq, T: Hash, S: BuildHasher {}
impl Debug for MZOInflate {}
impl Debug for {unknown} {}
impl Debug for Literal {}
impl Debug for Drain {}
impl Debug for NotifyHandle {}
impl Debug for Display {}
impl<T> Debug for FuturesUnordered<T> where T: Debug {}
impl Debug for UnparkEvent {}
impl<Tz> Debug for Date<Tz> where Tz: TimeZone {}
impl<I, F> Debug for Inspect<I, F> where I: Debug {}
impl<T> Debug for Slab<T> where T: Debug {}
impl<P> Debug for MatchesInternal<P> where P: Pattern, {unknown}: Debug {}
impl<T, B> Debug for Connection<T, B> where T: Debug, B: Debug, B: IntoBuf, {unknown}: Debug {}
impl<U> Debug for Scheduler<U> {}
impl<T, P> Debug for Io<T, P> where T: Debug {}
impl<T> Debug for SendError<T> {}
impl Debug for Formatter {}
impl Debug for Condvar {}
impl Debug for Pong {}
impl<T, F> Debug for DrainFilter<T, F> where T: Debug, F: FnMut<{unknown}> {}
impl Debug for Once {}
impl<T, P> Debug for RSplitNMut<T, P> where T: Debug, P: FnMut<{unknown}> {}
impl<T, S1, S2> Debug for ParIntersection<T, S1, S2> where T: Debug, T: Eq, T: Hash, S1: BuildHasher, S2: BuildHasher {}
impl<A> Debug for ContextParts<A> where A: Actor, {unknown}: AsyncContext<A> {}
impl Debug for Captures {}
impl Debug for Hasher {}
impl Debug for Group {}
impl Debug for Captures {}
impl Debug for Arguments {}
impl<T, S> Debug for SymmetricDifference<T, S> where T: Debug, T: Eq, T: Hash, S: BuildHasher {}
impl Debug for UnixDatagram {}
impl<S> Debug for Execute<S> where {error} {}
impl<K, V> Debug for Values<K, V> where V: Debug {}
impl Debug for SocketAddrV6 {}
impl<T> Debug for IterMut<T> where T: Debug {}
impl<T> Debug for Level<T> {}
impl Debug for OsString {}
impl Debug for Body {}
impl Debug for Args {}
impl<T> Debug for Inner<T> where T: Debug {}
impl<K> Debug for IntoIter<K> where K: Debug {}
impl<T> Debug for TrySendError<T> {}
impl<T> Debug for FuturesOrdered<T> where T: Debug, {error} {}
impl<I, E> Debug for SpawnHandle<I, E> {}
impl<T> Debug for Rx<T> {}
impl Debug for Mask {}
impl<T> Debug for Discriminant<T> {}
impl<K, V> Debug for Range<K, V> where K: Debug, V: Debug {}
impl Debug for Parts {}
impl<B> Debug for Response<B> where B: MessageBody {}
impl Debug for HeaderName {}
impl<T, D> Debug for FramedRead<T, D> where T: Debug, D: Debug {}
impl<T> Debug for UnboundedReceiver<T> {}
impl<K, V> Debug for Entry<K, V> where {error}, K: Debug, {error}, V: Debug {}
impl Debug for Semaphore {}
impl<K, V> Debug for Values<K, V> where V: Debug {}
impl Debug for Settings {}
impl<B> Debug for SendRequest<B> where B: IntoBuf {}
impl Debug for Extensions {}
impl Debug for ParseBuffer {}
impl Debug for PingPong {}
impl Debug for Builder {}
impl<T, S1, S2> Debug for ParDifference<T, S1, S2> where T: Debug, T: Eq, T: Hash, S1: BuildHasher, S2: BuildHasher {}
impl Debug for Thread {}
impl<T> Debug for ThreadBound<T> where T: Debug {}
impl<T> Debug for Drain<T> where T: Debug {}
impl Debug for Task {}
impl<I, E> Debug for MapDeserializer<I, E> where I: Iterator, I: Debug, {unknown}: Pair, <{unknown} as Pair>::Second: Debug {}
impl<T> Debug for Json<T> where T: Debug {}
impl<T, U> Debug for FramedWrite<T, U> where T: Debug, U: Debug {}
impl Debug for SocketAddr {}
impl Debug for Reason {}
impl Debug for CStr {}
impl<T> Debug for Iter<T> where T: Debug {}
impl Debug for Select {}
impl<T> Debug for Iter<T> where T: Debug {}
impl<K, V> Debug for Entry<K, V> where K: Debug, K: Ord, V: Debug {}
impl<T> Debug for AssertUnwindSafe<T> where T: Debug {}
impl<T> Debug for ThreadLocal<T> where T: Send, T: Debug {}
impl<T> Debug for Port<T> where T: Debug {}
impl<T> Debug for Iter<T> where T: Debug {}
impl<S> Debug for BufferUnordered<S> where S: Stream, S: Debug, {error}, {unknown}: Debug {}
impl Debug for RareByteOffsets {}
impl<K, V> Debug for VacantEntry<K, V> where K: Debug {}
impl Debug for Infallible {}
impl Debug for Key {}
impl Debug for IntoIter {}
impl Debug for Overlapped {}
impl Debug for Buf {}
impl Debug for ScalarRange {}
impl<T, U> Debug for Framed<T, U> where T: Debug, U: Debug {}
impl Debug for StdoutLock {}
impl<T> Debug for IterMut<T> where {error}, T: Debug {}
impl<I, P> Debug for SkipWhile<I, P> where I: Debug {}
impl Debug for ParseOptions {}
impl<T, P> Debug for Split<T, P> where T: Debug, P: FnMut<{unknown}> {}
impl Debug for dyn Any + Send + Sync {}
impl<P> Debug for Pin<P> where P: Debug {}
impl Debug for c_void {}
impl<T> Debug for Rsa<T> {}
impl<T> Debug for TrySendError<T> {}
impl<T> Debug for Data<T> {}
impl Debug for TokenTree {}
impl<K, V> Debug for IntoIter<K, V> where K: Debug, V: Debug {}
impl<T> Debug for Weak<T> where T: Debug {}
impl<T> Debug for MutexGuard<T> where T: Debug {}
impl<T> Debug for Receiver<T> {}
impl Debug for Socket {}
impl Debug for ResponseBuilder {}
impl<T, E> Debug for SendError<T, E> {}
impl<T> Debug for SymmetricDifference<T> where T: Debug {}
impl<K, V> Debug for VacantEntry<K, V> where K: Debug, K: Ord {}
impl Debug for UnixStream {}
impl Debug for Url {}
impl Debug for NaiveDateTime {}
impl<T> Debug for Cell<T> where T: Copy, T: Debug {}
impl<K, V, S> Debug for RawEntryBuilder<K, V, S> {}
impl<T, S> Debug for Tx<T, S> where S: Semaphore, {unknown}: Debug, S: Debug {}
impl Debug for RecvStream {}
impl Debug for TcpListener {}
impl<K, V> Debug for Drain<K, V> where K: Debug, V: Debug {}
impl Debug for Components {}
impl<T> Debug for SilentDebug<T> {}
impl Debug for ByteClasses {}
impl Debug for SourceFile {}
impl<I, U, F> Debug for FlatMap<I, U, F> where I: Debug, U: IntoIterator, {unknown}: Debug {}
impl<B> Debug for ServiceResponse<B> where B: MessageBody {}
impl<T, B> Debug for Handshake<T, B> where T: AsyncRead, T: AsyncWrite, T: Debug, B: Debug, B: IntoBuf, {unknown}: Debug, {unknown}: IntoBuf {}
impl Debug for Url {}
impl<T, F, S> Debug for ScopeGuard<T, F, S> where T: Debug, F: FnOnce<{unknown}>, S: Strategy {}
impl<T, P> Debug for Punctuated<T, P> where T: Debug, P: Debug {}
impl Debug for bool {}
impl<K, V> Debug for Iter<K, V> where K: Debug, V: Debug {}
impl Debug for Handle {}
impl<T> Debug for Spawn<T> where T: Debug {}
impl Debug for PathAndQuery {}
impl Debug for SplitPaths {}
impl<T, S> Debug for ArcSwapAny<T, S> where S: LockStorage, T: Debug, T: RefCnt {}
impl Debug for CapturesDebug {}
impl<K, V, S> Debug for IndexMap<K, V, S> where K: Debug, K: Hash, K: Eq, V: Debug, S: BuildHasher {}
impl<Idx> Debug for RangeFrom<Idx> where Idx: Debug {}
impl Debug for Barrier {}
impl Debug for {unknown} {}
impl<T, S1, S2> Debug for ParUnion<T, S1, S2> where T: Debug, T: Eq, T: Hash, S1: BuildHasher, S2: BuildHasher {}
impl Debug for Value {}
impl Debug for UnixListener {}
impl<T> Debug for PhantomData<T> {}
impl<K, V, S> Debug for RawEntryMut<K, V, S> where K: Debug, V: Debug {}
impl Debug for PollOpt {}
impl Debug for RegexSet {}
impl<T> Debug for RxFields<T> {}
impl<R> Debug for BufReader<R> where R: Debug {}
impl Debug for InternalNumeric {}
impl Debug for Span {}
impl Debug for Empty {}
impl<A> Debug for Context<A> where A: Actor, <A as Actor>::Context = Context<A> {}
impl Debug for Bytes {}
impl<T> Debug for Form<T> where T: Debug {}
impl<T> Debug for Weak<T> where T: Debug {}
impl<T> Debug for Guard<T> where T: Debug, T: RefCnt {}
impl Debug for Regex {}
impl Debug for Mime {}
impl<T> Debug for AtomicPtr<T> {}
impl Debug for ServiceRequest {}
impl Debug for Selector {}
impl Debug for IoSliceMut {}
impl Debug for StderrLock {}
impl Debug for BoxStd {}
impl Debug for {unknown} {}
impl Debug for Slot {}
impl<T, D> Debug for FramedRead<T, D> where T: Debug, D: Debug {}
impl<T, S> Debug for HashSet<T, S> where T: Eq, T: Hash, T: Debug, S: BuildHasher {}
impl<T, S> Debug for Difference<T, S> where T: Debug, T: Eq, T: Hash, S: BuildHasher {}
impl<T> Debug for Key<T> {}
impl<T, S1, S2> Debug for ParSymmetricDifference<T, S1, S2> where T: Debug, T: Eq, T: Hash, S1: BuildHasher, S2: BuildHasher {}
impl<T, B> Debug for Framed<T, B> where B: IntoBuf, T: Debug, {unknown}: Debug {}
impl<K, V, S> Debug for LruCache<K, V, S> where K: Debug, K: Eq, K: Hash, V: Debug, S: BuildHasher {}
impl Debug for BsDebug {}
impl Debug for Ready {}
impl<F> Debug for Execute<F> where {error}, F: Debug {}
impl<T> Debug for IntoIter<T> where T: Debug {}
impl<O, T> Debug for OwningRefMut<O, T> where O: Debug, T: Debug {}
impl<K> Debug for Iter<K> where K: Debug {}
impl Debug for Mdf {}
impl<T, P> Debug for RSplitN<T, P> where T: Debug, P: FnMut<{unknown}> {}
impl Debug for SetReadiness {}
impl Debug for Codec {}
impl<R> Debug for BufReader<R> where R: Debug {}
impl Debug for SourceFile {}
impl Debug for Inner {}
impl Debug for AtomicBool {}
impl<K, V> Debug for Keys<K, V> where K: Debug {}
impl<T> Debug for VecDeque<T> where T: Debug {}
impl Debug for Error {}
impl<A> Debug for AddressSender<A> where A: Actor {}
impl Debug for Stderr {}
impl Debug for Waker {}
impl<I, E> Debug for SpawnHandle<I, E> {}
impl Debug for SocketAddrV4 {}
impl Debug for Poll {}
impl Debug for ClassBytesRange {}
impl Debug for Certificate {}
impl<T> Debug for PeekMut<T> where T: Ord, T: Debug {}
impl<S> Debug for Buffered<S> where S: Stream, S: Debug, {error}, {unknown}: Debug, {unknown}: Debug, {unknown}: Debug {}
impl<T> Debug for PoisonError<T> {}
impl Debug for DirEntry {}
impl<I, P> Debug for Filter<I, P> where I: Debug {}
impl Debug for Socket {}
impl<T, U> Debug for FramedWrite<T, U> where T: Debug, U: Debug {}
impl<K, V> Debug for Keys<K, V> where K: Debug {}
impl Debug for TokenStream {}
impl<T> Debug for Iter<T> where {error}, T: Debug {}
impl Debug for RegValue {}
impl<T, S> Debug for Intersection<T, S> where T: Debug, T: Eq, T: Hash, S: BuildHasher {}
impl<T> Debug for Key<T> {}
impl Debug for Reactor {}
impl Debug for Task {}
impl Debug for UdpSocket {}
impl Debug for Error {}
impl Debug for Error {}
impl Debug for Ping {}
impl<B> Debug for Cow<B> where B: Debug, B: ToOwned, <B as ToOwned>::Owned: Debug {}
impl Debug for TcpStream {}
impl<T> Debug for Mutex<T> where T: Debug {}
impl Debug for Filter {}
impl Debug for Literal {}
impl<T> Debug for Sender<T> {}
impl Debug for SelectedOperation {}
impl<A, I, E> Debug for ActorResponse<A, I, E> {}
impl Debug for Enter {}
impl Debug for BorrowMutError {}
impl<T> Debug for TrySendError<T> {}
impl<E> Debug for InOrderError<E> where E: Debug {}
impl<T> Debug for Request<T> where T: Debug {}
impl<A, B, S> Debug for LinkedHashMap<A, B, S> where A: Debug, A: Hash, A: Eq, B: Debug, S: BuildHasher {}
impl Debug for Isaac64Core {}
impl<T, S> Debug for Intersection<T, S> where T: Debug, T: Eq, T: Hash, S: BuildHasher {}
impl Debug for Ident {}
impl Debug for Name {}
impl Debug for Slice {}
impl<T> Debug for SyncFailure<T> where T: Debug {}
impl Debug for TcpStream {}
impl<K, V> Debug for Values<K, V> where V: Debug {}
impl Debug for KeyValues {}
impl Debug for ThreadPool {}
impl<I, U> Debug for Flatten<I> where I: Iterator, I: Debug, U: Iterator, U: Debug, {unknown}: IntoIterator, <{unknown} as IntoIterator>::IntoIter = U, <{unknown} as IntoIterator>::Item = {unknown} {}
impl Debug for Regex {}
impl<K, V> Debug for ParValues<K, V> where V: Debug {}
impl Debug for AsyncResolver {}
impl<T, P> Debug for SplitMut<T, P> where T: Debug, P: FnMut<{unknown}> {}
impl<T> Debug for SendError<T> {}
impl<T, D> Debug for FramedRead<T, D> where T: Debug, D: Debug {}
impl Debug for Of {}
impl Debug for Writer {}
impl<T> Debug for JoinHandle<T> {}
impl Debug for InternalBacktrace {}
impl Debug for CodePoint {}
impl<K, V> Debug for IntoParIter<K, V> where K: Debug, V: Debug {}
impl Debug for BytesMut {}
impl Debug for Hex {}
impl<T> Debug for SendError<T> {}
impl<T> Debug for Union<T> where T: Debug {}
impl<I, E> Debug for Response<I, E> {}
impl<K, V> Debug for RangeMut<K, V> where K: Debug, V: Debug {}
impl<B> Debug for Prioritized<B> where B: Buf {}
impl Debug for FixedOffset {}
impl<P> Debug for SplitInternal<P> where P: Pattern, {unknown}: Debug {}
impl Debug for StateFlags {}
impl<T> Debug for IntoIter<T> where T: Debug {}
impl Debug for Logger {}
impl<T, P> Debug for RSplitMut<T, P> where T: Debug, P: FnMut<{unknown}> {}
impl<T> Debug for RwLockWriteGuard<T> where T: Debug {}
impl<T> Debug for Ref<T> where T: Debug {}
impl<K, V> Debug for OccupiedEntry<K, V> where K: Debug, V: Debug {}
impl<T> Debug for HeaderMap<T> where T: Debug {}
impl Debug for Events {}
impl<T> Debug for Cell<T> where T: Debug {}
impl<K> Debug for Drain<K> where K: Debug {}
impl<W> Debug for LineWriter<W> where W: Write, W: Debug {}
impl Debug for Group {}
impl Debug for TcpListener {}
impl Debug for RegexSet {}
impl Debug for Ident {}
impl Debug for Span {}
impl<I, St, F> Debug for Scan<I, St, F> where I: Debug, St: Debug {}
impl<F> Debug for FromFn<F> {}
impl Debug for Ipv6Addr {}
impl<T> Debug for Drain<T> where {error} {}
impl Debug for UdpSocket {}
impl Debug for TokenTreeIter {}
impl<K, V> Debug for VacantEntry<K, V> where {error}, K: Debug, {error} {}
impl Debug for dyn Any + Send {}
impl<T> Debug for IntoIter<T> where T: Debug {}
impl Debug for {unknown} {}
impl<T, U> Debug for Chain<T, U> where T: Debug, U: Debug {}
impl Debug for ULiteral {}
impl Debug for SettingsFlags {}
impl<M> Debug for Sender<M> {}
impl<I, F> Debug for Map<I, F> where I: Debug {}
impl Debug for MailboxError {}
impl Debug for TcpStream {}
impl Debug for ArbiterCommand {}
impl<K, V> Debug for ParIter<K, V> where K: Debug, V: Debug {}
impl<T> Debug for IntoIter<T> {}
impl Debug for Vars {}
impl Debug for RawValue {}
impl<Idx> Debug for RangeTo<Idx> where Idx: Debug {}
impl<T> Debug for Difference<T> where T: Debug {}
impl<T> Debug for Vec<T> where T: Debug {}
impl Debug for {unknown} {}
impl Debug for BorrowError {}
impl<T, S> Debug for Union<T, S> where T: Debug, T: Eq, T: Hash, S: BuildHasher {}
impl<T, B> Debug for Handshake<T, B> where T: AsyncRead, T: AsyncWrite, T: Debug, B: Debug, B: IntoBuf {}
impl Debug for Events {}
impl Debug for Socket {}
impl<T> Debug for RefCell<T> where T: Debug {}
impl<K, V, S> Debug for RawVacantEntryMut<K, V, S> {}
impl Debug for LexError {}
impl Debug for TcpBuilder {}
impl Debug for PathBuf {}
impl<T> Debug for Key<T> {}
impl Debug for TcpListener {}
impl<T, S> Debug for Rx<T, S> where S: Semaphore, S: Debug {}
impl Debug for Binding {}
impl Debug for IsoWeek {}
impl<T> Debug for Sender<T> {}
impl Debug for Position {}
impl Debug for Utf8Sequence {}
impl<T> Debug for CachedThreadLocal<T> where T: Send, T: Debug {}
impl<T> Debug for ReuniteError<T> {}
impl Debug for Metadata {}
impl<T> Debug for Dsa<T> {}
impl<I, P> Debug for TakeWhile<I, P> where I: Debug {}
impl Debug for NaiveTime {}
trait IoStream {}
impl<T> IoStream for TlsStream<T, ServerSession> where T: IoStream {}
impl<T> IoStream for Io<T> where T: IoStream {}
impl<T> IoStream for SslStream<T> where T: IoStream {}
impl IoStream for UnixStream {}
impl IoStream for TestBuffer {}
impl IoStream for TcpStream {}
trait AsyncWrite {}
impl AsyncWrite for &UnixStream {}
impl AsyncWrite for UnixStream {}
impl<S> AsyncWrite for SslStream<S> where S: AsyncRead, S: AsyncWrite {}
impl AsyncWrite for TcpStream {}
impl<T> AsyncWrite for Io<T> where T: AsyncWrite {}
impl AsyncWrite for Cursor<Vec<u8>> {}
impl<T> AsyncWrite for Box<T> where T: AsyncWrite {}
impl AsyncWrite for Sink {}
impl<T> AsyncWrite for BufWriter<T> where T: AsyncWrite {}
impl<E> AsyncWrite for &PollEvented<E> where E: Evented, &E: Write {}
impl AsyncWrite for &TcpStream {}
impl<IO, S> AsyncWrite for TlsStream<IO, S> where IO: AsyncRead, IO: AsyncWrite, S: Session {}
impl AsyncWrite for Cursor<&mut [u8]> {}
impl<E> AsyncWrite for PollEvented<E> where E: Evented, E: Write {}
impl<S> AsyncWrite for TlsStream<S> where S: AsyncRead, S: AsyncWrite {}
impl<T, U> AsyncWrite for Fuse<T, U> where T: AsyncWrite {}
impl AsyncWrite for TestBuffer {}
impl<T> AsyncWrite for H1Connection<T> where T: AsyncRead, T: AsyncWrite, {error} {}
impl<A, B> AsyncWrite for EitherIo<A, B> where A: AsyncWrite, B: AsyncWrite {}
impl AsyncWrite for Cursor<Box<[u8]>> {}
impl<T> AsyncWrite for &mut T where T: AsyncWrite {}
struct ExpectHandler;
struct UnitConfig<A, C>;
struct UpgradeHandler<T>;
struct AppInit<T, B>;
struct MapConfig<A, F, C>;
struct ServiceFactory<T>;
trait AsyncRead {}
impl<T> AsyncRead for FramedWrite2<T> where T: AsyncRead {}
impl<T> AsyncRead for &mut T where T: AsyncRead {}
impl AsyncRead for TcpStream {}
impl<T, B> AsyncRead for FramedWrite<T, B> where T: AsyncRead {}
impl<A, B> AsyncRead for EitherIo<A, B> where A: AsyncRead, B: AsyncRead {}
impl<IO, S> AsyncRead for TlsStream<IO, S> where IO: AsyncRead, IO: AsyncWrite, S: Session {}
impl AsyncRead for &UnixStream {}
impl<S> AsyncRead for TlsStream<S> where S: AsyncRead, S: AsyncWrite {}
impl<S> AsyncRead for SslStream<S> where S: AsyncRead, S: AsyncWrite {}
impl AsyncRead for &TcpStream {}
impl<T> AsyncRead for Box<T> where T: AsyncRead {}
impl<T> AsyncRead for Io<T> where T: AsyncRead {}
impl<E> AsyncRead for &PollEvented<E> where E: Evented, &E: Read {}
impl AsyncRead for UnixStream {}
impl<T, U> AsyncRead for Fuse<T, U> where T: AsyncRead {}
impl AsyncRead for &[u8] {}
impl AsyncRead for TestBuffer {}
impl<T> AsyncRead for H1Connection<T> where T: AsyncRead, T: AsyncWrite, {error} {}
impl<E> AsyncRead for PollEvented<E> where E: Evented, E: Read {}
trait IntoFuture {
type Future;
type Item;
type Error;
}
impl<F> IntoFuture for F where F: Future {
type Future = F;
type Item = {unknown};
type Error = {unknown};
}
impl IntoFuture for ResponseBuilder {
type Item = Response<Body>;
type Error = Error;
type Future = FutureResult<Response<Body>, Error>;
}
impl<B> IntoFuture for ServiceResponse<B> {
type Item = ServiceResponse<B>;
type Error = Error;
type Future = FutureResult<ServiceResponse<B>, Error>;
}
impl<T, E> IntoFuture for {unknown} {
type Future = FutureResult<T, E>;
type Item = T;
type Error = E;
}
impl IntoFuture for Response<Body> {
type Item = Response<Body>;
type Error = Error;
type Future = FutureResult<Response<Body>, Error>;
}
trait Display {}
impl Display for FormatDisplay {}
impl Display for {unknown} {}
impl Display for Error {}
impl Display for Number {}
impl Display for VarError {}
impl Display for ParseLevelError {}
impl<T> Display for ReuniteError<T> {}
impl Display for UserError {}
impl Display for Encoding {}
impl Display for Duration {}
impl Display for ErrorStack {}
impl Display for Never {}
impl Display for Uri {}
impl Display for Error {}
impl Display for SslErrorStack {}
impl Display for FormattedDuration {}
impl Display for Ident {}
impl Display for Filter {}
impl Display for BoxStd {}
impl Display for SocketAddr {}
impl Display for ToStrError {}
impl Display for ParseError {}
impl<C> Display for NulError<C> where C: UChar {}
impl Display for RecvError {}
impl<E> Display for SharedError<E> where E: Display {}
impl<T> Display for SendError<T> {}
impl Display for CannotReallocInPlace {}
impl<T> Display for BlockError<T> {}
impl Display for Error {}
impl Display for Level {}
impl<E> Display for PercentEncode<E> where E: EncodeSet {}
impl Display for Group {}
impl Display for IfRange {}
impl Display for Error {}
impl Display for TryRecvError {}
impl Display for SocketAddrV6 {}
impl Display for CompressError {}
impl<C> Display for MissingNulError<C> where C: UChar {}
impl Display for Literal {}
impl<T> Display for TrySendError<T> {}
impl Display for ReadError {}
impl Display for DispositionParam {}
impl Display for MSVCTarget {}
impl Display for RecvError {}
impl Display for AcquireError {}
impl Display for char {}
impl<T> Display for ThrottleError<T> where T: Error {}
impl Display for ParseIntError {}
impl<B> Display for Cow<B> where B: Display, B: ToOwned, <B as ToOwned>::Owned: Display {}
impl<T> Display for String<T> where T: AsRef<[u8]> {}
impl<T> Display for Json<T> where T: Display {}
impl Display for SocketAddr {}
impl Display for NaiveDate {}
impl Display for Duration {}
impl Display for ParseError {}
impl<T> Display for Port<T> {}
impl Display for BorrowMutError {}
impl Display for StatusCode {}
impl Display for FromUtf8Error {}
impl Display for Infallible {}
impl Display for Key {}
impl Display for CaseMappingIter {}
impl Display for Name {}
impl Display for Slice {}
impl<T> Display for SyncFailure<T> where T: Display {}
impl Display for Error {}
impl Display for Regex {}
impl Display for Predicate {}
impl<T> Display for SendError<T> {}
impl<S> Display for TcpClientStream<S> where S: AsyncRead, S: AsyncWrite, S: Send {}
impl Display for Error {}
impl<S> Display for HostAndPort<S> where S: AsRef<str> {}
impl Display for ParseColorError {}
impl Display for ParseError {}
impl Display for Lifetime {}
impl Display for Error {}
impl Display for DecompressError {}
impl Display for Window {}
impl Display for Reason {}
impl<T> Display for RefMut<T> where T: Display {}
impl Display for Base64Display {}
impl Display for CacheControl {}
impl Display for Algorithm {}
impl<I> Display for Decompositions<I> where I: Iterator, <I as Iterator>::Item = char, I: Clone {}
impl<I> Display for DelayedFormat<I> where I: Iterator, <I as Iterator>::Item = Item, I: Clone {}
impl Display for InvalidUriBytes {}
impl Display for Ident {}
impl Display for Error {}
impl Display for {unknown} {}
impl Display for SendError {}
impl Display for ! {}
impl Display for TrySelectError {}
impl Display for InvalidHeaderNameBytes {}
impl Display for ParseBoolError {}
impl Display for RecvTimeoutError {}
impl Display for Network {}
impl Display for PathAndQuery {}
impl Display for Literal {}
impl<W> Display for IntoInnerError<W> {}
impl Display for Location {}
impl Display for SetLoggerError {}
impl Display for OneOf {}
impl<MF> Display for UdpClientStream<MF> where MF: MessageFinalizer {}
impl<T> Display for SendError<T> {}
impl Display for Value {}
impl Display for Error {}
impl Display for Label {}
impl Display for Charset {}
impl Display for AccessError {}
impl Display for ParseError {}
impl Display for Error {}
impl Display for SemVerError {}
impl Display for ErrorKind {}
impl Display for Wtf8 {}
impl Display for Error {}
impl<E> Display for Formatter<E> where E: Display {}
impl<T> Display for Form<T> where T: Display {}
impl Display for Regex {}
impl Display for IntoStringError {}
impl Display for Error {}
impl<T> Display for UnboundedTrySendError<T> where T: Debug {}
impl Display for {unknown} {}
impl Display for ParseError {}
impl Display for InvalidHeaderValueBytes {}
impl<T> Display for InternalError<T> where T: Display, {error} {}
impl Display for Error {}
impl Display for HttpDate {}
impl Display for SyntaxViolation {}
impl<T> Display for Wrapping<T> where T: Display {}
impl Display for Error {}
impl Display for RecvError {}
impl Display for Cookie {}
impl<T> Display for Rc<T> where T: Display {}
impl<E> Display for TimeoutError<E> where E: Display {}
impl Display for EncoderError {}
impl Display for OutOfRangeError {}
impl Display for EscapeUnicode {}
impl Display for TurnError {}
impl Display for ParseCharError {}
impl Display for {unknown} {}
impl Display for ReqParseError {}
impl<T> Display for QualityItem<T> where T: Display {}
impl Display for FromBytesWithNulError {}
impl Display for ProtoError {}
impl Display for Arguments {}
impl<T> Display for Arc<T> where T: Display {}
impl Display for Error {}
impl Display for FixedOffset {}
impl Display for InvalidHeaderName {}
impl Display for SocketAddrV4 {}
impl<T> Display for Path<T> where T: Display {}
impl<T> Display for SendError<T> {}
impl<T> Display for TrySendError<T> where T: Debug {}
impl Display for JoinPathsError {}
impl<T> Display for Ref<T> where T: Display {}
impl Display for Ast {}
impl Display for TimerError {}
impl Display for IpAddr {}
impl<T> Display for Error<T> where T: Display {}
impl Display for Error {}
impl Display for StripPrefixError {}
impl Display for {unknown} {}
impl Display for VersionReq {}
impl Display for UnboundedSendError {}
impl Display for ParseBuffer {}
impl Display for Identifier {}
impl Display for AddrParseError {}
impl Display for Identifier {}
impl Display for CharTryFromError {}
impl Display for ResponseCode {}
impl Display for Rfc3339Timestamp {}
impl Display for NulError {}
impl Display for Method {}
impl Display for FrameTooBig {}
impl Display for Unexpected {}
impl Display for Error {}
impl Display for BorrowError {}
impl Display for RunError {}
impl<T> Display for Query<T> where T: Display {}
impl Display for ParseFloatError {}
impl Display for RecvError {}
impl Display for B {}
impl Display for ToUppercase {}
impl Display for Ident {}
impl<Tz> Display for Date<Tz> where Tz: TimeZone, {unknown}: Display {}
impl Display for DispositionType {}
impl Display for FromUtf32Error {}
impl Display for TryFromSliceError {}
impl Display for LanguageTag {}
impl Display for SendError {}
impl Display for Error {}
impl Display for Utc {}
impl Display for Error {}
impl Display for dyn Expected + {error} {}
impl Display for Url {}
impl<T> Display for RwLockWriteGuard<T> where T: Display {}
impl Display for FromUtf16Error {}
impl Display for SameSite {}
impl Display for ContentRangeSpec {}
impl Display for EscapeDebug {}
impl Display for ErrorKind {}
impl Display for RecvError {}
impl Display for {unknown} {}
impl Display for Ipv6Addr {}
impl Display for Op {}
impl Display for Error {}
impl Display for DecoderError {}
impl Display for UnboundedRecvError {}
impl Display for bool {}
impl Display for ResolveError {}
impl Display for SelectTimeoutError {}
impl Display for Utf8Error {}
impl Display for Version {}
impl<T> Display for SendError<T> {}
impl Display for RecordType {}
impl Display for PanicInfo {}
impl Display for RawValue {}
impl Display for TokenStream {}
impl Display for EncodedCookie {}
impl Display for TLSError {}
impl Display for InvalidStatusCode {}
impl Display for InvalidChunkSize {}
impl<T> Display for ReuniteError<T> {}
impl Display for Mime {}
impl Display for ErrorCode {}
impl<S> Display for Ascii<S> where S: Display {}
impl Display for InvalidMethod {}
impl Display for NaiveTime {}
impl Display for Punct {}
impl Display for RecvError {}
impl Display for AddrParseError {}
impl<M> Display for NotifyError<M> {}
impl<T> Display for TryLockError<T> {}
impl<T> Display for SendError<T> where T: Debug {}
impl Display for Ipv4Addr {}
impl Display for TmFmt {}
impl<S> Display for UniCase<S> where S: Display {}
impl Display for TryAcquireError {}
impl<T> Display for TrySendError<T> {}
impl Display for TokenStream {}
impl<L, R> Display for Either<L, R> where L: Display, R: Display {}
impl Display for RunTimeoutError {}
impl Display for X509VerifyResult {}
impl Display for Hir {}
impl Display for Literal {}
impl Display for ErrorImpl {}
impl Display for Error {}
impl Display for Config {}
impl Display for RecvTimeoutError {}
impl Display for Group {}
impl<T> Display for Connect<T> where T: Address {}
impl<T> Display for PoisonError<T> {}
impl Display for SteadyTime {}
impl Display for TimerErrorKind {}
impl Display for Type {}
impl Display for Error {}
impl<E, U> Display for FramedTransportError<E, U> where U: Encoder, U: Decoder, E: Display, <U as Encoder>::Error: Debug, <U as Decoder>::Error: Debug {}
impl Display for Utf8Lossy {}
impl<T> Display for LockGuard<T> where T: Display {}
impl<T> Display for Guard<T> where T: Debug, T: RefCnt {}
impl Display for ParseError {}
impl Display for DecodeUtf16Error {}
impl Display for Canceled {}
impl Display for Authority {}
impl<T> Display for SendError<T> {}
impl Display for ContentDisposition {}
impl Display for LevelFilter {}
impl Display for Value {}
impl Display for Unsupported {}
impl Display for {unknown} {}
impl Display for Display {}
impl Display for EntityTag {}
impl Display for AllocErr {}
impl Display for EscapeDefault {}
impl Display for Error {}
impl Display for Error {}
impl Display for ScopedIp {}
impl Display for Version {}
impl<S> Display for HandshakeError<S> where S: Debug {}
impl Display for DecodeError {}
impl Display for Unspecified {}
impl Display for OutOfRangeError {}
impl<I> Display for Recompositions<I> where I: Iterator, <I as Iterator>::Item = char, I: Clone {}
impl Display for A {}
impl Display for ToLowercase {}
impl Display for PercentEncode {}
impl<T> Display for DeadlineError<T> where T: Display {}
impl Display for Error {}
impl Display for TryRecvError {}
impl Display for DNSClass {}
impl Display for HeaderName {}
impl Display for Duration {}
impl Display for ExitStatus {}
impl Display for {unknown} {}
impl Display for String {}
impl Display for LayoutErr {}
impl Display for Scheme {}
impl Display for Error {}
impl Display for InvalidUriParts {}
impl Display for StdListener {}
impl<T, S> Display for ArcSwapAny<T, S> where S: LockStorage, T: Display, T: RefCnt {}
impl Display for OpCode {}
impl<S> Display for Host<S> where S: AsRef<str> {}
impl Display for EnterError {}
impl Display for Timestamp {}
impl<T> Display for TrySendError<T> {}
impl<E> Display for InOrderError<E> where E: Display {}
impl Display for SpawnError {}
impl<T> Display for SendTimeoutError<T> {}
impl Display for TryFromIntError {}
impl<T> Display for RwLockReadGuard<T> where T: Display {}
impl Display for Buf {}
impl Display for SystemTimeError {}
impl Display for SetFallbackError {}
impl<T> Display for TrySendError<T> {}
impl Display for MdnsClientStream {}
impl<P> Display for Pin<P> where P: Display {}
impl Display for TokenTree {}
impl<S, MF> Display for DnsMultiplexer<S, MF, Box<{unknown}>> where S: DnsClientStream, {error}, MF: MessageFinalizer, MF: Send, MF: Sync, {error} {}
impl<S> Display for Host<S> where S: AsRef<str> {}
impl Display for TryRecvError {}
impl Display for SyntaxViolation {}
impl Display for Error {}
impl<T> Display for MutexGuard<T> where T: Display {}
impl Display for TokenStream {}
impl Display for FromStrError {}
impl<T, E> Display for SendError<T, E> {}
impl<Tz> Display for DateTime<Tz> where Tz: TimeZone, {unknown}: Display {}
impl Display for CacheDirective {}
impl Display for NaiveDateTime {}
impl Display for Name {}
impl Display for KeyRejected {}
impl Display for RunError {}
impl Display for InvalidUri {}
impl Display for InvalidHeaderValue {}
impl Display for Group {}
impl Display for SupportedAlgorithms {}
impl Display for ExtendedValue {}
impl Display for Url {}
impl Display for Error {}
impl Display for Query {}
trait From<T> {}
impl From<DateTime<FixedOffset>> for DateTime<Local> {}
impl From<{unknown}> for Socket {}
impl From<PathAndQuery> for Bytes {}
impl<T> From<T> for CachePadded<T> {}
impl From<RecordType> for &str {}
impl From<CString> for Cow<CStr> {}
impl From<(EdnsCode, &[u8])> for EdnsOption {}
impl From<&mut [u8]> for &mut IoVec {}
impl<I> From<(I, u16)> for SocketAddr where I: Into<IpAddr> {}
impl From<Map<String, Value>> for Value {}
impl From<&str> for Key {}
impl<W> From<x4<W>> for vec512_storage where W: Copy, vec128_storage: From<W> {}
impl From<i16> for Value {}
impl<T> From<&mut T> for NonNull<T> {}
impl From<&UStr<u16>> for Cow<UStr<u16>> {}
impl<T> From<SendError<T>> for SendError<T> {}
impl<T> From<Data<T>> for Frame<T> {}
impl From<DateTime<FixedOffset>> for DateTime<Utc> {}
impl<T, B> From<ReadPreface<T, Prioritized<{unknown}>>> for Handshaking<T, B> where T: AsyncRead, T: AsyncWrite, B: IntoBuf {}
impl From<Socket> for UdpSocket {}
impl From<Socket> for TcpListener {}
impl From<Nsec3HashAlgorithm> for u8 {}
impl From<{unknown}> for Ident {}
impl From<KeyRejected> for Unspecified {}
impl From<Box<CStr>> for CString {}
impl From<&EdnsOption> for Vec<u8> {}
impl From<Error> for SendError {}
impl<B> From<Response<B>> for ResponseBuilder {}
impl<T> From<Continuable> for Frame<T> {}
impl From<Box<OsStr>> for OsString {}
impl From<&PathBuf> for Cow<Path> {}
impl From<{unknown}> for StreamId {}
impl From<Identifier> for Identifier {}
impl From<&{unknown}> for ByteStr {}
impl From<Option<usize>> for KeepAlive {}
impl<A> From<Vec<{unknown}>> for SmallVec<A> where A: Array {}
impl From<UString<u16>> for OsString {}
impl From<CloseCode> for CloseReason {}
impl From<ZeroMeansSuccess> for Result<(), Unspecified> {}
impl<T> From<SendError<T>> for TrySendError<T> {}
impl From<Error> for ProtoError {}
impl From<Error> for ResolveError {}
impl From<Socket> for TcpListener {}
impl From<{unknown}> for TokenStream {}
impl From<Reason> for Error {}
impl From<Match> for &str {}
impl From<DNSSECRecordType> for &str {}
impl From<Error> for Error {}
impl From<Vec<usize>> for IndexVec {}
impl From<&str> for Vec<u8> {}
impl From<OsString> for Arc<OsStr> {}
impl<T> From<&T> for PathBuf where T: AsRef<OsStr> {}
impl<O, T> From<O> for OwningRef<O, T> where O: StableDeref, O: Deref, <O as Deref>::Target = T {}
impl From<Scheme> for Bytes {}
impl From<StreamId> for {unknown} {}
impl From<OsString> for DefaultEnvKey {}
impl From<ByteStr> for Bytes {}
impl From<Option<&Debt>> for Protection {}
impl From<u8> for OpCode {}
impl From<&Method> for Method {}
impl<T> From<RecvError> for RecvHeaderBlockError<T> {}
impl From<Error> for ProtoError {}
impl From<String> for ResolveError {}
impl From<TokenTree> for TokenStream {}
impl From<UnixSocket> for UnixListener {}
impl From<EnterError> for RunTimeoutError {}
impl From<[u32;_]> for vec128_storage {}
impl From<UCString<u16>> for OsString {}
impl From<&CStr> for Rc<CStr> {}
impl<T> From<(T, TrySendError)> for UnboundedTrySendError<T> {}
impl<T> From<&Vec<T>> for Cow<[T]> where T: Clone {}
impl From<&str> for Arc<str> {}
impl From<String> for PathBuf {}
impl<X> From<{unknown}> for Uniform<X> where X: SampleUniform {}
impl From<Response<Body>> for Error {}
impl From<i32> for Value {}
impl From<Cow<str>> for Box<dyn Error + Send + Sync + {error}> {}
impl From<Algorithm> for DigestType {}
impl From<SpawnError> for ProtoError {}
impl From<Arc<ClientConfig>> for TlsConnector {}
impl From<StandardHeader> for HeaderName {}
impl From<TcpListener> for Socket {}
impl<R, T> From<T> for RwLock<R, T> where R: RawRwLock {}
impl From<Op> for Op {}
impl<C, T> From<&T> for UCString<C> where C: UChar, T: AsRef<UCStr<C>> {}
impl From<CString> for Arc<CStr> {}
impl<T> From<&[T]> for Arc<[T]> where T: Clone {}
impl From<OsString> for Rc<OsStr> {}
impl From<Bytes> for Body {}
impl From<NulError> for Status {}
impl<T> From<(T, TrySendError)> for TrySendError<T> {}
impl<T, S> From<T> for ArcSwapAny<T, S> where T: RefCnt, S: LockStorage {}
impl From<&{unknown}> for Ref {}
impl From<String> for Box<dyn Error> {}
impl From<&mut [u8]> for &mut IoVec {}
impl From<DigestType> for u8 {}
impl<R, G, T> From<T> for ReentrantMutex<R, G, T> where R: RawMutex, G: GetThreadId {}
impl From<BytesMut> for Bytes {}
impl From<{unknown}> for LexError {}
impl<IO, S> From<(IO, S)> for TlsStream<IO, S> where S: Session {}
impl From<UdpSocket> for Socket {}
impl From<Error> for Error {}
impl From<TryFromSliceError> for Unspecified {}
impl From<char> for u32 {}
impl From<[Block;_]> for Key {}
impl From<&[u8]> for SupportedAlgorithms {}
impl From<[u8;_]> for Ipv4Addr {}
impl From<&str> for ContentEncoding {}
impl From<Message> for DnsResponse {}
impl From<{unknown}> for ReadinessState {}
impl<T> From<T> for Error where T: ResponseError, {error} {}
impl<T> From<&mut Option<T>> for Option<&mut T> {}
impl From<&[u8]> for Body {}
impl From<String> for BytesMut {}
impl From<&mut [u8]> for &mut IoVec {}
impl<T> From<PoisonError<T>> for TryLockError<T> {}
impl From<String> for UString<u16> {}
impl<E> From<E> for Box<dyn Error + {error}> where E: Error, {error} {}
impl<F> From<F> for ErrorImpl where F: Fail {}
impl<T, B> From<Flush<T, Prioritized<{unknown}>>> for Handshaking<T, B> where T: AsyncRead, T: AsyncWrite, B: IntoBuf {}
impl From<ProtoError> for String {}
impl From<{unknown}> for Char {}
impl From<ResponseCode> for u16 {}
impl From<&Error> for Formatter<ErrorKind> {}
impl From<DnsResponse> for Message {}
impl<T> From<&mut [T]> for Vec<T> where T: Clone {}
impl From<RecvError> for TryRecvError {}
impl<T> From<Headers> for Frame<T> {}
impl From<u8> for CertUsage {}
impl From<Vec<u32>> for IndexVec {}
impl From<Vec<u8>> for BytesMut {}
impl From<(char,)> for Fold {}
impl From<u16> for KeyTrust {}
impl From<&str> for Rc<str> {}
impl From<Custom> for Bytes {}
impl From<File> for Stdio {}
impl From<DnsMultiplexerSerialResponseInner> for DnsMultiplexerSerialResponse {}
impl From<{unknown}> for TypeParam {}
impl From<InvalidHeaderValue> for Error {}
impl From<String> for Box<{unknown}> {}
impl From<HeaderValue> for Bytes {}
impl From<UnixReady> for Ready {}
impl From<Ipv4Addr> for u32 {}
impl From<Duration> for Duration {}
impl<T> From<Vec<T>> for Box<[T]> {}
impl From<ConnectError> for ConnectError {}
impl From<u32x4_generic> for vec128_storage {}
impl From<&UCStr<u16>> for Cow<UCStr<u16>> {}
impl From<HeadersFlag> for u8 {}
impl From<Error> for ParseError {}
impl From<IpAddr> for Name {}
impl From<&Path> for Arc<Path> {}
impl From<u8> for Value {}
impl From<PercentDecode> for Cow<[u8]> {}
impl From<Token> for usize {}
impl From<&Box<Sender<i32>>> for SignalId {}
impl<S> From<RecvStream> for Payload<S> {}
impl From<{unknown}> for Span {}
impl From<u16> for KeyUsage {}
impl From<String> for Rc<str> {}
impl<X> From<{unknown}> for Uniform<X> where X: SampleUniform {}
impl<Tz> From<DateTime<Tz>> for SystemTime where Tz: TimeZone {}
impl<T> From<T> for Codec<T, Cursor<Bytes>> where T: AsyncRead, T: AsyncWrite {}
impl From<Error> for Error {}
impl From<Group> for TokenTree {}
impl From<InvalidHeaderNameBytes> for Error {}
impl From<Socket> for {unknown} {}
impl From<IpAddr> for ScopedIp {}
impl From<String> for Cow<{unknown}> {}
impl From<TokenTree> for TokenStream {}
impl From<&str> for ResourceDef {}
impl From<&{unknown}> for Response<Body> {}
impl From<Header<HeaderName>> for Header<Option<HeaderName>> {}
impl<R, T> From<T> for Mutex<R, T> where R: RawMutex {}
impl From<f64> for Value {}
impl From<InvalidUri> for ParseError {}
impl From<ErrorStack> for Error {}
impl From<InvalidHeaderValue> for DecoderError {}
impl From<u32> for FuchsiaReady {}
impl From<SendError> for Error {}
impl From<u16> for UpdateScope {}
impl From<SystemTime> for DateTime<Local> {}
impl<E, F, G> From<E> for Background<F, G> where E: Into<ResolveError>, F: Future, <F as Future>::Error = ResolveError, G: Future, <G as Future>::Error = ResolveError {}
impl<T> From<&mut T> for Unique<T> {}
impl From<InvalidMethod> for Error {}
impl From<i32> for Type {}
impl From<&{unknown}> for Cow<{unknown}> {}
impl From<String> for String<String> {}
impl From<[u16;_]> for Ipv6Addr {}
impl<W> From<IntoInnerError<W>> for Error {}
impl From<TokenStream> for {unknown} {}
impl From<DNSClass> for &str {}
impl From<u128x1_generic> for vec128_storage {}
impl From<u8> for FingerprintType {}
impl<C> From<&UCStr<C>> for Box<UCStr<C>> where C: UChar {}
impl From<SystemTime> for Timestamp {}
impl From<bool> for Value {}
impl From<Utf8Error> for ParseError {}
impl From<isize> for Value {}
impl From<ErrorKind> for InvalidUriParts {}
impl From<FuchsiaReady> for Ready {}
impl From<Reason> for Error {}
impl From<u8> for Protocol {}
impl From<&str> for ProtoError {}
impl From<DataFlags> for u8 {}
impl From<RecvError> for TryRecvError {}
impl From<InvalidStatusCode> for Error {}
impl From<{unknown}> for Socket {}
impl From<OpCode> for u8 {}
impl<I, E> From<Result<I, E>> for Response<Body> where I: Into<Response<Body>>, E: Into<Error> {}
impl<T> From<Port<T>> for u16 {}
impl<T> From<T> for Cell<T> {}
impl From<SocketAddrV6> for SocketAddr {}
impl<T> From<Vec<T>> for Value where T: Into<Value> {}
impl<E> From<E> for TimeoutError<E> {}
impl From<Error> for EncoderError {}
impl From<Version> for Version {}
impl From<ErrorKind> for InvalidUriBytes {}
impl From<KEY> for RData {}
impl<R, G, T> From<T> for ReentrantMutex<R, G, T> where R: RawMutex, G: GetThreadId {}
impl<T> From<{unknown}> for Unique<T> {}
impl From<UnixSocket> for UnixSocket {}
impl From<LookupFuture<LookupEither<ConnectionHandle, StandardConnection>>> for SrvLookupFuture {}
impl From<DateTime<Utc>> for DateTime<Local> {}
impl<T> From<T> for Path<T> {}
impl From<{unknown}> for Socket {}
impl From<Socket> for UdpSocket {}
impl From<u128> for Ipv6Addr {}
impl From<&EdnsOption> for EdnsCode {}
impl From<&ResponseHead> for ResponseBuilder {}
impl From<PushPromiseFlag> for u8 {}
impl From<Duration> for Duration {}
impl From<&[u8]> for TBS {}
impl From<&OsStr> for Box<OsStr> {}
impl From<PathBuf> for Cow<Path> {}
impl From<u32> for Value {}
impl From<LexError> for Error {}
impl<A> From<&[{unknown}]> for SmallVec<A> where A: Array, {unknown}: Clone {}
impl From<Group> for Group {}
impl<T> From<(CloseCode, T)> for CloseReason where T: Into<String> {}
impl<T> From<TrySendError<T>> for TrySendError<T> {}
impl From<SslErrorStack> for ProtoError {}
impl<T> From<PoisonError<T>> for ResolveError {}
impl From<!> for Infallible {}
impl From<UnixSocket> for UnixStream {}
impl From<DateTime<Utc>> for DateTime<FixedOffset> {}
impl From<StatusCode> for u16 {}
impl From<Socket> for TcpStream {}
impl<T> From<T> for Mutex<T> {}
impl From<&Edns> for Record {}
impl From<u16> for RecordType {}
impl From<Cow<CStr>> for CString {}
impl From<Error> for Error {}
impl From<Ipv4Addr> for IpAddr {}
impl From<u16> for DNSSECRecordType {}
impl From<Vec<u32>> for IndexVec {}
impl<F> From<F> for Error where F: Fail {}
impl<O, T> From<O> for OwningRefMut<O, T> where O: StableDeref, O: DerefMut, {error} {}
impl From<f32> for Value {}
impl From<&[u8]> for &IoVec {}
impl<T> From<Vec<T>> for VecDeque<T> {}
impl From<DNSNameRef> for Input {}
impl From<ParseError> for ProtoError {}
impl From<Error> for ResolveError {}
impl From<TokenStream> for TokenStream {}
impl<T> From<&T> for NotifyHandle where T: Notify {}
impl<T> From<T> for Lock<T> {}
impl From<UCString<u32>> for Cow<UCStr<u32>> {}
impl From<Error> for RecvError {}
impl<T> From<Arc<T>> for NotifyHandle where T: Notify, {error} {}
impl From<Error> for DecoderError {}
impl<T> From<Vec<T>> for Cow<[T]> where T: Clone {}
impl<T> From<Vec<T>> for Arc<[T]> {}
impl From<OsString> for Box<OsStr> {}
impl From<PathBuf> for OsString {}
impl From<!> for TryFromIntError {}
impl From<Error> for Error {}
impl From<TryAcquireError> for TrySendError {}
impl From<Errors> for ParseError {}
impl From<ErrorKind> for Status {}
impl<D> From<D> for Context<D> where {error}, D: Send, D: Sync, {error} {}
impl From<Error> for Error {}
impl<T> From<Vec<T>> for Rc<[T]> {}
impl From<Cow<str>> for Box<dyn Error> {}
impl From<Unspecified> for ProtoError {}
impl From<&str> for Bytes {}
impl From<Arc<ServerConfig>> for TlsAcceptor {}
impl<T> From<EnterError> for BlockError<T> {}
impl From<TcpStream> for Socket {}
impl From<Authority> for Bytes {}
impl From<Tag> for usize {}
impl From<Name> for &str {}
impl From<Exec> for Regex {}
impl From<HeaderMap<HeaderValue>> for HeaderMap<HeaderValue> {}
impl<C> From<UCString<C>> for UString<C> where C: UChar {}
impl From<{unknown}> for TDEFLFlush {}
impl From<Error> for Error {}
impl From<&CStr> for Arc<CStr> {}
impl From<Error> for SendError {}
impl<T> From<T> for Arc<T> {}
impl From<&OsStr> for Cow<OsStr> {}
impl From<&String> for Body {}
impl From<ReadinessState> for {unknown} {}
impl From<Uri> for Parts {}
impl From<ChaChaCore> for ChaChaRng {}
impl From<i64> for Value {}
impl From<Literal> for Literal {}
impl From<UString<u32>> for Cow<UStr<u32>> {}
impl From<&str> for Box<dyn Error + Send + Sync + {error}> {}
impl<S> From<Host<S>> for HostInternal {}
impl From<&[u8]> for Bytes {}
impl From<SocketAddr> for SockAddr {}
impl From<{unknown}> for TokenStream {}
impl From<HeaderName> for Bytes {}
impl From<usize> for Index {}
impl<NI> From<u32x4x4_avx2<NI>> for vec512_storage {}
impl From<Protocol> for i32 {}
impl From<u32> for Ipv4Addr {}
impl From<Error> for Error {}
impl From<Error> for Error {}
impl From<&CStr> for Cow<CStr> {}
impl From<()> for Error {}
impl From<RecvError> for RecvTimeoutError {}
impl<S> From<SizedStream<S>> for Body where S: Stream, <S as Stream>::Item = Bytes, <S as Stream>::Error = Error, {error} {}
impl From<u8> for Matching {}
impl From<Error> for Status {}
impl<T> From<&Option<T>> for Option<&T> {}
impl From<&str> for Body {}
impl From<Bytes> for BytesMut {}
impl From<OsString> for UString<u32> {}
impl<T> From<SendError<T>> for TrySendError<T> {}
impl<E> From<E> for Box<dyn Error + Send + Sync + {error}> where E: Error, E: Send, E: Sync, {error} {}
impl From<SocketAddrV6> for SockAddr {}
impl From<ProtoError> for Error {}
impl<NI> From<x4<u128x1_sse2<YesS3, YesS4, NI>>> for u32x4x4_avx2<NI> where NI: Copy {}
impl<T> From<T> for T {}
impl From<Exec> for RegexSet {}
impl<T> From<BinaryHeap<T>> for Vec<T> {}
impl From<TcpStream> for Socket {}
impl From<i32> for Protocol {}
impl<E, U> From<E> for FramedTransportError<E, U> where U: Encoder, U: Decoder {}
impl From<Algorithm> for SupportedAlgorithms {}
impl From<Predicate> for Predicate {}
impl From<&Error> for Formatter<ErrorKind> {}
impl From<Exec> for Regex {}
impl<T> From<&[T]> for Vec<T> where T: Clone {}
impl From<Cow<OsStr>> for OsString {}
impl From<Error> for Error {}
impl<T> From<&[T]> for Value where T: Clone, T: Into<Value> {}
impl From<CertUsage> for u8 {}
impl From<BlockingError<Error>> for PayloadError {}
impl<T> From<&T> for OsString where T: AsRef<OsStr> {}
impl From<Vec<usize>> for IndexVec {}
impl<W, G> From<x2<W, G>> for vec256_storage where W: Copy, vec128_storage: From<W> {}
impl From<SystemTime> for HttpDate {}
impl From<bool> for Value {}
impl From<String> for Body {}
impl From<(char, char)> for Fold {}
impl From<u64> for N0 {}
impl From<Box<Path>> for PathBuf {}
impl From<Io> for PipeReader {}
impl<T> From<Repr<T>> for Bytes where T: Into<Bytes> {}
impl<C> From<&UStr<C>> for Box<UStr<C>> where C: UChar {}
impl<T> From<T> for PathSegment where T: Into<{unknown}> {}
impl From<Box<{unknown}>> for String {}
impl From<Ready> for UnixReady {}
impl From<NulError> for Error {}
impl From<&mut [u8]> for &mut IoVec {}
impl From<Bytes> for Response<Body> {}
impl<T> From<Box<[T]>> for Vec<T> {}
impl From<FromUtf16Error> for Error {}
impl From<Algorithm> for &str {}
impl From<u8> for Selector {}
impl From<Error> for PayloadError {}
impl From<String> for OsString {}
impl From<PathBuf> for Arc<Path> {}
impl From<usize> for Token {}
impl From<Box<dyn Stream<Item = Bytes, Error = PayloadError>>> for Payload<Box<dyn Stream<Item = Bytes, Error = PayloadError>>> {}
impl<T> From<Box<T>> for Rc<T> {}
impl From<Io> for PipeWriter {}
impl<S> From<S> for UniCase<S> where S: AsRef<str> {}
impl From<ChildStdout> for Stdio {}
impl From<Ident> for TokenTree {}
impl From<RecvError> for RecvTimeoutError {}
impl From<Vec<NameServerConfig>> for NameServerConfigGroup {}
impl From<InvalidHeaderName> for Error {}
impl From<i32> for Domain {}
impl From<&String> for String {}
impl From<Reason> for u32 {}
impl<T> From<T> for UnsafeCell<T> {}
impl From<&[u8]> for Response<Body> {}
impl From<&[u8]> for &IoVec {}
impl From<&CStr> for CString {}
impl<E> From<E> for InOrderError<E> {}
impl From<Option<Error>> for PayloadError {}
impl<T> From<SendError<T>> for SendTimeoutError<T> {}
impl From<Ipv6Addr> for Name {}
impl From<&Path> for Rc<Path> {}
impl From<u16> for Value {}
impl From<PercentEncode> for Cow<{unknown}> {}
impl From<InvalidHeaderName> for DecoderError {}
impl<S> From<Payload> for Payload<S> {}
impl<S> From<SslStream<S>> for SslStream<S> {}
impl From<StandardHeader> for HdrName {}
impl<C> From<UString<C>> for Box<UStr<C>> where C: UChar {}
impl From<DNSKEY> for RData {}
impl From<SystemTime> for DateTime<Utc> {}
impl From<&str> for ResolveError {}
impl From<StreamResult> for Result<MZStatus, MZError> {}
impl From<Infallible> for TryFromSliceError {}
impl From<InvalidUriParts> for Error {}
impl From<Ipv6Addr> for ScopedIp {}
impl From<Cow<{unknown}>> for String {}
impl From<Record> for RecordSet {}
impl From<[u8;_]> for Ipv6Addr {}
impl From<{unknown}> for TokenStream {}
impl From<String> for Response<Body> {}
impl From<DNSClass> for u16 {}
impl<T> From<Protocol> for Scheme2<T> {}
impl From<String> for Value {}
impl From<FromUtf8Error> for ParseError {}
impl From<()> for Error {}
impl From<Ready> for FuchsiaReady {}
impl From<Exec> for RegexSet {}
impl From<Error> for Error {}
impl<T> From<{unknown}> for NonNull<T> {}
impl From<&str> for DispositionType {}
impl<T> From<T> for Poll<T> {}
impl From<SettingsFlags> for u8 {}
impl From<Context<ProtoErrorKind>> for ProtoError {}
impl From<{unknown}> for Error {}
impl From<Literal> for TokenTree {}
impl From<Lookup> for SrvLookup {}
impl From<DateTime<Local>> for DateTime<FixedOffset> {}
impl From<String> for Vec<u8> {}
impl From<[u16;_]> for IpAddr {}
impl From<ResponseBuilder> for Response<Body> {}
impl From<Ipv6Addr> for IpAddr {}
impl From<u8> for Algorithm {}
impl<C> From<UCString<C>> for Box<UCStr<C>> where C: UChar {}
impl From<Scheme2<Box<ByteStr>>> for Scheme {}
impl From<SocketAddrV4> for SocketAddr {}
impl From<&str> for Value {}
impl From<Result> for {unknown} {}
impl From<i8> for Value {}
impl From<InvalidStatusCode> for DecoderError {}
impl<T> From<T> for RwLock<T> {}
impl From<LayoutErr> for CollectionAllocErr {}
impl From<ErrorKind> for InvalidUri {}
impl From<Error> for Error {}
impl From<PercentDecode> for Cow<[u8]> {}
impl From<&[u8;_]> for Key {}
impl From<HdrName> for HeaderName {}
impl From<DateTime<Local>> for DateTime<Utc> {}
impl<L, R> From<Result<R, L>> for Either<L, R> {}
impl From<UdpSocket> for Socket {}
impl<M> From<TrySendError<M>> for NotifyError<M> {}
impl From<Ipv6Addr> for u128 {}
impl From<RecordType> for u16 {}
impl From<CString> for Box<CStr> {}
impl From<usize> for Selected {}
impl<T, E> From<Result<T, E>> for FutureResult<T, E> {}
impl From<&Path> for Cow<Path> {}
impl<S> From<Host<S>> for HostInternal {}
impl<T> From<T> for Async<T> {}
impl<T> From<&T> for NonNull<T> {}
impl From<ErrorStack> for Error {}
impl<B> From<Reset> for Frame<B> {}
impl<C, T> From<&T> for UString<C> where C: UChar, T: AsRef<UStr<C>> {}
impl<T> From<*mut T> for AtomicPtr<T> {}
impl<T> From<Error> for SendError<T> {}
impl From<DNSNameRef> for DNSName {}
impl From<ResolveError> for Error {}
impl<T, B> From<Codec<T, Prioritized<{unknown}>>> for Handshaking<T, B> where T: AsyncRead, T: AsyncWrite, B: IntoBuf {}
impl From<String> for Property {}
impl From<Utf8Error> for ParseError {}
impl From<Socket> for {unknown} {}
impl From<u8> for Level {}
impl From<&Record> for Edns {}
impl From<Errors> for ParseError {}
impl From<Socket> for TcpStream {}
impl From<&CStr> for Box<CStr> {}
impl From<u16> for EdnsCode {}
impl From<Error> for RecvError {}
impl From<TimerError> for Error {}
impl From<PathBuf> for Box<Path> {}
impl<O, T> From<OwningRefMut<O, T>> for OwningRef<O, T> where O: StableDeref, O: DerefMut, {error} {}
impl From<u64> for Value {}
impl<U32> From<Counter<U32>> for Iv where U32: Layout<u32>, u32: From<U32> {}
impl From<String> for ByteStr {}
impl<S> From<ErrorStack> for HandshakeError<S> {}
impl From<usize> for KeepAlive {}
impl<A> From<A> for SmallVec<A> where A: Array {}
impl<E> From<PercentEncode<E>> for Cow<{unknown}> where E: EncodeSet {}
impl From<UString<u32>> for OsString {}
impl From<u16> for CloseCode {}
impl<T> From<Error> for TrySendError<T> {}
impl<T> From<VecDeque<T>> for Vec<T> {}
impl From<Error<ProtoError>> for ProtoError {}
impl From<ProtoError> for ResolveError {}
impl From<TokenStream> for {unknown} {}
impl From<EdnsCode> for u16 {}
impl From<UCString<u16>> for Cow<UCStr<u16>> {}
impl From<DNSSECRecordType> for u16 {}
impl From<Error> for Error {}
impl<T> From<&[T]> for Cow<[T]> where T: Clone {}
impl<T> From<Box<T>> for Arc<T> {}
impl From<&OsStr> for Arc<OsStr> {}
impl<S, E> From<BodyStream<S, E>> for Body where S: Stream, <S as Stream>::Item = Bytes, <S as Stream>::Error = E, {error}, E: Into<Error>, {error} {}
impl From<OsString> for PathBuf {}
impl From<Infallible> for TryFromIntError {}
impl From<ErrorKind> for Error {}
impl From<Error> for Error {}
impl From<Status> for ErrorKind {}
impl From<DefaultEnvKey> for OsString {}
impl<T> From<T> for Env where T: Into<Cow<str>> {}
impl From<f64> for Value {}
impl From<&[u8;_]> for Block {}
impl<Sz> From<ShortHash<Sz>> for HashValue {}
impl From<{unknown}> for Error {}
impl<T> From<PoisonError<T>> for ProtoError {}
impl<T> From<Vec<T>> for BinaryHeap<T> where T: Ord {}
impl From<EndOfInput> for Unspecified {}
impl From<UCString<u32>> for OsString {}
impl From<UserError> for SendError {}
impl From<CString> for Rc<CStr> {}
impl From<String> for Arc<str> {}
impl From<OsString> for Cow<OsStr> {}
impl<T> From<T> for RefCell<T> {}
impl<T> From<T> for Message<T> {}
impl<B> From<GoAway> for Frame<B> {}
impl<X> From<{unknown}> for Uniform<X> where X: SampleUniform {}
impl<T> From<NodeToHandle<T>> for NotifyHandle {}
impl From<&str> for Box<dyn Error> {}
impl From<String> for Bytes {}
impl From<Custom> for HeaderName {}
impl From<TokenStream> for {unknown} {}
impl From<Message<RequestHead>> for Request<Box<dyn Stream<Item = Bytes, Error = PayloadError>>> {}
impl<B> From<WindowUpdate> for Frame<B> {}
impl From<VersionReq> for VersionReq {}
impl From<Error> for Error {}
impl From<&CString> for Cow<CStr> {}
impl<T> From<Ping> for Frame<T> {}
impl From<&OsStr> for Rc<OsStr> {}
impl From<BytesMut> for Body {}
impl<T> From<PushPromise> for Frame<T> {}
impl From<Authority> for Key {}
impl From<Matching> for u8 {}
impl From<Status> for Error {}
impl<T> From<T> for Option<T> {}
impl From<&str> for BytesMut {}
impl From<&str> for Value {}
impl From<OsString> for UString<u16> {}
impl From<usize> for Ref {}
impl From<String> for Box<dyn Error + Send + Sync> {}
impl From<Vec<u8>> for Bytes {}
impl From<SocketAddrV4> for SockAddr {}
impl From<LexError> for LexError {}
impl From<ChildStdin> for Stdio {}
impl From<Utf8Error> for ProtoError {}
impl<R, T> From<T> for Mutex<R, T> where R: RawMutex {}
impl From<TcpListener> for Socket {}
impl From<Type> for i32 {}
impl From<u8> for char {}
impl From<&SupportedAlgorithms> for Vec<u8> {}
impl From<[u8;_]> for IpAddr {}
impl From<String> for ReqParseError {}
impl From<SmallVec<[Message;_]>> for DnsResponse {}
impl From<Error> for Response<Body> {}
impl From<&OsString> for Cow<OsStr> {}
impl From<Lookup> for LookupIp {}
impl From<Tm> for HttpDate {}
impl From<Vec<u8>> for Body {}
impl From<&[u8]> for BytesMut {}
impl From<&[u8]> for &IoVec {}
impl From<(char, char, char)> for Fold {}
impl From<String> for UString<u32> {}
impl From<&Path> for Box<Path> {}
impl<T> From<T> for Rc<T> {}
impl From<&HeaderName> for HeaderName {}
impl From<&StatusCode> for StatusCode {}
impl From<&StreamResult> for Result<MZStatus, MZError> {}
impl<T> From<T> for Path where T: Into<PathSegment> {}
impl From<Never> for Error {}
impl From<AddrParseError> for AddrParseError {}
impl From<Option<{unknown}>> for Char {}
impl From<HeaderName> for HeaderValue {}
impl From<DeriveInput> for Item {}
impl From<u16> for ResponseCode {}
impl From<BytesMut> for Response<Body> {}
impl<T> From<Cow<[T]>> for Vec<T> where [T]: ToOwned, <[T] as ToOwned>::Owned = Vec<T> {}
impl From<Utf8Error> for Error {}
impl From<Key> for Cow<str> {}
impl From<(u64, u64, u64)> for Version {}
impl From<Selector> for u8 {}
impl From<HttpDate> for SystemTime {}
impl From<Cow<Path>> for PathBuf {}
impl From<char> for Value {}
impl From<KeyTrust> for u16 {}
impl<T> From<&[T]> for Rc<[T]> where T: Clone {}
impl From<ChildStderr> for Stdio {}
impl From<bool> for AtomicBool {}
impl<F, G> From<AndThen<MapErr<Receiver<F>, fn(Canceled) -> ResolveError>, G, fn(F) -> G>> for Background<F, G> where F: Future, <F as Future>::Error = ResolveError, G: Future, <G as Future>::Error = ResolveError {}
impl From<Error> for Error {}
impl From<Punct> for TokenTree {}
impl From<InvalidHeaderValueBytes> for Error {}
impl From<&{unknown}> for String {}
impl From<&HeaderValue> for HeaderValue {}
impl<R, T> From<T> for RwLock<R, T> where R: RawRwLock {}
impl From<Duration> for Duration {}
impl<A, T, S> From<A> for Cache<A, T> where A: Deref, <A as Deref>::Target = ArcSwapAny<T, S>, T: RefCnt, S: LockStorage {}
impl From<u32> for Reason {}
impl<T> From<HandshakeError<T>> for ConnectError {}
impl From<&UCStr<u32>> for Cow<UCStr<u32>> {}
impl From<Error> for PayloadError {}
impl<R, G, T> From<T> for ReentrantMutex<R, G, T> where R: RawMutex, G: GetThreadId {}
impl From<Ipv4Addr> for Name {}
impl From<PathBuf> for Rc<Path> {}
impl From<InvalidMethod> for DecoderError {}
impl From<UString<u16>> for Cow<UStr<u16>> {}
impl<S> From<Payload> for Payload<S> {}
impl From<Span> for Span {}
impl From<KeyUsage> for u16 {}
impl<X> From<{unknown}> for Uniform<X> where X: SampleUniform {}
impl<C> From<Box<UStr<C>>> for UString<C> where C: UChar {}
impl<T, E, A> From<Result<T, E>> for FutureResult<T, E, A> {}
impl<T> From<Settings> for Frame<T> {}
impl From<Context<ResolveErrorKind>> for ResolveError {}
impl<Tz> From<TsSeconds<Tz>> for DateTime<Tz> where Tz: TimeZone {}
impl From<InvalidUriBytes> for Error {}
impl From<Socket> for {unknown} {}
impl From<Ipv4Addr> for ScopedIp {}
impl From<&String> for Cow<{unknown}> {}
impl<B> From<Priority> for Frame<B> {}
impl From<ParserNumber> for Number {}
impl From<DecompressError> for Error {}
impl From<String> for ResourceDef {}
impl From<CString> for Vec<u8> {}
impl From<&String> for Response<Body> {}
impl From<Algorithm> for u8 {}
impl From<f32> for Value {}
impl From<Error> for ParseError {}
impl From<ErrorStack> for Error {}
impl From<usize> for Value {}
impl From<Utf8Error> for DecoderError {}
impl From<u32> for Ready {}
impl From<UserError> for Error {}
impl From<UpdateScope> for u16 {}
impl<R, T> From<T> for Mutex<R, T> where R: RawMutex {}
impl<S> From<Ascii<S>> for UniCase<S> {}
impl From<ProtoErrorKind> for ProtoError {}
impl From<ResolveErrorKind> for ResolveError {}
impl<T> From<&T> for Unique<T> {}
impl From<InvalidUri> for Error {}
impl From<Domain> for i32 {}
impl From<Io> for UnixSocket {}
impl From<CompressError> for Error {}
impl From<[u8;_]> for IpAddr {}
impl<T> From<T> for Connect<T> where T: Address {}
impl From<&[u8]> for &IoVec {}
impl From<u64x2_generic> for vec128_storage {}
impl<C> From<Box<UCStr<C>>> for UCString<C> where C: UChar {}
impl<R, T> From<T> for RwLock<R, T> where R: RawRwLock {}
impl From<Cow<str>> for Value {}
impl From<TsSeconds> for NaiveDateTime {}
impl<U> From<Notify<U>> for NotifyHandle where U: Unpark {}
impl<T> From<SendError<T>> for TrySendError<T> {}
impl From<DecoderError> for Error {}
impl From<AllocErr> for CollectionAllocErr {}
impl From<Protocol> for u8 {}
impl From<&UStr<u32>> for Cow<UStr<u32>> {}
impl From<String> for ProtoError {}
trait Into<T> {}
impl Into<usize> for Selected {}
impl Into<u8> for Algorithm {}
impl Into<IpAddr> for ScopedIp {}
impl Into<u8> for FingerprintType {}
impl Into<vec128_storage> for [u32;_] {}
impl Into<usize> for LengthMeasurement {}
impl Into<u16> for CloseCode {}
impl<T, U> Into<U> for T where U: From<T> {}
impl Into<u32> for FuchsiaReady {}
impl Into<IpAddr> for &ScopedIp {}
impl<L, R> Into<Result<R, L>> for Either<L, R> {}
impl Into<SystemTime> for Timestamp {}
impl Into<Duration> for Duration {}
impl<C> Into<Vec<C>> for UCString<C> where C: UChar {}
impl Into<DnsRequest> for Message {}
impl Into<u8> for Level {}
impl<A, M> Into<Recipient<M>> for Addr<A> where A: Actor, M: Message, M: Send, {error}, A: Handler<M>, {unknown}: Send, {unknown}: ToEnvelope<A, M> {}
impl Into<u8> for OpCode {}
impl<C> Into<Vec<C>> for NulError<C> where C: UChar {}
impl Into<UString<u32>> for Vec<{unknown}> {}
impl Into<&str> for DNSNameRef {}
impl Into<&[u32;_]> for &vec128_storage {}
impl Into<vec256_storage> for [u64;_] {}
impl<B> Into<Response<B>> for ServiceResponse<B> {}
impl Into<Box<[u8]>> for Writer {}
impl Into<UString<u32>> for Vec<u32> {}
impl Into<UString<u16>> for Vec<u16> {}
impl<C> Into<Vec<C>> for UString<C> where C: UChar {}
impl<S, E> Transform<S>