Skip to content

Instantly share code, notes, and snippets.

@flodiebold

flodiebold/actix-hang.rs

Created September 3, 2019 15:19
Show Gist options
  • Star 0 You must be signed in to star a gist
  • Fork 0 You must be signed in to fork a gist
  • Save flodiebold/529ec845c39b5cb81909aac4b613ba44 to your computer and use it in GitHub Desktop.
Save flodiebold/529ec845c39b5cb81909aac4b613ba44 to your computer and use it in GitHub Desktop.
Download ZIP
Raw
actix-hang.rs
// 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> for Timeout<E> where S: Service {
type Request = {unknown};
type Response = {unknown};
type Error = TimeoutError<{unknown}>;
type InitError = E;
type Transform = TimeoutService<S>;
type Future = FutureResult<{unknown}, {unknown}>;
}
impl<T, S, F, E> Transform<S> for TransformMapInitErr<T, S, F, E> where T: Transform<S>, F: Fn<{unknown}> {
type Request = {unknown};
type Response = {unknown};
type Error = {unknown};
type Transform = {unknown};
type InitError = E;
type Future = TransformMapInitErrFuture<T, S, F, E>;
}
impl<S> Transform<S> for InOrder<S> where S: Service, {error}, {error}, {error} {
type Request = {unknown};
type Response = {unknown};
type Error = InOrderError<{unknown}>;
type InitError = Infallible;
type Transform = InOrderService<S>;
type Future = FutureResult<{unknown}, {unknown}>;
}
impl<S> Transform<S> for InFlight where S: Service {
type Request = {unknown};
type Response = {unknown};
type Error = {unknown};
type InitError = Infallible;
type Transform = InFlightService<S>;
type Future = FutureResult<{unknown}, {unknown}>;
}
impl<S, B> Transform<S> for Logger 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 InitError = ();
type Transform = LoggerMiddleware<S>;
type Future = FutureResult<{unknown}, {unknown}>;
}
impl<F, S, In, Out, Err> Transform<S> for FnTransform<F, S, In, Out, Err> where S: Service, F: FnMut<{unknown}>, Out: IntoFuture, {unknown}: From<{unknown}> {
type Request = In;
type Response = {unknown};
type Error = {unknown};
type Transform = Apply<S, F, In, Out>;
type InitError = Err;
type Future = FutureResult<{unknown}, {unknown}>;
}
impl<S, B> Transform<S> for ErrorHandlers<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 InitError = ();
type Transform = ErrorHandlersMiddleware<S, B>;
type Future = FutureResult<{unknown}, {unknown}>;
}
impl<T, S> Transform<S> for Rc<T> where T: Transform<S> {
type Request = {unknown};
type Response = {unknown};
type Error = {unknown};
type InitError = {unknown};
type Transform = {unknown};
type Future = {unknown};
}
impl<S, B> Transform<S> for Compress 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 InitError = ();
type Transform = CompressMiddleware<S>;
type Future = FutureResult<{unknown}, {unknown}>;
}
impl<S, B> Transform<S> for NormalizePath 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 InitError = ();
type Transform = NormalizePathNormalization<S>;
type Future = FutureResult<{unknown}, {unknown}>;
}
impl<T, S, E> Transform<S> for TransformFromErr<T, S, E> where T: Transform<S>, E: From<{unknown}> {
type Request = {unknown};
type Response = {unknown};
type Error = {unknown};
type Transform = {unknown};
type InitError = E;
type Future = TransformFromErrFuture<T, S, E>;
}
impl<T, S> Transform<S> for Arc<T> where T: Transform<S> {
type Request = {unknown};
type Response = {unknown};
type Error = {unknown};
type InitError = {unknown};
type Transform = {unknown};
type Future = {unknown};
}
impl<S, B> Transform<S> for DefaultHeaders 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 InitError = ();
type Transform = DefaultHeadersMiddleware<S>;
type Future = FutureResult<{unknown}, {unknown}>;
}
trait Transform<S> {
type Request;
type Response;
type Error;
type Transform;
type InitError;
type Future;
}
struct Timeout<E>;
struct ResolverFactory<T>;
trait FnMut<Args> {}
impl<A, F> FnMut<A> for &mut F where F: FnMut<A> {}
impl<A, F> FnMut<A> for &F where F: Fn<A> {}
trait Clone {}
impl<A, F, Response> Clone for Map<A, F, Response> where A: Clone, F: Clone {}
impl<F> Clone for BufDnsRequestStreamHandle<F> where F: Future, <F as Future>::Item = DnsResponse, <F as Future>::Error = ProtoError, F: Send {}
impl<B> Clone for Cow<B> where B: ToOwned {}
impl<T> Clone for Lock<T> {}
impl Clone for PrefilterObj {}
impl<I, U> Clone for Flatten<I> where I: Iterator, I: Clone, U: Iterator, U: Clone, {unknown}: IntoIterator, <{unknown} as IntoIterator>::IntoIter = U, <{unknown} as IntoIterator>::Item = {unknown} {}
impl Clone for _IP_ADAPTER_ADDRESSES_LH {}
impl<T, S> Clone for Intersection<T, S> {}
impl<T> Clone for Iter<T> {}
impl<T, S> Clone for ArcSwapAny<T, S> where T: RefCnt, S: LockStorage {}
impl Clone for _IP_ADAPTER_ANYCAST_ADDRESS_XP__bindgen_ty_1__bindgen_ty_1 {}
impl<T, P> Clone for NativeTlsAcceptor<T, P> where T: AsyncRead, T: AsyncWrite {}
impl<T> Clone for TableEntry<T> where T: Send {}
impl<T> Clone for Path<T> where T: Clone {}
impl<T, U> Clone for RustlsConnector<T, U> {}
impl<K> Clone for Iter<K> {}
impl<K, V, S> Clone for ParValues<K, V, S> {}
impl<T, S1, S2> Clone for ParUnion<T, S1, S2> {}
impl<T, S, E> Clone for TransformFromErr<T, S, E> where T: Clone {}
impl Clone for _IP_ADAPTER_DNS_SERVER_ADDRESS_XP__bindgen_ty_1 {}
impl<T> Clone for Bucket<T> {}
impl<R, Rsdr> Clone for ReseedingCore<R, Rsdr> where R: BlockRngCore, R: SeedableRng, R: Clone, Rsdr: RngCore, Rsdr: Clone {}
impl<T> Clone for Weak<T> {}
impl<A, F, E> Clone for MapErr<A, F, E> where A: Clone, F: Clone {}
impl<K, V> Clone for Keys<K, V> {}
impl Clone for Exec {}
impl<Node, Type> Clone for Handle<Node, Type> where Node: Copy {}
impl<T> Clone for Cell<T> {}
impl Clone for SelectorId {}
impl<T, S> Clone for Intersection<T, S> {}
impl<T> Clone for *mut T {}
impl<A, B> Clone for EitherService<A, B> where A: Clone, B: Clone {}
impl Clone for _IP_ADAPTER_UNICAST_ADDRESS_LH__bindgen_ty_1 {}
impl Clone for ReleaseCapacity {}
impl<A, F, Res> Clone for MapNewService<A, F, Res> where A: Clone, F: Clone {}
impl Clone for Waker {}
impl<T, S> Clone for Difference<T, S> {}
impl<T> Clone for TcpConnector<T> {}
impl<T> Clone for RawIter<T> {}
impl<T> Clone for Array64<T> where T: Copy, T: Default {}
impl<T> Clone for CloneableService<T> {}
impl Clone for NotifyHandle {}
impl<K, V> Clone for Keys<K, V> {}
impl<R, E, F> Clone for KeepAlive<R, E, F> where F: Clone {}
impl<T> Clone for RChunks<T> {}
impl<T, S> Clone for Difference<T, S> {}
impl Clone for Droppable {}
impl<K, V> Clone for Keys<K, V> {}
impl Clone for _IP_ADAPTER_MULTICAST_ADDRESS_XP {}
impl Clone for Dropable {}
impl<T> Clone for Discriminant<T> {}
impl Clone for Bytes {}
impl<T, S1, S2> Clone for ParSymmetricDifference<T, S1, S2> {}
impl<T, S> Clone for Difference<T, S> {}
impl Clone for _IP_ADAPTER_GATEWAY_ADDRESS_LH__bindgen_ty_1__bindgen_ty_1 {}
impl<E> Clone for StringDeserializer<E> {}
impl<T, S> Clone for Tx<T, S> where S: Semaphore {}
impl<T, P> Clone for RustlsAcceptor<T, P> {}
impl Clone for Pos {}
impl<T> Clone for Windows<T> {}
impl Clone for RegistrationInner {}
impl<R, Rsdr> Clone for ReseedingRng<R, Rsdr> where R: BlockRngCore, R: SeedableRng, R: Clone, Rsdr: RngCore, Rsdr: Clone {}
impl<T> Clone for Arc<T> {}
impl<T> Clone for ResolverFactory<T> {}
impl<K, V> Clone for Iter<K, V> {}
impl<T, E> Clone for Result<T, E> where T: Clone, E: Clone {}
impl<E> Clone for Timeout<E> {}
impl Clone for Bucket {}
impl Clone for _IP_ADAPTER_ADDRESSES_LH__bindgen_ty_1__bindgen_ty_1 {}
impl<T> Clone for Sender<T> {}
impl<T> Clone for LinkedList<T> where T: Clone {}
impl Clone for Blocks {}
impl<T> Clone for ComPtr<T> where T: Interface {}
impl Clone for VaListImpl {}
impl<T, S> Clone for Union<T, S> {}
impl<B> Clone for StreamRef<B> {}
impl<T> Clone for Sender<T> {}
impl<T> Clone for RefCell<T> where T: Clone {}
impl<T> Clone for Union<T> {}
impl<T> Clone for Vec<T> where T: Clone {}
impl Clone for Droppable {}
impl Clone for _IP_ADAPTER_DNS_SUFFIX {}
impl<T, S> Clone for SymmetricDifference<T, S> {}
impl<M> Clone for Recipient<M> where M: Message, M: Send, {unknown}: Send {}
impl<T, U> Clone for OpensslConnectorService<T, U> {}
impl<K, V, S> Clone for ParKeys<K, V, S> {}
impl<T, P> Clone for Split<T, P> where P: Clone, P: FnMut<{unknown}> {}
impl Clone for _NET_LUID_LH__bindgen_ty_1 {}
impl<A, B> Clone for AndThen<A, B> where A: Clone {}
impl<F, Req, Out> Clone for ServiceFn<F, Req, Out> where F: FnMut<{unknown}>, Out: IntoFuture {}
impl<T> Clone for ParIter<T> {}
impl<A> Clone for Addr<A> where A: Actor {}
impl<T, S> Clone for Intersection<T, S> {}
impl<F, T, R> Clone for AsyncHandler<F, T, R> where F: AsyncFactory<T, R>, R: IntoFuture, {unknown}: Responder, {unknown}: Into<Error> {}
impl<K, V> Clone for Iter<K, V> {}
impl Clone for _IP_ADAPTER_ANYCAST_ADDRESS_XP__bindgen_ty_1 {}
impl<K, V, S> Clone for ParKeys<K, V, S> {}
impl<K, V> Clone for Iter<K, V> {}
impl<T, S> Clone for SymmetricDifference<T, S> {}
impl<U> Clone for Notify<U> {}
impl Clone for _IP_ADAPTER_DNS_SERVER_ADDRESS_XP {}
impl<E> Clone for CowStrDeserializer<E> {}
impl Clone for Box<RawValue> {}
impl<Sz> Clone for ShortHash<Sz> {}
impl<T> Clone for Sender<T> {}
impl<T> Clone for EcKey<T> {}
impl<T, F, In, Out> Clone for Apply<T, F, In, Out> where T: Service, T: Clone, F: Clone {}
impl<R, Rsdr> Clone for ReseedingCore<R, Rsdr> where R: BlockRngCore, R: SeedableRng, R: Clone, Rsdr: RngCore, Rsdr: Clone {}
impl<T> Clone for MaybeUninit<T> where T: Copy {}
impl<T> Clone for RChunksExact<T> {}
impl<T> Clone for Iter<T> {}
impl Clone for SocketAddrV6 {}
impl<T> Clone for Intersection<T> {}
impl<A> Clone for TaskRc<A> {}
impl<M, E> Clone for Elem<M, E> {}
impl<A, F, E> Clone for MapErrNewService<A, F, E> where A: NewService, A: Clone, F: Fn<{unknown}> {}
impl Clone for _IP_ADAPTER_PREFIX_XP__bindgen_ty_1__bindgen_ty_1 {}
impl<T> Clone for SyncSender<T> {}
impl<T> Clone for Resolver<T> {}
impl<K, V> Clone for Keys<K, V> {}
impl<K, V, S> Clone for ParIter<K, V, S> {}
impl Clone for ProtoError {}
impl<T> Clone for &T {}
impl Clone for _GUID {}
impl<K, V> Clone for Keys<K, V> {}
impl<A> Clone for AddressSender<A> where A: Actor {}
impl<T> Clone for Weak<T> {}
impl<F, C, R, S, E> Clone for FnNewServiceConfig<F, C, R, S, E> where F: Fn<{unknown}>, R: IntoFuture, <R as IntoFuture>::Error = E, {unknown}: IntoService<S>, S: Service {}
impl<K, V> Clone for ParValues<K, V> {}
impl<T1, T2, Io1, Io2> Clone 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} {}
impl<A, B, F, Out> Clone for AndThenApply<A, B, F, Out> where A: Service, A: Clone, B: Service, <B as Service>::Error = {unknown}, F: FnMut<{unknown}>, Out: IntoFuture, {unknown}: Into<{unknown}> {}
impl<T> Clone for Option<T> where T: Clone {}
impl<T> Clone for Cell<T> where T: Copy {}
impl Clone for Buffer {}
impl<T> Clone for OpensslConnectServiceFactory<T> {}
impl<A, F, E> Clone for MapInitErr<A, F, E> where A: Clone, F: Clone {}
impl Clone for _IP_ADAPTER_DNS_SERVER_ADDRESS_XP__bindgen_ty_1__bindgen_ty_1 {}
impl Clone for Box<OsStr> {}
impl Clone for Box<CStr> {}
impl<F, Req, Out, Cfg> Clone for NewServiceFn<F, Req, Out, Cfg> where F: FnMut<{unknown}>, Out: IntoFuture {}
impl<T> Clone for Empty<T> {}
impl Clone for HandleRef {}
impl<T, S1, S2> Clone for SymmetricDifference<T, S1, S2> {}
impl<T, P> Clone for Pairs<T, P> {}
impl<T> Clone for Range<T> {}
impl Clone for ProtoErrorKind {}
impl<T> Clone for Cell<T> {}
impl Clone for _IP_ADAPTER_GATEWAY_ADDRESS_LH__bindgen_ty_1 {}
impl Clone for Select {}
impl Clone for BytesMut {}
impl Clone for InternalNumeric {}
impl<T> Clone for Iter<T> {}
impl<A, C> Clone for UnitConfig<A, C> where A: Clone {}
impl<A> Clone for Iter<A> {}
impl Clone for ServiceConfig {}
impl<M> Clone for BoxedLimbs<M> {}
impl<T, S> Clone for Union<T, S> {}
impl<T> Clone for SymmetricDifference<T> {}
impl<K, V> Clone for Iter<K, V> {}
impl<F> Clone for Shared<F> where {error} {}
impl<T> Clone for Dsa<T> {}
impl Clone for _IP_ADAPTER_ADDRESSES_LH__bindgen_ty_1 {}
impl<K, V> Clone for Iter<K, V> {}
impl<T, U> Clone for OpensslConnector<T, U> {}
impl Clone for HashValue {}
impl<K, V> Clone for Values<K, V> {}
impl<T> Clone for Bucket<T> {}
impl Clone for ! {}
impl Clone for _NET_LUID_LH {}
impl<K, V, S> Clone for LinkedHashMap<K, V, S> where K: Hash, K: Eq, K: Clone, V: Clone, S: BuildHasher, S: Clone {}
impl<A, B> Clone for AndThenNewService<A, B> where A: NewService, A: Clone, B: NewService, B: Clone {}
impl Clone for {unknown} {}
impl Clone for Hasher {}
impl Clone for Ipv6Addr {}
impl<T> Clone for Receiver<T> {}
impl Clone for Droppable {}
impl<K, V> Clone for Keys<K, V> {}
impl<T, P> Clone for OpensslAcceptor<T, P> where T: AsyncRead, T: AsyncWrite {}
impl Clone for ResolveError {}
impl Clone for _IP_ADAPTER_MULTICAST_ADDRESS_XP__bindgen_ty_1__bindgen_ty_1 {}
impl<T> Clone for ChunksExact<T> {}
impl<S> Clone for Hasher<S> where S: Sip {}
impl<M> Clone for Sender<M> {}
impl<T> Clone for NonNull<T> {}
impl<F> Clone for DnsRequestStreamHandle<F> where F: Future, <F as Future>::Item = DnsResponse, <F as Future>::Error = ProtoError, F: Send {}
impl<F, C, T, R, S> Clone for ApplyConfigNewService<F, C, T, R, S> where C: Clone, F: FnMut<{unknown}>, T: NewService, <T as NewService>::Config = (), R: IntoFuture, <R as IntoFuture>::Error = {unknown}, {unknown}: IntoService<S>, S: Service {}
impl<T> Clone for Chunks<T> {}
impl<A, B, F, Out> Clone for AndThenApplyNewService<A, B, F, Out> where A: Clone, B: Clone {}
impl<T> Clone for TcpConnectorFactory<T> {}
impl<T> Clone for RawIterRange<T> {}
impl<T, S> Clone for Intersection<T, S> {}
impl<K, V> Clone for ParIter<K, V> {}
impl<T> Clone for Receiver<T> {}
impl<T> Clone for UnboundedSender<T> {}
impl<K, V> Clone for IntoIter<K, V> where K: Clone, V: Clone {}
impl Clone for _IP_ADAPTER_ANYCAST_ADDRESS_XP {}
impl Clone for Box<Path> {}
impl Clone for Dropable {}
impl Clone for SenderCtl {}
impl<T, S1, S2> Clone for ParIntersection<T, S1, S2> {}
impl<A, F, C> Clone for MapConfig<A, F, C> where A: Clone, F: Clone {}
impl<T> Clone for Sender<T> {}
impl<T, S> Clone for Union<T, S> {}
impl Clone for DigestBytes {}
impl<T> Clone for Difference<T> {}
impl<A> Clone for SmallVec<A> where A: Array, {unknown}: Clone {}
impl Clone for String {}
impl Clone for _IP_ADAPTER_WINS_SERVER_ADDRESS_LH__bindgen_ty_1__bindgen_ty_1 {}
impl<K> Clone for Iter<K> {}
impl<A, B> Clone for ThenNewService<A, B> where A: Clone, B: Clone {}
impl<K, V> Clone for Values<K, V> {}
impl Clone for SocketAddrV4 {}
impl<T, S> Clone for ApplyTransform<T, S> {}
impl<T> Clone for Iter<T> {}
impl<H> Clone for BuildHasherDefault<H> {}
impl Clone for _IP_ADAPTER_PREFIX_XP__bindgen_ty_1 {}
impl<K, V> Clone for Values<K, V> {}
impl<T> Clone for BinaryHeap<T> where T: Clone {}
impl<T> Clone for RawIterRange<T> {}
impl Clone for sockaddr {}
impl Clone for BorrowRef {}
impl<B, P> Clone for Streams<B, P> where P: Peer {}
impl Clone for TaskUnpark {}
impl<F, C, R, S, E> Clone 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 {}
impl<F, C, T, R, S> Clone for ApplyConfigService<F, C, T, R, S> where F: FnMut<{unknown}>, T: Service, R: IntoFuture, {unknown}: IntoService<S>, S: Service {}
impl<T> Clone for VecDeque<T> where T: Clone {}
impl Clone for {unknown} {}
impl Clone for _IP_ADAPTER_ADDRESSES_LH__bindgen_ty_2 {}
impl<K, V> Clone for Values<K, V> {}
impl Clone for _IP_ADAPTER_UNICAST_ADDRESS_LH {}
impl<T> Clone for Unique<T> {}
impl<W> Clone for WeightedIndex<W> where W: Weight, Uniform<W>: Clone {}
impl<T, S1, S2> Clone for ParDifference<T, S1, S2> {}
impl<K, V> Clone for BTreeMap<K, V> where K: Clone, V: Clone {}
impl Clone for Ipv4Addr {}
impl<T, S> Clone for SymmetricDifference<T, S> {}
impl<T> Clone for Sender<T> {}
impl<A, E> Clone for FromErrNewService<A, E> where A: Clone {}
impl<T> Clone for UnboundedSender<T> {}
impl<T, U> Clone for Index<T, U> {}
impl<I, E> Clone for MapDeserializer<I, E> where I: Iterator, I: Clone, {unknown}: Pair, <{unknown} as Pair>::Second: Clone {}
impl<T, E> Clone for UnsafeWriter<T, E> where T: AsyncWrite, E: From<Error> {}
impl<T> Clone for Rsa<T> {}
impl Clone for Error {}
impl Clone for _IP_ADAPTER_GATEWAY_ADDRESS_LH {}
impl<T, S> Clone for Union<T, S> {}
impl<T> Clone for Iter<T> {}
impl<K, V> Clone for Range<K, V> {}
impl<T> Clone for SyncSender<T> {}
impl<O, T> Clone for OwningRef<O, T> where O: CloneStableDeref {}
impl Clone for ThreadPool {}
impl<K, V> Clone for Values<K, V> {}
impl Clone for OpaqueStreamRef {}
impl<K, V, S> Clone for ParIter<K, V, S> {}
impl Clone for Infallible {}
impl Clone for _IP_ADAPTER_ADDRESSES_LH__bindgen_ty_2__bindgen_ty_1 {}
impl<K> Clone for Iter<K> {}
impl<T> Clone for *const T {}
impl Clone for _IP_ADAPTER_UNICAST_ADDRESS_LH__bindgen_ty_1__bindgen_ty_1 {}
impl<T> Clone for Data<T> {}
impl Clone for {unknown} {}
impl<T> Clone for Iter<T> {}
impl<F, T, R> Clone for Handler<F, T, R> where F: Factory<T, R>, R: Responder {}
impl Clone for _IP_ADAPTER_MULTICAST_ADDRESS_XP__bindgen_ty_1 {}
impl<K, V, Type> Clone for NodeRef<Immut, K, V, Type> where {error}, {error} {}
impl<F, S, In, Out, Err> Clone for FnTransform<F, S, In, Out, Err> where F: FnMut<{unknown}>, Out: IntoFuture {}
impl<T> Clone for Sender<T> {}
impl<T> Clone for FromRawArc<T> {}
impl<T> Clone for RawTable<T> where T: Clone {}
impl<T, Io> Clone for ConnectionPool<T, Io> where T: Clone, Io: AsyncRead, Io: AsyncWrite, {error} {}
impl<T> Clone for UnboundedSender<T> {}
impl<B> Clone for SendRequest<B> where B: IntoBuf {}
impl<T> Clone for ConnectServiceFactory<T> {}
impl<T> Clone for Iter<T> {}
impl<T> Clone for IntoIter<T> where T: Clone {}
impl<T, S, F, E> Clone for TransformMapInitErr<T, S, F, E> where T: Clone, F: Clone {}
impl Clone for _IP_ADAPTER_WINS_SERVER_ADDRESS_LH {}
impl<T> Clone for NodeToHandle<T> {}
impl<T> Clone for Message<T> where T: Head {}
impl<T> Clone for RawIter<T> {}
impl<T> Clone for Iter<T> {}
impl<T, S> Clone for Difference<T, S> {}
impl<T, A, B> Clone for AndThenTransform<T, A, B> where A: Clone, B: Clone {}
impl<A, B> Clone for Then<A, B> where A: Clone {}
impl<A, E> Clone for FromErr<A, E> where A: Clone {}
impl<T, F, In, Out> Clone for ApplyNewService<T, F, In, Out> where T: NewService, T: Clone, F: FnMut<{unknown}>, Out: IntoFuture {}
impl<R, Rsdr> Clone for ReseedingRng<R, Rsdr> where R: BlockRngCore, R: SeedableRng, R: Clone, Rsdr: RngCore, Rsdr: Clone {}
impl Clone for Level {}
impl<K, V> Clone for ParKeys<K, V> {}
impl<K, V> Clone for Iter<K, V> {}
impl Clone for _IP_ADAPTER_WINS_SERVER_ADDRESS_LH__bindgen_ty_1 {}
impl Clone for JitterRng {}
impl<T, P> Clone for PrivateIter<T, P> {}
impl<A, B> Clone for Either<A, B> where A: Clone, B: Clone {}
impl<K, V> Clone for Values<K, V> {}
impl Clone for Map<String, Value> {}
impl<T> Clone for Rc<T> {}
impl Clone for LevelFilter {}
impl<I, U, F> Clone for FlatMap<I, U, F> where I: Clone, U: Clone, U: IntoIterator, F: Clone, <U as IntoIterator>::IntoIter: Clone {}
impl Clone for _IP_ADAPTER_PREFIX_XP {}
impl<K, V, S> Clone for ParValues<K, V, S> {}
impl<T> Clone for RawTable<T> where T: Clone {}
impl<K, V> Clone for Iter<K, V> {}
impl Clone for _SOCKET_ADDRESS {}
impl Clone for ResolveErrorKind {}
struct UnixStream;
struct KeepAlive<R, E, F>;
struct AndThen<A, B>;
struct AppRoutingFactory;
struct TestBuffer;
struct AppEntry;
struct SslStream<S>;
struct BlankNewService<R, E1, E2>;
struct Either<A, B>;
struct Clock;
struct ResourceFactory;
struct OpensslConnector<T, U>;
struct ResourceEndpoint;
struct Io<T>;
struct AndThenNewService<A, B>;
trait Handler {
type Timeout;
type Message;
}
struct RustlsConnector<T, U>;
struct Rc<T>;
struct TcpConnectorFactory<T>;
struct Literals;
struct AndThenTransform<T, A, B>;
trait Future {
type Item;
type Error;
}
impl Future for Delay {
type Item = ();
type Error = {unknown};
}
impl<H> Future for RetrySendFuture<H> where H: DnsHandle {
type Item = DnsResponse;
type Error = ProtoError;
}
impl<F> Future for OneshotDnsResponseReceiver<F> where F: Future, <F as Future>::Item = DnsResponse, <F as Future>::Error = ProtoError, F: Send {
type Item = <F as Future>::Item;
type Error = ProtoError;
}
impl<A, E> Future for FromErrFuture<A, E> where A: Service, E: From<{unknown}> {
type Item = {unknown};
type Error = E;
}
impl<A, B, F, Out> Future for AndThenApplyFuture<A, B, F, Out> where A: Service, B: Service, <B as Service>::Error = {unknown}, F: FnMut<{unknown}>, Out: IntoFuture, {unknown}: Into<{unknown}> {
type Item = {unknown};
type Error = {unknown};
}
impl<MF> Future for UdpClientConnect<MF> where MF: MessageFinalizer {
type Item = UdpClientStream<MF>;
type Error = ProtoError;
}
impl<C> Future for QueryState<C> where C: DnsHandle, {error} {
type Item = Lookup;
type Error = ResolveError;
}
impl<C> Future for LookupFuture<C> where C: DnsHandle, {error} {
type Item = Lookup;
type Error = ResolveError;
}
impl<T, B> Future for ReadPreface<T, B> where T: AsyncRead, B: Buf {
type Item = Codec<T, B>;
type Error = Error;
}
impl Future for NextRandomUdpSocket {
type Item = UdpSocket;
type Error = Error;
}
impl Future for CreateRouteService {
type Item = RouteService;
type Error = ();
}
impl Future for HttpMessageBody {
type Item = Bytes;
type Error = PayloadError;
}
impl<A> Future for Shutdown<A> where {error} {
type Item = A;
type Error = Error;
}
impl<R, W> Future for Copy<R, W> where {error}, {error} {
type Item = (u64, R, W);
type Error = Error;
}
impl<A, F, Response> Future for MapFuture<A, F, Response> where A: Service, F: FnMut<{unknown}> {
type Item = Response;
type Error = {unknown};
}
impl Future for SrvLookupFuture {
type Item = SrvLookup;
type Error = ResolveError;
}
impl<R, S, E> Future for FnNewServiceConfigFut<R, S, E> where R: IntoFuture, <R as IntoFuture>::Error = E, {unknown}: IntoService<S>, S: Service {
type Item = S;
type Error = {unknown};
}
impl<F, B> Future for ServiceResponse<F, B> where F: Future, {unknown}: Into<Error>, {unknown}: Into<Response<B>>, B: MessageBody, {error} {
type Item = ();
type Error = ();
}
impl<T, Io1, Io2> Future for InnerConnectorResponseB<T, Io1, Io2> where T: Service, <T as Service>::Request = Connect, <T as Service>::Response = (Io2, Protocol), <T as Service>::Error = ConnectError, T: Clone, {error}, Io1: AsyncRead, Io1: AsyncWrite, {error}, Io2: AsyncRead, Io2: AsyncWrite, {error} {
type Item = EitherConnection<Io1, Io2>;
type Error = ConnectError;
}
impl<S> Future for InOrderServiceResponse<S> where S: Service {
type Item = {unknown};
type Error = InOrderError<{unknown}>;
}
impl<T, S> Future for ExtractResponse<T, S> where T: FromRequest, S: Service, <S as Service>::Request = (T, HttpRequest), <S as Service>::Response = ServiceResponse<Body>, <S as Service>::Error = Infallible {
type Item = ServiceResponse<Body>;
type Error = (Error, ServiceRequest);
}
impl<T, B> Future for Handshake<T, B> where T: AsyncRead, T: AsyncWrite, B: IntoBuf, {error} {
type Item = (SendRequest<B>, Connection<T, B>);
type Error = Error;
}
impl<S, B> Future for LoggerResponse<S, B> where B: MessageBody, S: Service, <S as Service>::Request = ServiceRequest, <S as Service>::Response = ServiceResponse<B>, <S as Service>::Error = Error {
type Item = ServiceResponse<StreamLog<B>>;
type Error = Error;
}
impl<S> Future for Concat<S> where S: Stream, {unknown}: Extend<<<S as Stream>::Item as IntoIterator>::Item>, {unknown}: IntoIterator {
type Item = {unknown};
type Error = {unknown};
}
impl<A, F, E> Future for MapInitErrFuture<A, F, E> where A: NewService, F: Fn<{unknown}> {
type Item = {unknown};
type Error = E;
}
impl Future for Driver {
type Item = ();
type Error = ();
}
impl<A, B> Future for ThenNewServiceFuture<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 Item = Then<{unknown}, {unknown}>;
type Error = {unknown};
}
impl Future for Worker {
type Item = ();
type Error = ();
}
impl Future for Signals {
type Item = ();
type Error = ();
}
impl<C, P> Future for TrySend<C, P> where C: DnsHandle, {error}, P: ConnectionProvider, <P as ConnectionProvider>::ConnHandle = C, {error} {
type Item = DnsResponse;
type Error = ProtoError;
}
impl<S> Future for ConnectAsync<S> where S: Read, S: Write {
type Item = SslStream<S>;
type Error = HandshakeError<S>;
}
impl<C> Future for LookupIpFuture<C> where C: DnsHandle, {error} {
type Item = LookupIp;
type Error = ResolveError;
}
impl<T> Future for ResolverFuture<T> where T: Address {
type Item = Connect<T>;
type Error = ConnectError;
}
impl<T> Future for ConnectServiceResponse<T> where T: Address {
type Item = Connection<T, TcpStream>;
type Error = ConnectError;
}
impl<U> Future for JsonBody<U> where U: DeserializeOwned, {error} {
type Item = U;
type Error = JsonPayloadError;
}
impl<F, S, R> Future for DnsExchangeConnectInner<F, S, R> where F: Future, <F as Future>::Item = S, <F as Future>::Error = ProtoError, {error}, F: Send, S: DnsRequestSender, <S as DnsRequestSender>::DnsResponseFuture = R, R: Future, <R as Future>::Item = DnsResponse, <R as Future>::Error = ProtoError, {error}, R: Send {
type Item = DnsExchange<S, R>;
type Error = ProtoError;
}
impl<IO> Future for Accept<IO> where IO: AsyncRead, IO: AsyncWrite {
type Item = TlsStream<IO, ServerSession>;
type Error = Error;
}
impl Future for DnsMultiplexerSerialResponseInner {
type Item = DnsResponse;
type Error = ProtoError;
}
impl<T, P, S, B> Future for H2ServiceResponse<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 Item = H2ServiceHandler<T, P, {unknown}, B>;
type Error = {unknown};
}
impl<T> Future for CloseConnection<T> where T: AsyncWrite {
type Item = ();
type Error = ();
}
impl<F, Io> Future for OpenWaitingConnection<F, Io> where F: Future, <F as Future>::Item = (Io, Protocol), <F as Future>::Error = ConnectError, Io: AsyncRead, Io: AsyncWrite {
type Item = ();
type Error = ();
}
impl<I, B> Future for SendBody<I, B> where I: ConnectionLifetime, B: MessageBody {
type Item = Framed<I, ClientCodec>;
type Error = SendRequestError;
}
impl<T, S, E> Future for TransformFromErrFuture<T, S, E> where T: Transform<S>, E: From<{unknown}> {
type Item = {unknown};
type Error = E;
}
impl Future for ListServicesFuture {
type Item = ListServices;
type Error = ResolveError;
}
impl<T> Future for OpensslConnectServiceResponse<T> where T: Address {
type Item = SslStream<TcpStream>;
type Error = ConnectError;
}
impl<B> Future for ReadySendRequest<B> where B: IntoBuf, {error} {
type Item = SendRequest<B>;
type Error = Error;
}
impl Future for TcpClientConnect {
type Item = TcpClientStream<TcpStream>;
type Error = ProtoError;
}
impl<S, R> Future for DnsExchange<S, R> where S: DnsRequestSender, <S as DnsRequestSender>::DnsResponseFuture = R, R: Future, <R as Future>::Item = DnsResponse, <R as Future>::Error = ProtoError, {error}, R: Send {
type Item = ();
type Error = ProtoError;
}
impl Future for PushedResponseFuture {
type Item = Response<{unknown}>;
type Error = Error;
}
impl<T, P, S, B, X, U> Future for HttpServiceResponse<T, P, S, B, X, U> where T: IoStream, S: NewService, <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>::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>::Request = (Request<Box<dyn Stream<Item = Bytes, Error = PayloadError>>>, Framed<T, Codec>), <U as NewService>::Response = (), {unknown}: Display, {unknown}: Debug {
type Item = HttpServiceHandler<T, P, {unknown}, B, {unknown}, {unknown}>;
type Error = ();
}
impl<T> Future for Deadline<T> where T: Future {
type Item = {unknown};
type Error = DeadlineError<{unknown}>;
}
impl<F, S, MF> Future for DnsMultiplexerConnect<F, S, MF> where F: Future, <F as Future>::Item = S, <F as Future>::Error = ProtoError, F: Send, {error}, S: DnsClientStream, {error}, MF: MessageFinalizer, MF: Send, MF: Sync, {error} {
type Item = DnsMultiplexer<S, MF, Box<{unknown}>>;
type Error = ProtoError;
}
impl<T, S, B> Future for H2ServiceHandlerResponse<T, 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 {
type Item = ();
type Error = DispatchError;
}
impl<A> Future for Supervisor<A> where A: Supervised, A: Actor, <A as Actor>::Context = Context<A> {
type Item = ();
type Error = ();
}
impl<T> Future for ResponseFuture<T> where T: Future, <T as Future>::Item = Response<Body>, {unknown}: Into<Error> {
type Item = Response<Body>;
type Error = Error;
}
impl<F, C, T, R, S> Future for ApplyConfigNewServiceFut<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 Item = S;
type Error = {unknown};
}
impl<A, F, Res> Future for MapNewServiceFuture<A, F, Res> where A: NewService, F: FnMut<{unknown}> {
type Item = Map<{unknown}, F, Res>;
type Error = {unknown};
}
impl<A, B, F, Out> Future for AndThenApplyNewServiceFuture<A, B, F, Out> where A: NewService, B: NewService, <B as NewService>::Error = {unknown}, <B as NewService>::InitError = {unknown}, F: FnMut<{unknown}>, Out: IntoFuture, {unknown}: Into<{unknown}> {
type Item = AndThenApply<{unknown}, {unknown}, F, Out>;
type Error = {unknown};
}
impl<T, B> Future for AppInitResult<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 Item = AppInitService<{unknown}, B>;
type Error = ();
}
impl<F> Future for StreamDispatcherService<F> where F: Future {
type Item = ();
type Error = ();
}
impl<T, U> Future for ConnectAsyncExt<T, U> where T: Address, U: AsyncRead, U: AsyncWrite, U: Debug {
type Item = Connection<T, SslStream<U>>;
type Error = HandshakeError<U>;
}
impl<S, T> Future for Transport<S, T> where T: AsyncRead, T: AsyncWrite, S: Service, <S as Service>::Request = Frame, <S as Service>::Response = Message, {error}, {error} {
type Item = ();
type Error = FramedTransportError<{unknown}, Codec>;
}
impl<T> Future for Receiver<T> {
type Item = T;
type Error = RecvError;
}
impl Future for DnsMultiplexerSerialResponse {
type Item = DnsResponse;
type Error = ProtoError;
}
impl<T, B> Future for Handshake<T, B> where B: IntoBuf, T: AsyncRead, T: AsyncWrite, B: IntoBuf {
type Item = Connection<T, B>;
type Error = Error;
}
impl<T> Future for Timeout<T> where T: Future {
type Item = {unknown};
type Error = Error<{unknown}>;
}
impl<S, T> Future for StreamDispatcher<S, T> where S: Stream, T: Service, <T as Service>::Request = Result<<S as IntoStream>::Item, <S as IntoStream>::Error>, <T as Service>::Response = (), {error} {
type Item = ();
type Error = {unknown};
}
impl Future for SingleUseUdpSocket {
type Item = DnsResponse;
type Error = ProtoError;
}
impl Future for ArbiterController {
type Item = ();
type Error = ();
}
impl Future for DriverTask {
type Item = ();
type Error = ();
}
impl<T> Future for TimeoutServiceResponse<T> where T: Service {
type Item = {unknown};
type Error = TimeoutError<{unknown}>;
}
impl<F, S, R> Future for DnsExchangeConnect<F, S, R> where F: Future, <F as Future>::Item = S, <F as Future>::Error = ProtoError, {error}, F: Send, S: DnsRequestSender, <S as DnsRequestSender>::DnsResponseFuture = R, R: Future, <R as Future>::Item = DnsResponse, <R as Future>::Error = ProtoError, {error}, R: Send {
type Item = DnsExchange<S, R>;
type Error = ProtoError;
}
impl<T> Future for OneRequestServiceResponse<T> where T: IoStream {
type Item = (Request<Box<dyn Stream<Item = Bytes, Error = PayloadError>>>, Framed<T, Codec>);
type Error = ParseError;
}
impl<A, B> Future for EitherNewService<A, B> where A: NewService, B: NewService, <B as NewService>::Response = {unknown}, <B as NewService>::Error = {unknown}, <B as NewService>::InitError = {unknown} {
type Item = EitherService<{unknown}, {unknown}>;
type Error = {unknown};
}
impl<T, P> Future for RustlsAcceptorServiceFut<T, P> where T: AsyncRead, T: AsyncWrite {
type Item = Io<TlsStream<T, ServerSession>, P>;
type Error = Error;
}
impl<Io> Future for WaitForConnection<Io> where Io: AsyncRead, Io: AsyncWrite {
type Item = IoConnection<Io>;
type Error = ConnectError;
}
impl Future for Task {
type Item = ();
type Error = ();
}
impl<T, S> Future for ApplyTransformFuture<T, S> where S: NewService, T: Transform<{unknown}>, <T as Transform<{unknown}>>::InitError = {unknown} {
type Item = {unknown};
type Error = {unknown};
}
impl Future for ConnectFuture {
type Item = TcpStream;
type Error = Error;
}
impl<T, U> Future for ConnectAsyncExt<T, U> where T: Address, U: AsyncRead, U: AsyncWrite, U: Debug {
type Item = Connection<T, TlsStream<U, ClientSession>>;
type Error = Error;
}
impl<A> Future for ReadToEnd<A> where {error} {
type Item = (A, Vec<u8>);
type Error = Error;
}
impl Future for ServiceInfoFuture {
type Item = ServiceInfo;
type Error = ResolveError;
}
impl Future for ServerBuilder {
type Item = ();
type Error = ();
}
impl<A, F, E> Future for MapErrNewServiceFuture<A, F, E> where A: NewService, F: Fn<{unknown}> {
type Item = MapErr<{unknown}, F, E>;
type Error = {unknown};
}
impl<T, S, B, X, U> Future for HttpServiceHandlerResponse<T, 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, 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 Item = ();
type Error = DispatchError;
}
impl Future for CreateResourceService {
type Item = ResourceService;
type Error = ();
}
impl Future for ConnectFuture {
type Item = UnixStream;
type Error = Error;
}
impl<T, F, In, Out> Future for ApplyNewServiceFuture<T, F, In, Out> where T: NewService, F: FnMut<{unknown}>, Out: IntoFuture, {unknown}: From<{unknown}> {
type Item = Apply<{unknown}, F, In, Out>;
type Error = {unknown};
}
impl<A, T> Future for WriteAll<A, T> where {error}, T: AsRef<[u8]> {
type Item = (A, T);
type Error = Error;
}
impl<A> Future for Flush<A> where {error} {
type Item = A;
type Error = Error;
}
impl<R, S> Future for FnNewServiceConfigFut<R, S> where R: IntoFuture, {unknown}: IntoService<S>, S: Service {
type Item = S;
type Error = {unknown};
}
impl Future for UdpResponse {
type Item = DnsResponse;
type Error = ProtoError;
}
impl Future for FromCache {
type Item = Option<Lookup>;
type Error = ResolveError;
}
impl Future for SystemArbiter {
type Item = ();
type Error = ();
}
impl Future for Shutdown {
type Item = ();
type Error = ();
}
impl<U> Future for UrlEncoded<U> where U: DeserializeOwned, {error} {
type Item = U;
type Error = UrlencodedError;
}
impl<A, B> Future for EitherResponder<A, B> where A: Future, <A as Future>::Item = Response<Body>, {unknown}: Into<Error>, B: Future, <B as Future>::Item = Response<Body>, {unknown}: Into<Error> {
type Item = Response<Body>;
type Error = Error;
}
impl<IO, S> Future for MidHandshake<IO, S> where IO: Read, IO: Write, S: Session {
type Item = TlsStream<IO, S>;
type Error = Error;
}
impl Future for ResponseFuture {
type Item = Response<{unknown}>;
type Error = Error;
}
impl Future for ConnectionHandleResponseInner {
type Item = DnsResponse;
type Error = ProtoError;
}
impl<S> Future for SrvPoll<S> where S: Service {
type Item = ();
type Error = ();
}
impl<T> Future for TcpConnectorResponse<T> where T: Address {
type Item = Connection<T, TcpStream>;
type Error = ConnectError;
}
impl<T, S, B, X, U> Future for Dispatcher<T, 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 Item = ();
type Error = DispatchError;
}
impl Future for ScopeFactoryResponse {
type Item = ScopeService;
type Error = ();
}
impl<T, A, B> Future for AndThenTransformFuture<T, A, B> where A: NewService, B: NewService, <B as NewService>::InitError = {unknown}, T: Transform<{unknown}>, <T as Transform<{unknown}>>::Request = {unknown}, <T as Transform<{unknown}>>::InitError = {unknown}, {unknown}: From<{unknown}> {
type Item = AndThen<FromErr<{unknown}, {unknown}>, {unknown}>;
type Error = {unknown};
}
impl Future for ConnectFutureState {
type Item = TcpStream;
type Error = Error;
}
impl<A, E> Future for FromErrNewServiceFuture<A, E> where A: NewService, E: From<{unknown}> {
type Item = FromErr<{unknown}, E>;
type Error = {unknown};
}
impl<T> Future for RecvDgram<T> where T: AsMut<[u8]> {
type Item = (UdpSocket, T, usize, SocketAddr);
type Error = Error;
}
impl Future for VerifyRrsetsFuture {
type Item = DnsResponse;
type Error = ProtoError;
}
impl Future for Local {
type Item = DnsResponse;
type Error = ProtoError;
}
impl<T, Io1, Io2> Future for InnerConnectorResponseA<T, Io1, Io2> where T: Service, <T as Service>::Request = Connect, <T as Service>::Response = (Io1, Protocol), <T as Service>::Error = ConnectError, T: Clone, {error}, Io1: AsyncRead, Io1: AsyncWrite, {error}, Io2: AsyncRead, Io2: AsyncWrite, {error} {
type Item = EitherConnection<Io1, Io2>;
type Error = ConnectError;
}
impl<A> Future for SyncArbiter<A> where A: Actor, <A as Actor>::Context = SyncContext<A> {
type Item = ();
type Error = ();
}
impl<F, G> Future for Background<F, G> where F: Future, <F as Future>::Error = ResolveError, G: Future, <G as Future>::Error = ResolveError, Either<AndThen<MapErr<Receiver<F>, fn(Canceled) -> ResolveError>, G, fn(F) -> G>, FutureResult<{unknown}, ResolveError>>: Future, <Either<AndThen<MapErr<Receiver<F>, fn(Canceled) -> ResolveError>, G, fn(F) -> G>, FutureResult<{unknown}, ResolveError>> as Future>::Item = {unknown}, <Either<AndThen<MapErr<Receiver<F>, fn(Canceled) -> ResolveError>, G, fn(F) -> G>, FutureResult<{unknown}, ResolveError>> as Future>::Error = ResolveError {
type Item = {unknown};
type Error = ResolveError;
}
impl<T, B> Future for SendResponse<T, B> where T: AsyncRead, T: AsyncWrite, B: MessageBody {
type Item = Framed<T, Codec>;
type Error = Error;
}
impl<M> Future for RecipientRequest<M> where M: Message, M: Send, {error}, {unknown}: Send {
type Item = {unknown};
type Error = MailboxError;
}
impl Future for AppRoutingFactoryResponse {
type Item = AppRouting;
type Error = ();
}
impl<S> Future for ConcatSafe<S> where S: Stream, {unknown}: Extend<<<S as Stream>::Item as IntoIterator>::Item>, {unknown}: IntoIterator {
type Item = Option<{unknown}>;
type Error = {unknown};
}
impl<T> Future for SendDgram<T> where T: AsRef<[u8]> {
type Item = (UdpSocket, T);
type Error = Error;
}
impl<A, B> Future for ThenFuture<A, B> where A: Service, B: Service, <B as Service>::Request = Result<{unknown}, {unknown}> {
type Item = {unknown};
type Error = {unknown};
}
impl<A, T> Future for ReadExact<A, T> where {error}, T: AsMut<[u8]> {
type Item = (A, T);
type Error = Error;
}
impl<I, E> Future for CpuFuture<I, E> where E: Debug {
type Item = I;
type Error = BlockingError<E>;
}
impl Future for NextRandomUdpSocket {
type Item = Option<UdpSocket>;
type Error = Error;
}
impl<C> Future for QueryFuture<C> where C: DnsHandle, {error} {
type Item = Records;
type Error = ResolveError;
}
impl<T> Future for RecvDgram<T> where T: AsMut<[u8]> {
type Item = ({unknown}, T, usize, String);
type Error = Error;
}
impl<S, B> Future for CompressResponse<S, B> where B: MessageBody, S: Service, <S as Service>::Request = ServiceRequest, <S as Service>::Response = ServiceResponse<B>, <S as Service>::Error = Error {
type Item = ServiceResponse<Encoder<B>>;
type Error = Error;
}
impl<B> Future for SendBody<B> where B: MessageBody {
type Item = ();
type Error = SendRequestError;
}
impl<T> Future for AsyncHandlerServiceResponse<T> where T: Future, {unknown}: Responder, {unknown}: Into<Error> {
type Item = ServiceResponse<Body>;
type Error = Infallible;
}
impl<IO> Future for Connect<IO> where IO: AsyncRead, IO: AsyncWrite {
type Item = TlsStream<IO, ClientSession>;
type Error = Error;
}
impl<R, T> Future for Read<R, T> where {error}, T: AsMut<[u8]> {
type Item = (R, T, usize);
type Error = Error;
}
impl Future for MdnsClientConnect {
type Item = MdnsClientStream;
type Error = ProtoError;
}
impl<T, P> Future for SendDgram<T, P> where T: AsRef<[u8]>, P: AsRef<Path> {
type Item = ({unknown}, T);
type Error = Error;
}
impl<T> Future for CustomResponderFut<T> where T: Responder {
type Item = Response<Body>;
type Error = {unknown};
}
impl<T, P> Future for Accept<T, P> where T: AsyncRead, T: AsyncWrite {
type Item = Io<TlsStream<T>, P>;
type Error = {unknown};
}
impl<F> Future for &mut F where F: Future {
type Item = {unknown};
type Error = {unknown};
}
impl<A, B> Future for AndThenFuture<A, B> where A: Service, B: Service, <B as Service>::Request = {unknown}, <B as Service>::Error = {unknown} {
type Item = {unknown};
type Error = {unknown};
}
impl<T, Io> Future for ConnectorPoolSupport<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, {error} {
type Item = ();
type Error = ();
}
impl Future for InsertCache {
type Item = Lookup;
type Error = ResolveError;
}
impl<A> Future for ReadUntil<A> where {error}, A: BufRead {
type Item = (A, Vec<u8>);
type Error = Error;
}
impl<A, M> Future for Request<A, M> where A: Handler<M>, {unknown}: ToEnvelope<A, M>, M: Message, M: Send, {unknown}: Send {
type Item = {unknown};
type Error = MailboxError;
}
impl<T, B> Future for Flush<T, B> where T: AsyncWrite, B: Buf {
type Item = Codec<T, B>;
type Error = Error;
}
impl<T, P> Future for OpensslAcceptorServiceFut<T, P> where T: AsyncRead, T: AsyncWrite {
type Item = Io<SslStream<T>, P>;
type Error = HandshakeError<T>;
}
impl<T> Future for HandlerServiceResponse<T> where T: Future, <T as Future>::Item = Response<Body>, {unknown}: Into<Error> {
type Item = ServiceResponse<Body>;
type Error = Infallible;
}
impl Future for ConnectionHandleResponse {
type Item = DnsResponse;
type Error = ProtoError;
}
impl<A, C> Future for ContextFut<A, C> where C: AsyncContextParts<A>, A: Actor, <A as Actor>::Context = C {
type Item = ();
type Error = ();
}
impl<A, B> Future for AndThenNewServiceFuture<A, B> where A: NewService, B: NewService, <B as NewService>::Request = {unknown}, <B as NewService>::Error = {unknown}, <B as NewService>::InitError = {unknown} {
type Item = AndThen<{unknown}, {unknown}>;
type Error = {unknown};
}
impl<S, T, U> Future for FramedTransport<S, T, U> where S: Service, <S as Service>::Request = <U as Decoder>::Item, <S as Service>::Response = <U as Encoder>::Item, {error}, {error}, T: AsyncRead, T: AsyncWrite, U: Decoder, U: Encoder, {error}, <U as Encoder>::Error: Debug {
type Item = ();
type Error = FramedTransportError<{unknown}, U>;
}
impl<F, Io> Future for OpenConnection<F, Io> where F: Future, <F as Future>::Item = (Io, Protocol), <F as Future>::Error = ConnectError, Io: AsyncRead, Io: AsyncWrite {
type Item = IoConnection<Io>;
type Error = ConnectError;
}
impl<T, S, B> Future for Dispatcher<T, 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 Item = ();
type Error = DispatchError;
}
impl<S> Future for AcceptAsync<S> where S: Read, S: Write {
type Item = SslStream<S>;
type Error = HandshakeError<S>;
}
impl<A, F, E> Future for MapErrFuture<A, F, E> where A: Service, F: Fn<{unknown}> {
type Item = {unknown};
type Error = E;
}
impl<T, S, F, E> Future for TransformMapInitErrFuture<T, S, F, E> where T: Transform<S>, F: Fn<{unknown}> {
type Item = {unknown};
type Error = E;
}
impl<T, B> Future for Connection<T, B> where T: AsyncRead, T: AsyncWrite, B: IntoBuf {
type Item = ();
type Error = Error;
}
impl<T> Future for InFlightServiceResponse<T> where T: Service {
type Item = {unknown};
type Error = {unknown};
}
impl<S> Future for Concat2<S> where S: Stream, {unknown}: Extend<<<S as Stream>::Item as IntoIterator>::Item>, {unknown}: IntoIterator, {unknown}: Default {
type Item = {unknown};
type Error = {unknown};
}
impl<T, P, S, B, X, U> Future for H1ServiceResponse<T, P, S, B, X, U> where T: IoStream, S: NewService, <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>::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>::Request = (Request<Box<dyn Stream<Item = Bytes, Error = PayloadError>>>, Framed<T, Codec>), <U as NewService>::Response = (), {unknown}: Display, {unknown}: Debug {
type Item = H1ServiceHandler<T, P, {unknown}, B, {unknown}, {unknown}>;
type Error = ();
}
impl<S> Future for Finish<S> where S: Stream {
type Item = ();
type Error = {unknown};
}
struct Cursor<T>;
struct TransformFromErr<T, S, E>;
struct Arc<T>;
struct FromErrNewService<A, E>;
trait Send {}
struct RouteNewService<T>;
struct ScopeFactory;
struct Query<T>;
struct ApplyTransform<T, S>;
struct Box<T>;
trait ToOwned {
type Owned;
}
impl<T> ToOwned for RsaRef<T> {
type Owned = Rsa<T>;
}
impl<C> ToOwned for UCStr<C> where C: UChar {
type Owned = UCString<C>;
}
impl ToOwned for {unknown} {
type Owned = {unknown};
}
impl<T> ToOwned for [T] where T: Clone {
type Owned = Vec<T>;
}
impl<C> ToOwned for UStr<C> where C: UChar {
type Owned = UString<C>;
}
impl ToOwned for OsStr {
type Owned = OsString;
}
impl ToOwned for str {
type Owned = String;
}
impl ToOwned for CStr {
type Owned = CString;
}
impl<T> ToOwned for EcKeyRef<T> {
type Owned = EcKey<T>;
}
impl<T> ToOwned for DsaRef<T> {
type Owned = Dsa<T>;
}
impl<T> ToOwned for T where T: Clone {
type Owned = T;
}
impl ToOwned for Path {
type Owned = PathBuf;
}
impl ToOwned for RawValue {
type Owned = Box<RawValue>;
}
impl ToOwned for {unknown} {
type Owned = {unknown};
}
struct ConnectServiceFactory<T>;
struct ScopeEndpoint;
struct MapInitErr<A, F, E>;
trait Park {
type Unpark;
type Error;
}
impl<T, N> Park for Timer<T, N> where T: Park, N: Now {
type Unpark = {unknown};
type Error = {unknown};
}
impl Park for Reactor {
type Unpark = Handle;
type Error = Error;
}
impl Park for ParkThread {
type Unpark = UnparkThread;
type Error = ParkError;
}
struct Route;
struct Sink;
struct LowResTime;
struct MapNewService<A, F, Res>;
struct OpensslConnectServiceFactory<T>;
struct MapErrNewService<A, F, E>;
struct Extract<T, S>;
struct Iter<T>;
struct ThenNewService<A, B>;
struct BufWriter<W>;
impl<T> IntoIterator for &mut VecDeque<T> {
type Item = &mut T;
type IntoIter = IterMut<T>;
}
impl IntoIterator for SrvLookup {
type Item = SRV;
type IntoIter = SrvLookupIntoIter;
}
impl<T> IntoIterator for &mut ThreadLocal<T> where T: Send, {error} {
type Item = &mut Box<T>;
type IntoIter = IterMut<T>;
}
impl<T> IntoIterator for &GetAll<T> {
type Item = &T;
type IntoIter = ValueIter<T>;
}
impl<T> IntoIterator for &mut Slab<T> {
type Item = (usize, &mut T);
type IntoIter = IterMut<T>;
}
impl<K, V> IntoIterator for &mut BTreeMap<K, V> where {error}, {error} {
type Item = (&K, &mut V);
type IntoIter = IterMut<K, V>;
}
impl<T, E> IntoIterator for &mut Result<T, E> {
type Item = &mut T;
type IntoIter = IterMut<T>;
}
impl IntoIterator for Events {
type Item = Event;
type IntoIter = IntoIter;
}
impl<T> IntoIterator for Stack<T> where T: Stackable {
type IntoIter = IntoIter<T>;
type Item = T;
}
impl IntoIterator for LookupIp {
type Item = IpAddr;
type IntoIter = LookupIpIntoIter;
}
impl<I> IntoIterator for I where I: Iterator {
type Item = {unknown};
type IntoIter = I;
}
impl<K, V, S> IntoIterator for &mut LruCache<K, V, S> where K: Eq, K: Hash, S: BuildHasher {
type Item = (&K, &mut V);
type IntoIter = IterMut<K, V>;
}
impl<A> IntoIterator for &mut SmallVec<A> where A: Array {
type IntoIter = {unknown};
type Item = &mut {unknown};
}
impl IntoIterator for &SparseSet {
type Item = &usize;
type IntoIter = Iter<usize>;
}
impl<T> IntoIterator for &OccupiedEntry<T> {
type Item = &T;
type IntoIter = ValueIter<T>;
}
impl<K, V, S> IntoIterator for &IndexMap<K, V, S> where K: Hash, K: Eq, S: BuildHasher {
type Item = (&K, &V);
type IntoIter = Iter<K, V>;
}
impl IntoIterator for &Bytes {
type Item = u8;
type IntoIter = Iter<Cursor<&Bytes>>;
}
impl<T> IntoIterator for &Option<T> {
type Item = &T;
type IntoIter = Iter<T>;
}
impl<T> IntoIterator for Receiver<T> {
type Item = T;
type IntoIter = IntoIter<T>;
}
impl<T, S> IntoIterator for &HashSet<T, S> {
type Item = &T;
type IntoIter = Iter<T>;
}
impl<T, P> IntoIterator for Punctuated<T, P> {
type Item = T;
type IntoIter = IntoIter<T, P>;
}
impl<T> IntoIterator for Receiver<T> {
type Item = T;
type IntoIter = IntoIter<T>;
}
impl IntoIterator for &mut Fields {
type Item = &mut Field;
type IntoIter = IterMut<Field>;
}
impl IntoIterator for &BytesMut {
type Item = u8;
type IntoIter = Iter<Cursor<&BytesMut>>;
}
impl<T> IntoIterator for VecDeque<T> {
type Item = T;
type IntoIter = IntoIter<T>;
}
impl<T> IntoIterator for &mut LinkedList<T> {
type Item = &mut T;
type IntoIter = IterMut<T>;
}
impl IntoIterator for &SetMatches {
type IntoIter = SetMatchesIter;
type Item = usize;
}
impl<T> IntoIterator for &Vec<T> {
type Item = &T;
type IntoIter = Iter<T>;
}
impl<T> IntoIterator for &mut Option<T> {
type Item = &mut T;
type IntoIter = IterMut<T>;
}
impl IntoIterator for &Events {
type Item = Event;
type IntoIter = Iter;
}
impl<T> IntoIterator for HeaderMap<T> {
type Item = (Option<HeaderName>, T);
type IntoIter = IntoIter<T>;
}
impl<K, V, S> IntoIterator for LruCache<K, V, S> where K: Eq, K: Hash, S: BuildHasher {
type Item = (K, V);
type IntoIter = IntoIter<K, V>;
}
impl<K, V, S> IntoIterator for &LinkedHashMap<K, V, S> where K: Hash, K: Eq, S: BuildHasher {
type Item = (&K, &V);
type IntoIter = Iter<K, V>;
}
impl<T, S> IntoIterator for &HashSet<T, S> {
type Item = &T;
type IntoIter = Iter<T>;
}
impl<T> IntoIterator for ThreadLocal<T> where T: Send {
type Item = Box<T>;
type IntoIter = IntoIter<T>;
}
impl<T> IntoIterator for &LinkedList<T> {
type Item = &T;
type IntoIter = Iter<T>;
}
impl<K, V> IntoIterator for BTreeMap<K, V> {
type Item = (K, V);
type IntoIter = IntoIter<K, V>;
}
impl IntoIterator for &Signals {
type Item = i32;
type IntoIter = Forever;
}
impl<K, V, S> IntoIterator for &HashMap<K, V, S> {
type Item = (&K, &V);
type IntoIter = Iter<K, V>;
}
impl IntoIterator for &HeaderMap {
type Item = (&HeaderName, &HeaderValue);
type IntoIter = Iter;
}
impl<T> IntoIterator for &mut StackRef<T> where T: Stackable {
type Item = &mut {unknown};
type IntoIter = IterMut<T>;
}
impl<T> IntoIterator for BinaryHeap<T> {
type Item = T;
type IntoIter = IntoIter<T>;
}
impl<T> IntoIterator for &[T] {
type Item = &T;
type IntoIter = Iter<T>;
}
impl IntoIterator for SetMatches {
type IntoIter = SetMatchesIntoIter;
type Item = usize;
}
impl<T> IntoIterator for &mut OccupiedEntry<T> {
type Item = &mut T;
type IntoIter = ValueIterMut<T>;
}
impl IntoIterator for Lookup {
type Item = RData;
type IntoIter = LookupIntoIter;
}
impl<K, V, S> IntoIterator for &mut IndexMap<K, V, S> where K: Hash, K: Eq, S: BuildHasher {
type Item = (&K, &mut V);
type IntoIter = IterMut<K, V>;
}
impl IntoIterator for &Path {
type Item = &OsStr;
type IntoIter = Iter;
}
impl IntoIterator for Bytes {
type Item = u8;
type IntoIter = Iter<Cursor<Bytes>>;
}
impl IntoIterator for &Utf8Sequence {
type IntoIter = Iter<Utf8Range>;
type Item = &Utf8Range;
}
impl<K, V, S> IntoIterator for &mut HashMap<K, V, S> {
type Item = (&K, &mut V);
type IntoIter = IterMut<K, V>;
}
impl<T> IntoIterator for CachedThreadLocal<T> where T: Send {
type Item = Box<T>;
type IntoIter = Chain<IntoIter<Box<T>>, IntoIter<T>>;
}
impl<T> IntoIterator for &HeaderMap<T> {
type Item = (&HeaderName, &T);
type IntoIter = Iter<T>;
}
impl<K, V, S> IntoIterator for HashMap<K, V, S> {
type Item = (K, V);
type IntoIter = IntoIter<K, V>;
}
impl<K, V, S> IntoIterator for LinkedHashMap<K, V, S> where K: Hash, K: Eq, S: BuildHasher {
type Item = (K, V);
type IntoIter = IntoIter<K, V>;
}
impl IntoIterator for BytesMut {
type Item = u8;
type IntoIter = Iter<Cursor<BytesMut>>;
}
impl IntoIterator for BitMask {
type Item = usize;
type IntoIter = BitMaskIter;
}
impl<T, S> IntoIterator for IndexSet<T, S> where T: Hash, T: Eq, S: BuildHasher {
type Item = T;
type IntoIter = IntoIter<T>;
}
impl<T> IntoIterator for &mut Stack<T> where T: Stackable {
type Item = &mut {unknown};
type IntoIter = IterMut<T>;
}
impl<T, S> IntoIterator for &HashSet<T, S> {
type Item = &T;
type IntoIter = Iter<T>;
}
impl<T> IntoIterator for &BTreeSet<T> {
type Item = &T;
type IntoIter = Iter<T>;
}
impl<T> IntoIterator for OccupiedEntry<T> {
type Item = &mut T;
type IntoIter = ValueIterMut<T>;
}
impl<T> IntoIterator for RawTable<T> {
type Item = T;
type IntoIter = RawIntoIter<T>;
}
impl IntoIterator for TokenStream {
type Item = TokenTree;
type IntoIter = TokenTreeIter;
}
impl IntoIterator for &mut Map<String, Value> {
type Item = (&String, &mut Value);
type IntoIter = IterMut;
}
impl IntoIterator for &Name {
type Item = &[u8];
type IntoIter = LabelIter;
}
impl<T> IntoIterator for &mut [T] {
type Item = &mut T;
type IntoIter = IterMut<T>;
}
impl IntoIterator for SetMatches {
type IntoIter = SetMatchesIntoIter;
type Item = usize;
}
impl<T> IntoIterator for &Slab<T> {
type Item = (usize, &T);
type IntoIter = Iter<T>;
}
impl<T, E> IntoIterator for &Result<T, E> {
type Item = &T;
type IntoIter = Iter<T>;
}
impl IntoIterator for BitMask {
type Item = usize;
type IntoIter = BitMaskIter;
}
impl<T, P> IntoIterator for &mut Punctuated<T, P> {
type Item = &mut T;
type IntoIter = IterMut<T>;
}
impl<A> IntoIterator for &SmallVec<A> where A: Array {
type IntoIter = {unknown};
type Item = &{unknown};
}
impl<T> IntoIterator for &Receiver<T> {
type Item = T;
type IntoIter = Iter<T>;
}
impl<T, S> IntoIterator for HashSet<T, S> {
type Item = T;
type IntoIter = IntoIter<T>;
}
impl<T> IntoIterator for LinkedList<T> {
type Item = T;
type IntoIter = IntoIter<T>;
}
impl<K, V, S> IntoIterator for &mut HashMap<K, V, S> {
type Item = (&K, &mut V);
type IntoIter = IterMut<K, V>;
}
impl<T> IntoIterator for Option<T> {
type Item = T;
type IntoIter = IntoIter<T>;
}
impl<T> IntoIterator for &Receiver<T> {
type Item = T;
type IntoIter = Iter<T>;
}
impl<T, S> IntoIterator for HashSet<T, S> {
type Item = T;
type IntoIter = IntoIter<T>;
}
impl IntoIterator for &Program {
type Item = &Inst;
type IntoIter = Iter<Inst>;
}
impl<T, P> IntoIterator for &Punctuated<T, P> {
type Item = &T;
type IntoIter = Iter<T>;
}
impl<T> IntoIterator for RawTable<T> {
type Item = T;
type IntoIter = RawIntoIter<T>;
}
impl<T> IntoIterator for &StackRef<T> where T: Stackable {
type Item = &{unknown};
type IntoIter = Iter<T>;
}
impl<T> IntoIterator for &VecDeque<T> {
type Item = &T;
type IntoIter = Iter<T>;
}
impl<T> IntoIterator for GetAll<T> {
type Item = &T;
type IntoIter = ValueIter<T>;
}
impl<K, V, S> IntoIterator for HashMap<K, V, S> {
type Item = (K, V);
type IntoIter = IntoIter<K, V>;
}
impl<T> IntoIterator for Vec<T> {
type Item = T;
type IntoIter = IntoIter<T>;
}
impl IntoIterator for Map<String, Value> {
type Item = (String, Value);
type IntoIter = IntoIter;
}
impl IntoIterator for RecordSet {
type Item = Record;
type IntoIter = Chain<IntoIter<Record>, IntoIter<Record>>;
}
impl<T> IntoIterator for &mut CachedThreadLocal<T> where T: Send, {error} {
type Item = &mut Box<T>;
type IntoIter = Chain<IntoIter<&mut Box<T>>, IterMut<T>>;
}
impl<K, V, S> IntoIterator for &HashMap<K, V, S> {
type Item = (&K, &V);
type IntoIter = Iter<K, V>;
}
impl IntoIterator for TokenStream {
type Item = TokenTree;
type IntoIter = IntoIter;
}
impl<K, V, S> IntoIterator for &LruCache<K, V, S> where K: Eq, K: Hash, S: BuildHasher {
type Item = (&K, &V);
type IntoIter = Iter<K, V>;
}
impl<K, V, S> IntoIterator for &mut LinkedHashMap<K, V, S> where K: Hash, K: Eq, S: BuildHasher {
type Item = (&K, &mut V);
type IntoIter = IterMut<K, V>;
}
impl<K, V> IntoIterator for &BTreeMap<K, V> where {error}, {error} {
type Item = (&K, &V);
type IntoIter = Iter<K, V>;
}
impl<T, E> IntoIterator for Result<T, E> {
type Item = T;
type IntoIter = IntoIter<T>;
}
impl IntoIterator for TokenStream {
type Item = TokenTree;
type IntoIter = IntoIter<TokenTree>;
}
impl<A> IntoIterator for SmallVec<A> where A: Array {
type IntoIter = IntoIter<A>;
type Item = {unknown};
}
impl<T, S> IntoIterator for &IndexSet<T, S> where T: Hash, T: Eq, S: BuildHasher {
type Item = &T;
type IntoIter = Iter<T>;
}
impl<T> IntoIterator for &Stack<T> where T: Stackable {
type Item = &{unknown};
type IntoIter = Iter<T>;
}
impl<T> IntoIterator for &BinaryHeap<T> {
type Item = &T;
type IntoIter = Iter<T>;
}
impl<T> IntoIterator for BTreeSet<T> {
type Item = T;
type IntoIter = IntoIter<T>;
}
impl IntoIterator for &SetMatches {
type IntoIter = SetMatchesIter;
type Item = usize;
}
impl<K, V, S> IntoIterator for &HashMap<K, V, S> {
type Item = (&K, &V);
type IntoIter = Iter<K, V>;
}
impl<T> IntoIterator for &mut Vec<T> {
type Item = &mut T;
type IntoIter = IterMut<T>;
}
impl<T, S> IntoIterator for HashSet<T, S> {
type Item = T;
type IntoIter = IntoIter<T>;
}
impl<K, V, S> IntoIterator for IndexMap<K, V, S> where K: Hash, K: Eq, S: BuildHasher {
type Item = (K, V);
type IntoIter = IntoIter<K, V>;
}
impl IntoIterator for &Fields {
type Item = &Field;
type IntoIter = Iter<Field>;
}
impl IntoIterator for &Map<String, Value> {
type Item = (&String, &Value);
type IntoIter = Iter;
}
impl IntoIterator for &PathBuf {
type Item = &OsStr;
type IntoIter = Iter;
}
impl<K, V, S> IntoIterator for HashMap<K, V, S> {
type Item = (K, V);
type IntoIter = IntoIter<K, V>;
}
impl<T> IntoIterator for &mut HeaderMap<T> {
type Item = (&HeaderName, &mut T);
type IntoIter = IterMut<T>;
}
impl<K, V, S> IntoIterator for &mut HashMap<K, V, S> {
type Item = (&K, &mut V);
type IntoIter = IterMut<K, V>;
}
trait IntoIterator {
type Item;
type IntoIter;
}
struct Wrapping<T>;
trait Write {}
impl<S> Write for SslStream<S> where S: Read, S: Write {}
impl<T, U> Write for Fuse<T, U> where T: Write {}
impl Write for StderrRaw {}
impl Write for AcceptOneThenFail {}
impl<R> Write for ZlibDecoder<R> where R: Read, R: Write {}
impl Write for &mut [u8] {}
impl Write for Verifier {}
impl<T> Write for FramedRead<T> where T: Write {}
impl Write for Writer {}
impl Write for &TcpStream {}
impl Write for Cursor<&mut [u8]> {}
impl Write for Formatter {}
impl<R> Write for MultiGzDecoder<R> where R: BufRead, R: Write {}
impl Write for &PipeWriter {}
impl<W> Write for EncoderWriter<W> where W: Write {}
impl Write for &UnixStream {}
impl<T> Write for WriteHalf<T> where {error} {}
impl Write for Good {}
impl Write for Sink {}
impl Write for &UnixStream {}
impl<W> Write for DeflateEncoder<W> where W: BufRead, W: Write {}
impl Write for &TcpStream {}
impl Write for &NamedPipe {}
impl Write for Socket {}
impl<W> Write for Box<W> where W: Write {}
impl<W, R> Write for InterruptingWriter<W, R> where W: Write, {error} {}
impl Write for Io {}
impl<B> Write for Writer<B> where {error}, B: Sized {}
impl Write for &TcpStream {}
impl<W> Write for NoColor<W> where W: Write {}
impl<S> Write for TlsStream<S> where S: Read, S: Write {}
impl<W> Write for DeflateEncoder<W> where W: Read, W: Write {}
impl<W> Write for BrotliDecoder<W> where W: Write {}
impl<R> Write for GzDecoder<R> where R: BufRead, R: Write {}
impl Write for Signer {}
impl<R> Write for MultiGzDecoder<R> where R: Read, R: Write {}
impl<W> Write for WriterInnerLock<W> where W: Write {}
impl Write for TcpStream {}
impl Write for Bad {}
impl Write for Stderr {}
impl<W> Write for GzDecoder<W> where W: Write {}
impl Write for Socket {}
impl<T> Write for H1Connection<T> where T: AsyncRead, T: AsyncWrite, {error} {}
impl<W> Write for DeflateDecoder<W> where W: Read, W: Write {}
impl<W> Write for LineWriter<W> where W: Write {}
impl<W, D> Write for Writer<W, D> where W: Write, D: Ops {}
impl Write for &TcpStream {}
impl Write for WindowsBuffer {}
impl<W> Write for DeflateDecoder<W> where W: Write {}
impl<IO, S> Write for TlsStream<IO, S> where IO: Read, IO: Write, S: Session {}
impl Write for AnonWrite {}
impl Write for Stdout {}
impl Write for &Socket {}
impl Write for Vec<u8> {}
impl Write for &File {}
impl Write for IoStandardStream {}
impl<W> Write for BufWriter<W> where W: Write {}
impl<W> Write for WriterInner<W> where W: Write {}
impl Write for Cursor<Box<[u8]>> {}
impl<W> Write for Ansi<W> where W: Write {}
impl Write for UnixStream {}
impl<T, U> Write for Fuse<T, U> where T: Write {}
impl<W> Write for BrotliEncoder<W> where W: Write {}
impl Write for PipeWriter {}
impl Write for UnixStream {}
impl<R> Write for GzEncoder<R> where R: BufRead, R: Write {}
impl<W> Write for CrcWriter<W> where W: Write {}
impl Write for TestBuffer {}
impl<W> Write for &mut W where W: Write {}
impl Write for Writer {}
impl<S, T> Write for StreamOwned<S, T> where S: Session, T: Read, T: Write {}
impl Write for WriteEarlyData {}
impl<E> Write for &PollEvented<E> where E: Evented, &E: Write {}
impl<W> Write for GzEncoder<W> where W: Write {}
impl Write for ChildStdin {}
impl<W> Write for LossyStandardStream<W> where W: Write {}
impl<W> Write for Maybe<W> where W: Write {}
impl Write for &Io {}
impl<A, B> Write for EitherIo<A, B> where A: Write, B: Write {}
impl Write for BufferedStandardStream {}
impl Write for Cursor<&mut Vec<u8>> {}
impl Write for Hasher {}
impl Write for StdoutLock {}
impl<W> Write for DeflateDecoder<W> where W: BufRead, W: Write {}
impl<T> Write for Io<T> where T: Write {}
impl Write for Writer {}
impl<W> Write for ZlibDecoder<W> where W: Write {}
impl Write for ClientSession {}
impl Write for StdoutRaw {}
impl<T, U> Write for Fuse<T, U> where T: Write {}
impl<L, R> Write for Either<L, R> where L: Write, R: Write {}
impl Write for Box<dyn {error} + Send> {}
impl Write for NamedPipe {}
impl Write for &TcpStream {}
impl Write for &Socket {}
impl<W, R> Write for PartialInterruptingWriter<W, R> where W: Write, {error} {}
impl Write for StandardStreamLock {}
impl<W> Write for ZlibEncoder<W> where W: Write {}
impl<R> Write for ZlibEncoder<R> where R: BufRead, R: Write {}
impl<R> Write for GzDecoder<R> where R: Read, R: Write {}
impl<W> Write for DeflateEncoder<W> where W: Write {}
impl<W> Write for ZlibEncoder<W> where W: Read, W: Write {}
impl Write for &AnonWrite {}
impl Write for TcpStream {}
impl Write for Writer {}
impl<R> Write for GzEncoder<R> where R: Read, R: Write {}
impl Write for IoStandardStreamLock {}
impl Write for File {}
impl<S> Write for SslStream<S> where S: Read, S: Write {}
impl<S, T> Write for Stream<S, T> where {error}, S: Session, {error}, T: Read, T: Write {}
impl<E> Write for PollEvented<E> where E: Evented, E: Write {}
impl Write for Cursor<Vec<u8>> {}
impl Write for StderrLock {}
impl Write for TcpStream {}
impl Write for RW {}
impl Write for UnixStream {}
impl Write for ServerSession {}
impl Write for UnixSocket {}
impl Write for WriterFormatter {}
impl<T> Write for AllowStdIo<T> where T: Write {}
impl Write for StandardStream {}
impl<R> Write for ZlibDecoder<R> where R: BufRead, R: Write {}
impl<S, IO> Write for Stream<S, IO> where S: Session, IO: Read, IO: Write {}
impl Write for Buffer {}
struct ConnectAddrsIter;
trait Deref {
type Target;
}
impl<G, T> Deref for MapGuard<G, T> {
type Target = T;
}
impl Deref for SslCipher {
type Target = SslCipherRef;
}
impl<T> Deref for DynGuard<T> {
type Target = T;
}
impl<T, F, S> Deref for ScopeGuard<T, F, S> where S: Strategy, F: FnMut<{unknown}> {
type Target = T;
}
impl<O, T> Deref for OwningRef<O, T> {
type Target = T;
}
impl<T> Deref for Stack<T> where T: Stackable {
type Target = StackRef<T>;
}
impl<T> Deref for RefMut<T> {
type Target = T;
}
impl<T> Deref for MutexGuard<T> {
type Target = T;
}
impl<T> Deref for ConstantDeref<T> {
type Target = T;
}
impl<T, U> Deref for Connection<T, U> {
type Target = U;
}
impl Deref for BytesMut {
type Target = [u8];
}
impl<C> Deref for UString<C> where C: UChar {
type Target = UStr<C>;
}
impl Deref for IoVec {
type Target = [u8];
}
impl<T> Deref for Arc<T> {
type Target = T;
}
impl Deref for Ptr {
type Target = Stream;
}
impl<T> Deref for Guard<T> where T: RefCnt {
type Target = T;
}
impl Deref for VaList {
type Target = VaListImpl;
}
impl<T> Deref for &mut T {
type Target = T;
}
impl<T> Deref for IsaacArray<T> {
type Target = [T;_];
}
impl<T> Deref for CacheAligned<T> {
type Target = T;
}
impl Deref for ByteInput {
type Target = [u8];
}
impl Deref for UnixReady {
type Target = Ready;
}
impl Deref for TsSeconds {
type Target = NaiveDateTime;
}
impl<T> Deref for Reference<T> where {error} {
type Target = T;
}
impl<T> Deref for PeekMut<T> where T: Ord {
type Target = T;
}
impl<T, P> Deref for Io<T, P> {
type Target = T;
}
impl Deref for PathBuf {
type Target = Path;
}
impl Deref for IoSlice {
type Target = [u8];
}
impl Deref for CharInput {
type Target = [u8];
}
impl<T> Deref for BiLockGuard<T> {
type Target = T;
}
impl<S> Deref for UniCase<S> {
type Target = S;
}
impl<T> Deref for DirectDeref<Arc<T>> {
type Target = T;
}
impl<T> Deref for RwLockWriteGuard<T> {
type Target = T;
}
impl<T> Deref for Path<T> {
type Target = T;
}
impl<T> Deref for SpinlockGuard<T> {
type Target = T;
}
impl Deref for CString {
type Target = CStr;
}
impl<T> Deref for RwLockReadGuard<T> {
type Target = T;
}
impl<C> Deref for Sender<C> {
type Target = C;
}
impl<T> Deref for String<T> where T: AsRef<[u8]> {
type Target = {unknown};
}
impl<S> Deref for Ascii<S> {
type Target = S;
}
impl Deref for DnsResponse {
type Target = Message;
}
impl<T> Deref for Rc<T> {
type Target = T;
}
impl<B> Deref for Cow<B> where B: ToOwned {
type Target = B;
}
impl<T> Deref for Vec<T> {
type Target = [T];
}
impl Deref for Bytes {
type Target = [u8];
}
impl Deref for Key {
type Target = str;
}
impl Deref for DeltaCookie {
type Target = Cookie;
}
impl<C> Deref for Receiver<C> {
type Target = C;
}
impl<T> Deref for Message<T> where T: Head {
type Target = T;
}
impl Deref for SslConnectorBuilder {
type Target = SslContextBuilder;
}
impl Deref for Program {
type Target = [Inst];
}
impl<T> Deref for SharedItem<T> {
type Target = T;
}
impl<O, H> Deref for OwningHandle<O, H> where O: StableDeref, H: Deref {
type Target = {unknown};
}
impl Deref for BoxedResponseHead {
type Target = ResponseHead;
}
impl Deref for ByteStr {
type Target = {unknown};
}
impl<T> Deref for BiLockAcquired<T> {
type Target = T;
}
impl<T> Deref for Ref<T> where {error} {
type Target = T;
}
impl Deref for Timestamp {
type Target = SystemTime;
}
impl<O, T> Deref for OwningRefMut<O, T> {
type Target = T;
}
impl Deref for SslAcceptorBuilder {
type Target = SslContextBuilder;
}
impl Deref for StepCursor {
type Target = Cursor;
}
impl Deref for SparseSet {
type Target = [usize];
}
impl<T> Deref for RwLockWriteGuard<T> {
type Target = T;
}
impl<T> Deref for ManuallyDrop<T> {
type Target = T;
}
impl Deref for IoSliceMut {
type Target = [u8];
}
impl Deref for ZoneUsage {
type Target = Name;
}
impl<T> Deref for FromRawArc<T> {
type Target = T;
}
impl Deref for Wtf8Buf {
type Target = Wtf8;
}
impl<T> Deref for Form<T> {
type Target = T;
}
impl Deref for DigestBytes {
type Target = [u8];
}
impl<P> Deref for Pin<P> where P: Deref {
type Target = {unknown};
}
impl<T> Deref for ReentrantMutexGuard<T> {
type Target = T;
}
impl Deref for Duration {
type Target = Duration;
}
impl<T> Deref for RwLockReadGuard<T> {
type Target = T;
}
impl Deref for DnsRequest {
type Target = Message;
}
impl Deref for OsString {
type Target = OsStr;
}
impl<T> Deref for DontDrop<T> {
type Target = T;
}
impl<T> Deref for &T {
type Target = T;
}
impl<T> Deref for Ref<T> {
type Target = T;
}
impl Deref for String {
type Target = {unknown};
}
impl Deref for NameServerConfigGroup {
type Target = Vec<NameServerConfig>;
}
impl<L, R> Deref for Either<L, R> where L: Deref, R: Deref, <R as Deref>::Target = {unknown} {
type Target = {unknown};
}
impl Deref for RegistrationInner {
type Target = ReadinessNode;
}
impl Deref for Literal {
type Target = Vec<u8>;
}
impl<T> Deref for Query<T> {
type Target = T;
}
impl Deref for {unknown} {
type Target = {unknown};
}
impl<T> Deref for LockGuard<T> {
type Target = T;
}
impl<T> Deref for DirectDeref<Rc<T>> {
type Target = T;
}
impl<Tz> Deref for TsSeconds<Tz> where Tz: TimeZone {
type Target = DateTime<Tz>;
}
impl<T> Deref for ComPtr<T> where T: Interface {
type Target = T;
}
impl Deref for FuchsiaReady {
type Target = Ready;
}
impl<T> Deref for Data<T> {
type Target = T;
}
impl<C> Deref for UCString<C> where C: UChar {
type Target = UCStr<C>;
}
impl<T, F, S> Deref for ScopeGuard<T, F, S> where F: FnOnce<{unknown}>, S: Strategy {
type Target = T;
}
impl Deref for ConnectConfiguration {
type Target = {unknown};
}
impl<T> Deref for Json<T> {
type Target = T;
}
impl<E> Deref for SharedError<E> {
type Target = E;
}
impl Deref for Message {
type Target = Header;
}
impl<T> Deref for AssertUnwindSafe<T> {
type Target = T;
}
struct InFlightService<S>;
trait Session {}
impl Session for ClientSession {}
impl Session for ServerSession {}
struct IsaacCore;
trait SampleUniform {
type Sampler;
}
impl SampleUniform for Duration {
type Sampler = UniformDuration;
}
struct RangeFull;
trait RawRwLock {
type GuardMarker;
}
impl RawRwLock for RawRwLock {
type GuardMarker = GuardNoSend;
}
struct TlsStream<S>;
trait LockStorage {
type Shards;
}
impl<S> LockStorage for PrivateSharded<S> where S: AsRef<[Shard]>, S: Default {
type Shards = S;
}
impl LockStorage for Global {
type Shards = [Shard;_];
}
impl LockStorage for PrivateUnsharded {
type Shards = [Shard;_];
}
struct Ipv4Addr;
struct Fuse<T, U>;
trait DnsHandle {
type Response;
}
impl DnsHandle for MockDnsHandle {
type Response = Box<dyn Future<Item = DnsResponse, Error = ProtoError> + Send>>;
}
impl DnsHandle for TestClient {
type Response = Box<dyn Future<Item = DnsResponse, Error = ProtoError> + Send>>;
}
impl DnsHandle for MockDnsHandle {
type Response = Box<dyn Future<Item = DnsResponse, Error = ProtoError> + Send>>;
}
impl<H> DnsHandle for SecureDnsHandle<H> where H: DnsHandle {
type Response = Box<dyn Future<Item = DnsResponse, Error = ProtoError> + Send>>;
}
impl<F> DnsHandle for BufDnsRequestStreamHandle<F> where F: Future, <F as Future>::Item = DnsResponse, <F as Future>::Error = ProtoError, F: Send, {error} {
type Response = OneshotDnsResponseReceiver<F>;
}
impl<H> DnsHandle for RetryDnsHandle<H> where H: DnsHandle, {error} {
type Response = Box<dyn Future<Item = DnsResponse, Error = ProtoError> + Send>>;
}
impl<C, P> DnsHandle for LookupEither<C, P> where C: DnsHandle, P: ConnectionProvider, <P as ConnectionProvider>::ConnHandle = C {
type Response = Box<dyn Future<Item = DnsResponse, Error = ProtoError> + Send>>;
}
impl DnsHandle for ConnectionHandle {
type Response = ConnectionHandleResponse;
}
impl<C, P> DnsHandle for NameServer<C, P> where C: DnsHandle, P: ConnectionProvider, <P as ConnectionProvider>::ConnHandle = C {
type Response = Box<dyn Future<Item = DnsResponse, Error = ProtoError> + Send>>;
}
impl DnsHandle for ConnectionHandleConnected {
type Response = ConnectionHandleResponseInner;
}
impl DnsHandle for BasicDnsHandle {
type Response = Box<dyn Future<Item = DnsResponse, Error = ProtoError> + Send>>;
}
impl<C, P> DnsHandle for NameServerPool<C, P> where C: DnsHandle, {error}, P: ConnectionProvider, <P as ConnectionProvider>::ConnHandle = C, {error} {
type Response = Box<dyn Future<Item = DnsResponse, Error = ProtoError> + Send>>;
}
struct LexError;
trait GetThreadId {}
impl GetThreadId for RawThreadId {}
trait MessageBody {}
impl MessageBody for Body {}
impl<B> MessageBody for Encoder<B> where B: MessageBody {}
impl<T> MessageBody for Box<T> where T: MessageBody {}
impl MessageBody for &[u8] {}
impl MessageBody for BytesMut {}
impl<S> MessageBody for SizedStream<S> where S: Stream, <S as Stream>::Item = Bytes, <S as Stream>::Error = Error {}
impl MessageBody for Vec<u8> {}
impl MessageBody for &str {}
impl<B> MessageBody for ResponseBody<B> where B: MessageBody {}
impl MessageBody for () {}
impl<S, E> MessageBody for BodyStream<S, E> where S: Stream, <S as Stream>::Item = Bytes, <S as Stream>::Error = E, E: Into<Error> {}
impl<B> MessageBody for StreamLog<B> where B: MessageBody {}
impl MessageBody for String {}
impl MessageBody for Bytes {}
struct EitherIo<A, B>;
trait Read {}
impl Read for dyn RngCore {}
impl Read for UnixStream {}
impl Read for &File {}
impl Read for Socket {}
impl Read for Io {}
impl Read for ChildStderr {}
impl Read for TcpStream {}
impl<R> Read for GzDecoder<R> where R: BufRead {}
impl<T> Read for AllowStdIo<T> where T: Read {}
impl<R> Read for &mut R where R: Read {}
impl Read for File {}
impl<R> Read for ZlibDecoder<R> where R: BufRead {}
impl Read for TcpStream {}
impl<W> Read for GzDecoder<W> where W: Read, W: Write {}
impl Read for StdinRaw {}
impl Read for Socket {}
impl<R> Read for CrcReader<R> where R: Read {}
impl Read for &[u8] {}
impl<T> Read for Cursor<T> where T: AsRef<[u8]> {}
impl<R> Read for DeflateDecoder<R> where R: Read {}
impl Read for PipeReader {}
impl<B> Read for Reader<B> where {error}, B: Sized {}
impl<R> Read for BrotliEncoder<R> where R: BufRead {}
impl<R> Read for GzEncoder<R> where R: Read {}
impl<S> Read for SslStream<S> where S: Read, S: Write {}
impl<T> Read for Io<T> where T: Read {}
impl<R> Read for ZlibEncoder<R> where R: BufRead {}
impl<T, U> Read for Chain<T, U> where T: Read, U: Read {}
impl<S, T> Read for Stream<S, T> where {error}, S: Session, {error}, T: Read, T: Write {}
impl<E> Read for PollEvented<E> where E: Evented, E: Read {}
impl Read for ClientSession {}
impl Read for &TcpStream {}
impl Read for Repeat {}
impl Read for UnixStream {}
impl Read for AnonRead {}
impl<R> Read for DeflateEncoder<R> where R: BufRead {}
impl Read for &NamedPipe {}
impl<S, IO> Read for Stream<S, IO> where S: Session, IO: Read, IO: Write {}
impl<T> Read for Take<T> where T: Read {}
impl<T> Read for FramedWrite2<T> where T: Read {}
impl<R> Read for GzEncoder<R> where R: Read, R: Write {}
impl Read for &UnixStream {}
impl Read for ByteRead {}
impl Read for ShortReader {}
impl Read for &TcpStream {}
impl<R> Read for BrotliDecoder<R> where R: BufRead {}
impl<A, B> Read for EitherIo<A, B> where A: Read, B: Read {}
impl<R> Read for MultiGzDecoder<R> where R: Read {}
impl<R> Read for BufReader<R> where R: Read {}
impl Read for &TcpStream {}
impl Read for TcpStream {}
impl<R> Read for Maybe<R> where R: Read {}
impl Read for ServerSession {}
impl Read for StdinLock {}
impl Read for &TcpStream {}
impl<T> Read for H1Connection<T> where T: AsyncRead, T: AsyncWrite, {error} {}
impl<R> Read for BufReader<R> where R: Read {}
impl<W> Read for ZlibDecoder<W> where W: Read, W: Write {}
impl<W> Read for DeflateDecoder<W> where W: Read, W: Write {}
impl<S> Read for SslStream<S> where S: Read, S: Write {}
impl Read for &UnixStream {}
impl<R> Read for MultiGzDecoder<R> where R: BufRead {}
impl<L, R> Read for Either<L, R> where L: Read, R: Read {}
impl<T, B> Read for FramedWrite<T, B> where T: Read {}
impl<W> Read for ZlibEncoder<W> where W: Read, W: Write {}
impl Read for &Socket {}
impl<T> Read for ReadHalf<T> where {error} {}
impl<S> Read for TlsStream<S> where S: Read, S: Write {}
impl<W> Read for DeflateEncoder<W> where W: Read, W: Write {}
impl<T, U> Read for Fuse<T, U> where T: Read {}
impl Read for UnixSocket {}
impl<R> Read for ZlibEncoder<R> where R: Read {}
impl<T> Read for Buffer<T> where T: Read {}
impl<R> Read for DeflateEncoder<R> where R: Read {}
impl Read for Good {}
impl<T> Read for Counter<T> where T: Read {}
impl Read for RW {}
impl Read for UnixStream {}
impl Read for &AnonRead {}
impl Read for {unknown} {}
impl<R> Read for BrotliEncoder<R> where R: Read {}
impl Read for TestBuffer {}
impl<R> Read for Box<R> where R: Read {}
impl Read for &Io {}
impl<T, B> Read for FramedWrite<T, B> where T: Read, B: IntoBuf {}
impl Read for ChildStdout {}
impl<T> Read for FramedWrite2<T> where T: Read {}
impl<T> Read for FramedWrite2<T> where T: Read {}
impl<IO, S> Read for TlsStream<IO, S> where IO: Read, IO: Write, S: Session {}
impl<T, U> Read for Fuse<T, U> where T: Read {}
impl Read for &PipeReader {}
impl<R> Read for DeflateDecoder<R> where R: BufRead {}
impl<R> Read for ZlibDecoder<R> where R: Read {}
impl Read for &TcpStream {}
impl Read for Bad {}
impl Read for Empty {}
impl Read for Stdin {}
impl<R> Read for GzEncoder<R> where R: BufRead {}
impl<T, U> Read for Fuse<T, U> where T: Read {}
impl Read for NamedPipe {}
impl Read for &Socket {}
impl<R> Read for BrotliDecoder<R> where R: Read {}
impl<R> Read for GzDecoder<R> where R: Read {}
impl<E> Read for &PollEvented<E> where E: Evented, &E: Read {}
impl<S, T> Read for StreamOwned<S, T> where S: Session, T: Read, T: Write {}
trait Pattern {
type Searcher;
}
impl Pattern for char {
type Searcher = CharSearcher;
}
impl Pattern for &&str {}
impl Pattern for &str {
type Searcher = StrSearcher;
}
impl<C> Pattern for MultiCharEqPattern<C> where C: MultiCharEq {
type Searcher = MultiCharEqSearcher<C>;
}
impl Pattern for &String {
type Searcher = <&{unknown} as Pattern>::Searcher;
}
impl<F> Pattern for F where F: FnMut<{unknown}> {}
impl Pattern for &Regex {
type Searcher = RegexSearcher;
}
impl Pattern for &[char] {}
struct Stdio;
struct TlsStream<IO, S>;
struct InOrder<S>;
struct ClientSession;
struct String;
trait MessageFinalizer {}
impl MessageFinalizer for NoopMessageFinalizer {}
struct UdpBuilder;
struct InFlight;
trait Evented {}
impl Evented for UnixSocket {}
impl Evented for UnixStream {}
impl Evented for UnixSocket {}
impl Evented for PipeWriter {}
impl Evented for UnixStream {}
impl<T> Evented for Arc<T> where T: Evented {}
impl Evented for Awakener {}
impl Evented for ReceiverCtl {}
impl Evented for TcpListener {}
impl Evented for Registration {}
impl Evented for UnixListener {}
impl Evented for UnixListener {}
impl Evented for TcpStream {}
impl Evented for UdpSocket {}
impl Evented for UdpSocket {}
impl<T> Evented for Box<T> where T: Evented {}
impl Evented for Io {}
impl Evented for UdpSocket {}
impl Evented for TcpListener {}
impl Evented for UnixDatagram {}
impl<T> Evented for Receiver<T> {}
impl Evented for TcpStream {}
impl Evented for EventedFd {}
impl<T> Evented for Timer<T> {}
impl Evented for PipeReader {}
impl Evented for UdpSocket {}
impl Evented for TcpListener {}
impl Evented for Awakener {}
impl Evented for MyRegistration {}
impl Evented for Box<{unknown}> {}
impl Evented for SocketListener {}
impl Evented for TcpStream {}
struct TcpStream;
struct ServerSession;
struct StderrRaw;
struct Transitions;
trait Fail {}
impl Fail for Box<{unknown}> {}
impl<E> Fail for SyncFailure<E> where E: Error, E: Send, {error} {}
impl Fail for ResolveError {}
impl Fail for BoxStd {}
impl<D> Fail for ErrorMessage<D> where {error}, {error}, D: Sync, D: Send, {error} {}
impl<E> Fail for E where E: Error, E: Send, E: Sync, {error} {}
impl Fail for ProtoError {}
struct PipeWriter;
struct ClassInduct;
struct AcceptOneThenFail;
trait Buf {}
impl<B> Buf for Prioritized<B> where B: Buf {}
impl<T> Buf for Box<T> where T: Buf {}
impl Buf for {unknown} {}
impl<T> Buf for &mut T where T: Buf {}
impl Buf for Option<[u8;_]> {}
impl<T> Buf for Cursor<T> where T: AsRef<[u8]> {}
struct TimeoutError<E>;
struct UnixStream;
struct FromErr<A, E>;
struct File;
struct StreamService<S, T, E>;
trait SampleUniform {
type Sampler;
}
impl SampleUniform for Duration {
type Sampler = UniformDuration;
}
struct LowResTimeService;
trait RngCore {}
impl RngCore for ChaChaRng {}
impl RngCore for Mcg128Xsl64 {}
impl<R> RngCore for Box<R> where R: RngCore {}
impl RngCore for StepRng {}
impl<R> RngCore for BlockRng<R> where R: BlockRngCore, <R as BlockRngCore>::Item = u32, <R as BlockRngCore>::Results: AsRef<[u32]>, <R as BlockRngCore>::Results: AsMut<[u32]> {}
impl RngCore for Isaac64Rng {}
impl<R> RngCore for ReadRng<R> where R: Read {}
impl RngCore for Lcg64Xsh32 {}
impl<R> RngCore for &mut R where R: RngCore {}
impl RngCore for Hc128Rng {}
impl RngCore for IsaacRng {}
impl RngCore for XorShiftRng {}
impl<R, Rsdr> RngCore for ReseedingRng<R, Rsdr> where Rsdr: RngCore, R: BlockRngCore, <R as BlockRngCore>::Item = u32, R: SeedableRng, <R as BlockRngCore>::Results: AsRef<[u32]>, <R as BlockRngCore>::Results: AsMut<[u32]> {}
impl<R> RngCore for BlockRng64<R> where R: BlockRngCore, <R as BlockRngCore>::Item = u64, <R as BlockRngCore>::Results: AsRef<[u64]>, <R as BlockRngCore>::Results: AsMut<[u64]> {}
impl RngCore for EntropyRng {}
impl RngCore for JitterRng {}
impl RngCore for OsRng {}
impl<R> RngCore for TestRng<R> where R: RngCore {}
struct Lock<T>;
struct AsyncHandler<F, T, R>;
struct Program;
struct TcpStream;
trait RawMutex {
type GuardMarker;
}
impl RawMutex for RawMutex {
type GuardMarker = GuardNoSend;
}
struct Verifier;
struct FramedWrite2<T>;
struct Blank<R, E>;
trait TimeZone {
type Offset;
}
impl TimeZone for Utc {
type Offset = Utc;
}
impl TimeZone for FixedOffset {
type Offset = FixedOffset;
}
impl TimeZone for Local {
type Offset = FixedOffset;
}
struct RandomState;
struct FromErrFuture<A, E>;
struct Handler<F, T, R>;
struct NamedPipe;
struct ArgsOs;
struct FramedRead<T>;
struct Socket;
struct ServiceWrapper<T>;
struct TcpStream;
struct KeepAliveService<R, E, F>;
trait IntoBuf {
type Buf;
}
impl IntoBuf for Vec<u8> {
type Buf = Cursor<Vec<u8>>;
}
impl IntoBuf for u8 {
type Buf = Option<[u8;_]>;
}
impl IntoBuf for &[u8] {
type Buf = Cursor<&[u8]>;
}
impl IntoBuf for &&[u8] {
type Buf = Cursor<&[u8]>;
}
impl IntoBuf for &String {
type Buf = Cursor<&[u8]>;
}
impl IntoBuf for &str {
type Buf = Cursor<&[u8]>;
}
impl<T> IntoBuf for T where T: Buf {
type Buf = T;
}
impl IntoBuf for &Vec<u8> {
type Buf = Cursor<&[u8]>;
}
impl IntoBuf for i8 {
type Buf = Option<[u8;_]>;
}
impl IntoBuf for String {
type Buf = Cursor<Vec<u8>>;
}
impl IntoBuf for &mut [u8] {
type Buf = Cursor<&mut [u8]>;
}
impl IntoBuf for &&str {
type Buf = Cursor<&[u8]>;
}
struct Writer;
trait IntoService<T> {}
impl<F, Req, Out> IntoService<ServiceFn<F, Req, Out>> for F where F: FnMut<{unknown}>, Out: IntoFuture {}
impl<F, Req, Out, Cfg> IntoService<ServiceFn<F, Req, Out>> for NewServiceFn<F, Req, Out, Cfg> where F: FnMut<{unknown}>, Out: IntoFuture {}
impl<T> IntoService<T> for T where T: Service {}
struct Registration;
struct Io;
trait Copy {}
impl<T> Copy for *mut T {}
impl<T> Copy for Discriminant<T> {}
impl<T> Copy for *const T {}
impl<T> Copy for Unique<T> {}
impl<T> Copy for &T {}
impl<Node, Type> Copy for Handle<Node, Type> where Node: Copy {}
impl<Tz> Copy for Date<Tz> where Tz: TimeZone, <Tz as TimeZone>::Offset: Copy {}
impl<K, V, Type> Copy for NodeRef<Immut, K, V, Type> where {error}, {error} {}
impl<T> Copy for NonNull<T> {}
impl Copy for ! {}
impl<Tz> Copy for DateTime<Tz> where Tz: TimeZone, <Tz as TimeZone>::Offset: Copy {}
impl<Sz> Copy for ShortHash<Sz> {}
impl<T, U> Copy for Index<T, U> {}
struct MapErr<A, F, E>;
trait Responder {
type Error;
type Future;
}
impl<T> Responder for Form<T> where T: Serialize {
type Error = Error;
type Future = Result<Response<Body>, Error>;
}
impl Responder for () {
type Error = Error;
type Future = FutureResult<Response<Body>, Error>;
}
impl Responder for Bytes {
type Error = Error;
type Future = FutureResult<Response<Body>, Error>;
}
impl<A, B> Responder for Either<A, B> where A: Responder, B: Responder {
type Error = Error;
type Future = EitherResponder<<{unknown} as IntoFuture>::Future, <{unknown} as IntoFuture>::Future>;
}
impl<T> Responder for Json<T> where T: Serialize {
type Error = Error;
type Future = Result<Response<Body>, Error>;
}
impl<T> Responder for Option<T> where T: Responder {
type Error = {unknown};
type Future = Either<<{unknown} as IntoFuture>::Future, FutureResult<Response<Body>, {unknown}>>;
}
impl Responder for &str {
type Error = Error;
type Future = FutureResult<Response<Body>, Error>;
}
impl<T> Responder for InternalError<T> where T: Debug, T: Display, {error} {
type Error = Error;
type Future = Result<Response<Body>, Error>;
}
impl Responder for &String {
type Error = Error;
type Future = FutureResult<Response<Body>, Error>;
}
impl Responder for ResponseBuilder {
type Error = Error;
type Future = FutureResult<Response<Body>, Error>;
}
impl Responder for Response<Body> {
type Error = Error;
type Future = FutureResult<Response<Body>, Error>;
}
impl<T> Responder for (T, StatusCode) where T: Responder {
type Error = {unknown};
type Future = CustomResponderFut<T>;
}
impl<I, E> Responder for Box<dyn Future<Item = I, Error = E>> where I: Responder, {error}, E: Into<Error>, {error} {
type Error = Error;
type Future = Box<dyn Future<Item = Response<Body>, Error = Error>>;
}
impl Responder for BytesMut {
type Error = Error;
type Future = FutureResult<Response<Body>, Error>;
}
impl Responder for String {
type Error = Error;
type Future = FutureResult<Response<Body>, Error>;
}
impl<T> Responder for CustomResponder<T> where T: Responder {
type Error = {unknown};
type Future = CustomResponderFut<T>;
}
impl<T, E> Responder for Result<T, E> where T: Responder, E: Into<Error> {
type Error = Error;
type Future = Either<ResponseFuture<<{unknown} as IntoFuture>::Future>, FutureResult<Response<Body>, Error>>;
}
impl Responder for &[u8] {
type Error = Error;
type Future = FutureResult<Response<Body>, Error>;
}
struct Map<A, F, Response>;
struct IntoIter<T>;
trait GetThreadId {}
impl GetThreadId for RawThreadId {}
struct ChildStderr;
struct RwLock<T>;
struct Uri;
struct Socket;
struct IterMut<K, V>;
struct PollEvented<E>;
trait AsRef<T> {}
impl<C> AsRef<[C]> for UCString<C> where C: UChar {}
impl AsRef<[u8]> for BytesMut {}
impl AsRef<{unknown}> for {unknown} {}
impl AsRef<Path> for Iter {}
impl AsRef<{unknown}> for {unknown} {}
impl AsRef<SystemTime> for Timestamp {}
impl AsRef<OsStr> for PathBuf {}
impl AsRef<str> for str {}
impl AsRef<{unknown}> for Url {}
impl<T> AsRef<[T]> for IsaacArray<T> {}
impl<T> AsRef<[T]> for Array64<T> {}
impl AsRef<[u8]> for Bytes {}
impl AsRef<str> for Scheme {}
impl AsRef<Path> for Component {}
impl AsRef<Path> for String {}
impl AsRef<Path> for OsStr {}
impl AsRef<str> for HeaderName {}
impl AsRef<{unknown}> for {unknown} {}
impl<S> AsRef<str> for Ascii<S> where S: AsRef<str> {}
impl AsRef<[u8]> for PublicKey {}
impl AsRef<[u8]> for String {}
impl AsRef<[u8]> for HeaderValue {}
impl AsRef<OsStr> for OsString {}
impl AsRef<[u8]> for Document {}
impl<C> AsRef<UCStr<C>> for UCString<C> where C: UChar {}
impl AsRef<[u8]> for HeaderName {}
impl<L, R, Target> AsRef<Target> for Either<L, R> where L: AsRef<Target>, R: AsRef<Target> {}
impl AsRef<CStr> for CString {}
impl AsRef<[u8]> for DigestBytes {}
impl<C> AsRef<[C]> for UStr<C> where C: UChar {}
impl AsRef<Duration> for Duration {}
impl AsRef<{unknown}> for Authority {}
impl AsRef<{unknown}> for Method {}
impl AsRef<str> for DNSName {}
impl<T> AsRef<Vec<T>> for Vec<T> {}
impl AsRef<str> for Name {}
impl AsRef<[u8]> for Literal {}
impl<T> AsRef<str> for Port<T> where T: AsRef<str> {}
impl AsRef<Path> for OsString {}
impl AsRef<OsStr> for DefaultEnvKey {}
impl AsRef<[u8]> for Bytes {}
impl AsRef<[u8]> for {unknown} {}
impl AsRef<[u8;_]> for Block {}
impl AsRef<[u8]> for PublicKey {}
impl AsRef<OsStr> for String {}
impl AsRef<Path> for Components {}
impl AsRef<OsStr> for Component {}
impl AsRef<str> for Mime {}
impl<C> AsRef<UStr<C>> for UStr<C> where C: UChar {}
impl<T, U> AsRef<U> for &mut T where T: AsRef<U> {}
impl<T> AsRef<[T]> for Vec<T> {}
impl AsRef<[u8]> for Digest {}
impl AsRef<[u8]> for PublicKey {}
impl AsRef<[u8]> for Label {}
impl<A> AsRef<[{unknown}]> for SmallVec<A> where A: Array {}
impl AsRef<Path> for PathBuf {}
impl AsRef<[u8]> for TBS {}
impl<O, T> AsRef<T> for OwningRefMut<O, T> {}
impl AsRef<[u8]> for str {}
impl<T> AsRef<T> for Cow<T> where T: ToOwned {}
impl<C> AsRef<[C]> for UCStr<C> where C: UChar {}
impl AsRef<CStr> for CStr {}
impl<T> AsRef<StackRef<T>> for Stack<T> where T: Stackable {}
impl AsRef<str> for Key {}
impl<T> AsRef<T> for Arc<T> {}
impl AsRef<[u8]> for PublicKey {}
impl AsRef<Path> for str {}
impl AsRef<Path> for Path {}
impl<T> AsRef<[T]> for Iter<T> {}
impl AsRef<[u8]> for {unknown} {}
impl<T> AsRef<T> for Rc<T> {}
impl<T> AsRef<[u8]> for Window<T> where T: AsRef<[u8]> {}
impl AsRef<[u8]> for Certificate {}
impl AsRef<{unknown}> for String {}
impl AsRef<OsStr> for Iter {}
impl AsRef<OsStr> for OsStr {}
impl AsRef<[u8]> for PublicKey {}
impl AsRef<OsStr> for Components {}
impl<C> AsRef<UCStr<C>> for UCStr<C> where C: UChar {}
impl<C> AsRef<UStr<C>> for UString<C> where C: UChar {}
impl<T, U> AsRef<U> for &T where T: AsRef<U> {}
impl AsRef<Path> for Cow<OsStr> {}
impl<S> AsRef<str> for UniCase<S> where S: AsRef<str> {}
impl AsRef<OsStr> for Path {}
impl<T> AsRef<[T]> for [T] {}
impl AsRef<{unknown}> for Error {}
impl AsRef<[u8]> for Signature {}
impl AsRef<Channel> for Channel {}
impl AsRef<OsStr> for str {}
impl<T> AsRef<T> for Path<T> {}
impl<L, R, Target> AsRef<[Target]> for Either<L, R> where L: AsRef<[Target]>, R: AsRef<[Target]> {}
impl<M, E> AsRef<Elem<M, E>> for One<M, E> {}
impl<C> AsRef<[C]> for UString<C> where C: UChar {}
impl<O, T> AsRef<T> for OwningRef<O, T> {}
impl AsRef<{unknown}> for Url {}
impl AsRef<[u8]> for Signature {}
impl AsRef<[u8;_]> for Nonce {}
struct X509VerifyResult;
trait UChar {}
impl UChar for u16 {}
impl UChar for u32 {}
struct RouteService;
struct TcpStream;
struct Iter;
trait BufRead {}
impl BufRead for &[u8] {}
impl BufRead for Empty {}
impl<B> BufRead for &mut B where B: BufRead {}
impl<R> BufRead for BufReader<R> where R: Read {}
impl<L, R> BufRead for Either<L, R> where L: BufRead, R: BufRead {}
impl<B> BufRead for Reader<B> where {error}, B: Sized {}
impl<B> BufRead for Box<B> where B: BufRead {}
impl<T> BufRead for Cursor<T> where T: AsRef<[u8]> {}
impl<T, U> BufRead for Chain<T, U> where T: BufRead, U: BufRead {}
impl<R> BufRead for BufReader<R> where R: Read {}
impl<T> BufRead for Take<T> where T: BufRead {}
impl<R> BufRead for CrcReader<R> where R: BufRead {}
impl BufRead for StdinLock {}
struct Formatter;
struct ServerSessionImpl;
struct Utc;
struct RawEntryBuilderMut<K, V, S>;
struct AllowStdIo<T>;
struct UniCase<S>;
struct TrySendError<T>;
struct DefaultHeadersMiddleware<S>;
struct Error;
trait BuildHasher {
type Hasher;
}
impl<H> BuildHasher for BuildHasherDefault<H> where H: Default, H: Hasher {
type Hasher = H;
}
impl BuildHasher for RandomState {
type Hasher = DefaultHasher;
}
struct BTreeMap<K, V>;
struct Infallible;
trait Default {}
impl Default for CString {}
impl Default for Box<OsStr> {}
impl Default for ThreadRng {}
impl Default for ThreadRng {}
impl Default for ArrayToken {}
impl Default for RequestHead {}
impl Default for Stack {}
impl<T> Default for MessageDecoder<T> where T: MessageType {}
impl Default for Builder {}
impl<B> Default for Cow<B> where B: ToOwned, <B as ToOwned>::Owned: Default {}
impl<T> Default for Timer<T> {}
impl Default for BytesMut {}
impl<R, T> Default for Mutex<R, T> where R: RawMutex, T: Default {}
impl<T, S> Default for ArcSwapAny<T, S> where T: RefCnt, T: Default, S: LockStorage {}
impl Default for MatchKind {}
impl Default for PathBuf {}
impl Default for zx_packet_type_t {}
impl Default for TrustAnchor {}
impl Default for ThreadPool {}
impl Default for Condvar {}
impl<T> Default for Resolver<T> {}
impl Default for StatusCode {}
impl<T, S> Default for HashSet<T, S> where T: Eq, {error}, {error}, S: Default {}
impl Default for FloatRegisters {}
impl<T> Default for CachedThreadLocal<T> where T: Send {}
impl Default for OsString {}
impl<T> Default for BTreeSet<T> where T: Ord {}
impl Default for UCString<u32> {}
impl<T> Default for Weak<T> {}
impl Default for TranslatorBuilder {}
impl<T> Default for VecDeque<T> {}
impl<T> Default for Option<T> {}
impl Default for &str {}
impl Default for CompressorOxide {}
impl Default for AtomicBool {}
impl Default for Config {}
impl Default for Resolver {}
impl Default for Target {}
impl Default for KeyTrust {}
impl Default for PushPromiseFlag {}
impl Default for Env {}
impl Default for Config {}
impl<A> Default for SmallVec<A> where A: Array {}
impl<K, V, S> Default for HashMap<K, V, S> where {error}, S: Default {}
impl Default for NameServerStats {}
impl Default for Logger {}
impl<T, S> Default for HashSet<T, S> where T: Eq, {error}, {error}, S: Default {}
impl Default for DefaultHasher {}
impl<T> Default for Vec<T> {}
impl Default for &mut IoVec {}
impl Default for Condvar {}
impl Default for Once {}
impl Default for NameServerConfigGroup {}
impl<T> Default for FuturesOrdered<T> where {error} {}
impl<S> Default for InOrder<S> where S: Service, {error}, {error}, {error} {}
impl<R, T> Default for RwLock<R, T> where R: RawRwLock, T: Default {}
impl Default for Hasher {}
impl<T> Default for Array64<T> where T: Default {}
impl Default for Config {}
impl Default for SupportedAlgorithms {}
impl Default for Version {}
impl Default for Edns {}
impl Default for Decoder {}
impl Default for IdHasher {}
impl<T> Default for Arc<T> where T: Default {}
impl<K, V> Default for LinkedHashMapVisitor<K, V> {}
impl Default for SignalInfo {}
impl<T> Default for RefCell<T> where T: Default {}
impl<T> Default for TcpConnectorFactory<T> {}
impl<T> Default for Lock<T> where T: Default {}
impl Default for KeyUsage {}
impl Default for Condvar {}
impl Default for Node {}
impl<C> Default for Box<UStr<C>> where C: UChar {}
impl Default for Builder {}
impl<T> Default for MessageEncoder<T> where T: MessageType {}
impl Default for InFlight {}
impl Default for AhoCorasickBuilder {}
impl Default for Builder {}
impl Default for vec512_storage {}
impl Default for Value {}
impl<T> Default for Empty<T> {}
impl<R, T> Default for RwLock<R, T> where R: RawRwLock, T: Default {}
impl<C> Default for Box<UCStr<C>> where C: UChar {}
impl<T> Default for Path<T> where T: Default {}
impl Default for Builder {}
impl Default for ListToken {}
impl Default for &CStr {}
impl Default for Select {}
impl<T> Default for &mut [T] {}
impl Default for AtomicTask {}
impl Default for SigAction {}
impl<T> Default for RwLock<T> where T: Default {}
impl Default for FxHasher {}
impl Default for RareByteOffset {}
impl<R, G, T> Default for ReentrantMutex<R, G, T> where R: RawMutex, G: GetThreadId, T: Default {}
impl<T, S> Default for IndexSet<T, S> where S: BuildHasher, S: Default {}
impl Default for SpawnHandle {}
impl Default for DecompressorOxide {}
impl<K, V, S> Default for HashMap<K, V, S> where K: Eq, K: Hash, S: BuildHasher, S: Default {}
impl Default for UCString<u16> {}
impl Default for ResolverOpts {}
impl Default for vec256_storage {}
impl<K, V, S> Default for HashMap<K, V, S> where {error}, S: Default {}
impl Default for UpdateScope {}
impl<T> Default for Rc<T> where T: Default {}
impl Default for Buffer {}
impl Default for Compress {}
impl Default for LowResTime {}
impl Default for Builder {}
impl<T> Default for Response<T> where T: Default {}
impl<T> Default for ThreadLocal<T> where T: Send {}
impl<T> Default for Slab<T> {}
impl Default for HuffmanOxide {}
impl<T> Default for Cell<T> where T: Default {}
impl<S> Default for UniCase<S> where S: AsRef<str>, S: Default {}
impl Default for Handle {}
impl Default for Sha1 {}
impl Default for JsonConfig {}
impl Default for Bytes {}
impl<T> Default for Weak<T> {}
impl<K, V> Default for BTreeMap<K, V> where K: Ord {}
impl<R, G, T> Default for ReentrantMutex<R, G, T> where R: RawMutex, G: GetThreadId, T: Default {}
impl Default for Record {}
impl Default for Uri {}
impl Default for Protocol {}
impl<R, T> Default for Mutex<R, T> where R: RawMutex, T: Default {}
impl Default for DataFlags {}
impl Default for Builder {}
impl Default for Debt {}
impl Default for Arbiter {}
impl Default for TestRequest {}
impl Default for AppConfigInner {}
impl Default for State {}
impl<R, E> Default for Blank<R, E> {}
impl<T, P> Default for Punctuated<T, P> {}
impl Default for TestRequest {}
impl Default for Builder {}
impl Default for PrinterBuilder {}
impl Default for Build {}
impl Default for RegexOptions {}
impl Default for SpinWait {}
impl Default for PathConfig {}
impl<T> Default for UnsafeCell<T> where T: Default {}
impl Default for Method {}
impl Default for BigEndian {}
impl Default for PrinterBuilder {}
impl Default for FxHasher {}
impl Default for Once {}
impl Default for Header {}
impl Default for AcceptNotify {}
impl Default for HeadersFlag {}
impl<T> Default for LinkedList<T> {}
impl Default for FnvHasher {}
impl Default for &UCStr<u16> {}
impl Default for Timer<ParkThread, Clock> {}
impl Default for TokenStream {}
impl Default for Builder {}
impl Default for HashBuffers {}
impl Default for InflateState {}
impl<T> Default for Mocker<T> {}
impl Default for ClientCodec {}
impl Default for &OsStr {}
impl<T> Default for FuturesUnordered<T> where {error} {}
impl Default for &UCStr<u32> {}
impl Default for Config {}
impl Default for LookupIpStrategy {}
impl Default for Handle {}
impl<K, V, S> Default for IndexMap<K, V, S> where S: BuildHasher, S: Default {}
impl<H> Default for BuildHasherDefault<H> {}
impl<T> Default for RwLock<T> where T: Default {}
impl Default for Buffer {}
impl Default for Box<CStr> {}
impl<T> Default for AtomicPtr<T> {}
impl Default for Builder {}
impl Default for Peer {}
impl Default for Builder {}
impl Default for ResolverConfig {}
impl<R, G, T> Default for ReentrantMutex<R, G, T> where R: RawMutex, G: GetThreadId, T: Default {}
impl Default for EntropyRng {}
impl<T> Default for ConnectServiceFactory<T> {}
impl<R, E1, E2> Default for BlankNewService<R, E1, E2> {}
impl Default for Box<RawValue> {}
impl Default for Format {}
impl Default for RandomState {}
impl Default for Builder {}
impl Default for EntropyRng {}
impl<R, T> Default for Mutex<R, T> where R: RawMutex, T: Default {}
impl Default for ServiceConfig {}
impl Default for Condvar {}
impl Default for Codec {}
impl<T> Default for Condition<T> where T: Clone {}
impl Default for LocalBuf {}
impl<R, T> Default for RwLock<R, T> where R: RawRwLock, T: Default {}
impl Default for Query {}
impl Default for PrettyFormatter {}
impl<K, V, S> Default for LinkedHashMap<K, V, S> where K: Hash, K: Eq, S: BuildHasher, S: Default {}
impl Default for Map<String, Value> {}
impl Default for Builder {}
impl Default for Compression {}
impl Default for vec128_storage {}
impl<T> Default for AtomicCell<T> where T: Default {}
impl Default for QueryConfig {}
impl Default for &mut str {}
impl Default for ServerBuilder {}
impl Default for Backoff {}
impl<B> Default for ErrorHandlers<B> {}
impl Default for String {}
impl<T> Default for IsaacArray<T> where T: Copy, T: Default {}
impl<S> Default for Hasher<S> where S: Sip {}
impl Default for ParserBuilder {}
impl Default for WriteStyle {}
impl Default for FormConfig {}
impl<K> Default for CommandEnv<K> where K: EnvKey {}
impl<T> Default for Mutex<T> where T: Default {}
impl<T> Default for String<T> where T: Default, T: StableAsRef {}
impl Default for MatchKind {}
impl<A> Default for Mailbox<A> where A: Actor, {unknown}: AsyncContext<A> {}
impl Default for PathArguments {}
impl Default for DefaultHeaders {}
impl<T> Default for &[T] {}
impl Default for &IoVec {}
impl Default for Encoder {}
impl Default for EntropyRng {}
impl<T> Default for Mutex<T> where T: Default {}
impl Default for PayloadConfig {}
impl<T> Default for ResolverFactory<T> {}
impl<T, S> Default for HashSet<T, S> where T: Eq, T: Hash, S: BuildHasher, S: Default {}
impl<T> Default for HeaderMap<T> {}
impl Default for Once {}
impl Default for Quality {}
impl Default for LittleEndian {}
impl<T> Default for Stack<T> {}
impl<T> Default for Request<T> where T: Default {}
impl Default for Parsed {}
impl<T> Default for BinaryHeap<T> where T: Ord {}
impl Default for AtomicTask {}
struct Headers;
struct ValuesMut<K, V>;
struct ChildStdin;
trait Decoder {
type Item;
type Error;
}
impl<T, U> Decoder for Fuse<T, U> where U: Decoder {
type Item = {unknown};
type Error = {unknown};
}
impl<T> Decoder for FramedWrite2<T> where T: Decoder {
type Item = {unknown};
type Error = {unknown};
}
impl Decoder for Codec {
type Item = Frame;
type Error = ProtocolError;
}
impl<T, U> Decoder for Fuse<T, U> where U: Decoder {
type Item = {unknown};
type Error = {unknown};
}
impl Decoder for LinesCodec {
type Item = String;
type Error = Error;
}
impl<T, U> Decoder for Fuse<T, U> where U: Decoder {
type Item = {unknown};
type Error = {unknown};
}
impl Decoder for BytesCodec {
type Item = BytesMut;
type Error = Error;
}
impl<T> Decoder for MessageDecoder<T> where T: MessageType {
type Item = (T, PayloadType);
type Error = ParseError;
}
impl Decoder for ClientCodec {
type Item = ResponseHead;
type Error = ParseError;
}
impl Decoder for Decoder {
type Item = BytesMut;
type Error = Error;
}
impl<T> Decoder for FramedWrite2<T> where T: Decoder {
type Item = {unknown};
type Error = {unknown};
}
impl Decoder for BytesCodec {
type Item = BytesMut;
type Error = Error;
}
impl Decoder for Codec {
type Item = Message<Request<Box<dyn Stream<Item = Bytes, Error = PayloadError>>>>;
type Error = ParseError;
}
impl Decoder for BytesCodec {
type Item = BytesMut;
type Error = Error;
}
impl Decoder for PayloadDecoder {
type Item = PayloadItem;
type Error = Error;
}
impl Decoder for LinesCodec {
type Item = String;
type Error = Error;
}
impl Decoder for ClientPayloadCodec {
type Item = Option<Bytes>;
type Error = PayloadError;
}
impl<T> Decoder for FramedWrite2<T> where T: Decoder {
type Item = {unknown};
type Error = {unknown};
}
struct Error;
struct UdpSocket;
impl<T, D> Stream for FramedWrite<T, D> where T: Stream {
type Item = {unknown};
type Error = {unknown};
}
impl<T> Stream for Timeout<T> where T: Stream {
type Item = {unknown};
type Error = Error<{unknown}>;
}
impl<A> Stream for Lines<A> where {error}, A: BufRead {
type Item = String;
type Error = Error;
}
impl<S> Stream for BufferUnordered<S> where S: Stream, {error} {
type Item = {unknown};
type Error = <S as Stream>::Error;
}
impl Stream for Incoming {
type Item = TcpStream;
type Error = Error;
}
impl<F> Stream for IntoStream<F> where {error} {
type Item = {unknown};
type Error = {unknown};
}
impl<C> Stream for UdpFramed<C> where C: Decoder {
type Item = ({unknown}, SocketAddr);
type Error = {unknown};
}
impl<T, E> Stream for Empty<T, E> {
type Item = T;
type Error = E;
}
impl<S1, S2> Stream for Select<S1, S2> where S1: Stream, S2: Stream, <S2 as Stream>::Item = {unknown}, <S2 as Stream>::Error = {unknown} {
type Item = {unknown};
type Error = {unknown};
}
impl<T, D> Stream for FramedWrite<T, D> where T: Stream {
type Item = {unknown};
type Error = {unknown};
}
impl<T, E> Stream for Once<T, E> {
type Item = T;
type Error = E;
}
impl<T> Stream for Readlines<T> where T: HttpMessage, {unknown}: Stream, <{unknown} as Stream>::Item = Bytes, <{unknown} as Stream>::Error = PayloadError {
type Item = String;
type Error = ReadlinesError;
}
impl Stream for Payload {
type Item = Bytes;
type Error = PayloadError;
}
impl<T, B> Stream for Framed<T, B> where {error}, B: IntoBuf {
type Item = BytesMut;
type Error = Error;
}
impl<S> Stream for Fuse<S> where S: Stream {
type Item = {unknown};
type Error = {unknown};
}
impl<A, C> Stream for UnixDatagramFramed<A, C> where C: Decoder {
type Item = ({unknown}, {unknown});
type Error = {unknown};
}
impl<S1, S2> Stream for Merge<S1, S2> where S1: Stream, S2: Stream, <S2 as Stream>::Error = {unknown} {
type Item = MergedItem<{unknown}, {unknown}>;
type Error = {unknown};
}
impl<T> Stream for FramedRead2<T> where T: AsyncRead, T: Decoder {
type Item = {unknown};
type Error = {unknown};
}
impl Stream for UdpStream {
type Item = SerialMessage;
type Error = Error;
}
impl<T> Stream for FramedRead<T> where {error} {
type Item = BytesMut;
type Error = Error;
}
impl Stream for Event {
type Item = ();
type Error = Error;
}
impl<S> Stream for Flatten<S> where S: Stream, {unknown}: Stream, <{unknown} as Stream>::Error: From<{unknown}> {
type Item = <{unknown} as Stream>::Item;
type Error = <{unknown} as Stream>::Error;
}
impl<S, F, U> Stream for AndThen<S, F, U> where S: Stream, F: FnMut<{unknown}>, {error} {
type Item = {unknown};
type Error = {unknown};
}
impl<S, F, U> Stream for Map<S, F> where S: Stream, F: FnMut<{unknown}> {
type Item = U;
type Error = {unknown};
}
impl<S, MF> Stream for DnsMultiplexer<S, MF, Box<{unknown}>> where S: DnsClientStream, {error}, MF: MessageFinalizer, MF: Send, MF: Sync, {error} {
type Item = ();
type Error = ProtoError;
}
impl<S, F, U> Stream for MapErr<S, F> where S: Stream, F: FnMut<{unknown}> {
type Item = {unknown};
type Error = U;
}
impl Stream for Signal {
type Item = i32;
type Error = Error;
}
impl<I, T, E> Stream for IterResult<I> where I: Iterator, <I as Iterator>::Item = Result<T, E> {
type Item = T;
type Error = E;
}
impl<S> Stream for AssertUnwindSafe<S> where S: Stream {
type Item = {unknown};
type Error = {unknown};
}
impl<S, E> Stream for SinkFromErr<S, E> where S: Stream {
type Item = {unknown};
type Error = {unknown};
}
impl<S, F> Stream for Filter<S, F> where S: Stream, F: FnMut<{unknown}> {
type Item = {unknown};
type Error = {unknown};
}
impl<S> Stream for Skip<S> where S: Stream {
type Item = {unknown};
type Error = {unknown};
}
impl<T, E> Stream for Repeat<T, E> where T: Clone {
type Item = T;
type Error = E;
}
impl<S1, S2> Stream for Chain<S1, S2> where S1: Stream, S2: Stream, <S2 as Stream>::Item = {unknown}, <S2 as Stream>::Error = {unknown} {
type Item = {unknown};
type Error = {unknown};
}
impl<T, F, Fut, It> Stream for Unfold<T, F, Fut> where F: FnMut<{unknown}>, {error} {
type Item = It;
type Error = {unknown};
}
impl<S, P, R> Stream for TakeWhile<S, P, R> where S: Stream, P: FnMut<{unknown}>, {error} {
type Item = {unknown};
type Error = {unknown};
}
impl<S> Stream for Buffer<S> where S: Sink, S: Stream {
type Item = {unknown};
type Error = {unknown};
}
impl<S> Stream for Chunks<S> where S: Stream {
type Item = Vec<<S as Stream>::Item>;
type Error = <S as Stream>::Error;
}
impl<T, B> Stream for Connection<T, B> where T: AsyncRead, T: AsyncWrite, B: IntoBuf, {error} {
type Item = (Request<{unknown}>, SendResponse<B>);
type Error = Error;
}
impl<S> Stream for Decoder<S> where S: Stream, <S as Stream>::Item = Bytes, <S as Stream>::Error = PayloadError {
type Item = Bytes;
type Error = PayloadError;
}
impl<T, D> Stream for FramedRead<T, D> where {error}, D: Decoder {
type Item = {unknown};
type Error = {unknown};
}
impl<T, B> Stream for FramedWrite<T, B> where T: Stream, B: IntoBuf {
type Item = {unknown};
type Error = {unknown};
}
impl<S1, S2> Stream for Zip<S1, S2> where S1: Stream, S2: Stream, <S2 as Stream>::Error = {unknown} {
type Item = ({unknown}, {unknown});
type Error = {unknown};
}
impl<S> Stream for TcpStream<S> where S: AsyncRead, S: AsyncWrite {
type Item = SerialMessage;
type Error = Error;
}
impl<MF> Stream for UdpClientStream<MF> where MF: MessageFinalizer {
type Item = ();
type Error = ProtoError;
}
impl<S, P, R> Stream for SkipWhile<S, P, R> where S: Stream, P: FnMut<{unknown}>, {error} {
type Item = {unknown};
type Error = {unknown};
}
impl<S> Stream for Take<S> where S: Stream {
type Item = {unknown};
type Error = {unknown};
}
impl<F> Stream for FlattenStream<F> where {error}, {unknown}: Stream, <{unknown} as Stream>::Error = {unknown} {
type Item = <{unknown} as Stream>::Item;
type Error = <{unknown} as Stream>::Error;
}
impl<A> Stream for AddressReceiver<A> where A: Actor {
type Item = Envelope<A>;
type Error = ();
}
impl<S, F, B> Stream for FilterMap<S, F> where S: Stream, F: FnMut<{unknown}> {
type Item = B;
type Error = {unknown};
}
impl<T> Stream for UnboundedReceiver<T> {
type Item = T;
type Error = UnboundedRecvError;
}
impl<T, B> Stream for Codec<T, B> where T: AsyncRead {
type Item = Frame<Bytes>;
type Error = RecvError;
}
impl<T> Stream for FramedRead<T> where T: AsyncRead {
type Item = Frame<Bytes>;
type Error = RecvError;
}
impl Stream for Payload {
type Item = Bytes;
type Error = PayloadError;
}
impl<S, F, U> Stream for OrElse<S, F, U> where S: Stream, F: FnMut<{unknown}>, {error} {
type Item = {unknown};
type Error = {unknown};
}
impl<I, E> Stream for IterOk<I, E> where I: Iterator {
type Item = {unknown};
type Error = E;
}
impl<S> Stream for Peekable<S> where S: Stream {
type Item = {unknown};
type Error = {unknown};
}
impl<B> Stream for ResponseBody<B> where B: MessageBody {
type Item = Bytes;
type Error = Error;
}
impl<S, E> Stream for Results<S, E> where S: Stream {
type Item = Result<{unknown}, {unknown}>;
type Error = E;
}
impl<T> Stream for FramedRead2<T> where {error}, T: Decoder {
type Item = {unknown};
type Error = {unknown};
}
impl Stream for Incoming {
type Item = {unknown};
type Error = Error;
}
impl<T> Stream for Receiver<T> where T: Clone {
type Item = T;
type Error = RecvError;
}
impl<T, D> Stream for FramedWrite<T, D> where T: Stream {
type Item = {unknown};
type Error = {unknown};
}
impl<S, F, U> Stream for Then<S, F, U> where S: Stream, F: FnMut<{unknown}>, {error} {
type Item = {unknown};
type Error = {unknown};
}
impl<T> Stream for FramedRead2<T> where {error}, T: Decoder {
type Item = {unknown};
type Error = {unknown};
}
impl<S> Stream for Buffered<S> where S: Stream, {error} {
type Item = {unknown};
type Error = <S as Stream>::Error;
}
impl<S> Stream for TcpClientStream<S> where S: AsyncRead, S: AsyncWrite, S: Send {
type Item = SerialMessage;
type Error = ProtoError;
}
impl Stream for Payload {
type Item = Bytes;
type Error = PayloadError;
}
impl<T> Stream for DelayQueue<T> {
type Item = Expired<T>;
type Error = {unknown};
}
impl<S> Stream for Payload<S> where S: Stream, <S as Stream>::Item = Bytes, <S as Stream>::Error = PayloadError {
type Item = Bytes;
type Error = PayloadError;
}
impl<T, U> Stream for Framed<T, U> where {error}, U: Decoder {
type Item = {unknown};
type Error = {unknown};
}
impl<Io> Stream for PlStream<Io> where Io: ConnectionLifetime {
type Item = Bytes;
type Error = PayloadError;
}
impl<T> Stream for Throttle<T> where T: Stream {
type Item = {unknown};
type Error = ThrottleError<{unknown}>;
}
impl Stream for PushPromises {
type Item = PushPromise;
type Error = Error;
}
impl Stream for Interval {
type Item = Instant;
type Error = Error;
}
impl<S> Stream for &mut S where S: Stream {
type Item = {unknown};
type Error = {unknown};
}
impl<T> Stream for Receiver<T> {
type Item = T;
type Error = RecvError;
}
impl<S, E> Stream for FromErr<S, E> where S: Stream, E: From<{unknown}> {
type Item = {unknown};
type Error = E;
}
impl<S> Stream for CatchUnwind<S> where S: Stream, S: UnwindSafe {
type Item = Result<{unknown}, {unknown}>;
type Error = Box<dyn Any + Send>;
}
impl<T, D> Stream for FramedRead<T, D> where T: AsyncRead, D: Decoder {
type Item = {unknown};
type Error = {unknown};
}
impl<T, U> Stream for Framed<T, U> where T: AsyncRead, U: Decoder {
type Item = {unknown};
type Error = {unknown};
}
impl Stream for MdnsClientStream {
type Item = SerialMessage;
type Error = ProtoError;
}
impl<I, T, E> Stream for Iter<I> where I: Iterator, <I as Iterator>::Item = Result<T, E> {
type Item = T;
type Error = E;
}
impl Stream for RecvStream {
type Item = Bytes;
type Error = Error;
}
impl<S, U, F, Fut> Stream for With<S, U, F, Fut> where S: Stream, S: Sink, F: FnMut<{unknown}>, {error} {
type Item = {unknown};
type Error = {unknown};
}
impl<T, U> Stream for Framed<T, U> where {error}, U: Decoder {
type Item = {unknown};
type Error = {unknown};
}
impl Stream for MdnsStream {
type Item = SerialMessage;
type Error = Error;
}
impl<T, D> Stream for FramedRead<T, D> where {error}, D: Decoder {
type Item = {unknown};
type Error = {unknown};
}
impl<S, U, F, St> Stream for WithFlatMap<S, U, F, St> where S: Stream, S: Sink, F: FnMut<{unknown}>, St: Stream, <St as Stream>::Item = {unknown}, <St as Stream>::Error = {unknown} {
type Item = {unknown};
type Error = {unknown};
}
trait Stream {
type Item;
type Error;
}
struct BufferUnordered<S>;
struct Then<A, B>;
struct IntoParIter<T>;
struct SendError<T>;
struct AnonRead;
struct EncoderWriter<W>;
struct Path<T>;
struct SendError<T>;
struct ParseWeekdayError;
struct Path;
struct Literal;
struct Iter<K, V>;
struct FramedWrite<T, B>;
struct Value;
struct Stdin;
trait ConnectionLifetime {}
impl<T> ConnectionLifetime for H1Connection<T> where T: AsyncRead, T: AsyncWrite, {error} {}
struct Framed<T, U>;
struct ScopeService;
struct OsRng;
trait Array {
type Item;
}
struct AnonWrite;
trait Semaphore {
type Permit;
}
impl Semaphore for AtomicUsize {
type Permit = ();
}
impl Semaphore for (Semaphore, {unknown}) {
type Permit = Permit;
}
trait Serialize {}
impl<T> Serialize for RefCell<T> where T: Serialize {}
impl Serialize for OsString {}
impl<T> Serialize for Weak<T> where T: Serialize {}
impl<T> Serialize for [T] where T: Serialize {}
impl Serialize for Arguments {}
impl Serialize for SocketAddrV6 {}
impl Serialize for SystemTime {}
impl Serialize for Content {}
impl<T> Serialize for Cell<T> where T: Serialize, T: Copy {}
impl<T> Serialize for Bound<T> where T: Serialize {}
impl<T> Serialize for Option<T> where T: Serialize {}
impl Serialize for OsStr {}
impl Serialize for Ipv6Addr {}
impl<T> Serialize for RwLock<T> where T: Serialize {}
impl Serialize for Map<String, Value> {}
impl<T> Serialize for Reverse<T> where T: Serialize {}
impl<Idx> Serialize for RangeInclusive<Idx> where Idx: Serialize {}
impl Serialize for CString {}
impl Serialize for PathBuf {}
impl Serialize for RawValue {}
impl Serialize for Ipv4Addr {}
impl<T> Serialize for Mutex<T> where T: Serialize {}
impl Serialize for ! {}
impl<T> Serialize for [T;_] {}
impl Serialize for String {}
impl Serialize for SocketAddrV4 {}
impl Serialize for Duration {}
impl Serialize for Value {}
impl Serialize for Number {}
impl Serialize for () {}
impl<T> Serialize for PhantomData<T> {}
impl Serialize for str {}
impl Serialize for SocketAddr {}
impl<T, E> Serialize for Result<T, E> where T: Serialize, E: Serialize {}
impl<T> Serialize for Wrapping<T> where T: Serialize {}
impl<T> Serialize for Weak<T> where T: Serialize {}
impl<Idx> Serialize for Range<Idx> where Idx: Serialize {}
impl Serialize for CStr {}
impl Serialize for Path {}
impl Serialize for IpAddr {}
struct SourceFile;
struct PipeReader;
trait Factory<T, R> {}
impl<F, R> Factory<(), R> for F where F: Fn<{unknown}>, R: Responder {}
trait RngCore {}
impl<R> RngCore for ReadRng<R> where R: Read {}
impl<R> RngCore for Box<R> where R: RngCore {}
impl<R> RngCore for BlockRng<R> where R: BlockRngCore, <R as BlockRngCore>::Item = u32, <R as BlockRngCore>::Results: AsRef<[u32]>, <R as BlockRngCore>::Results: AsMut<[u32]> {}
impl RngCore for StdRng {}
impl RngCore for ThreadRng {}
impl<R, Rsdr> RngCore for ReseedingRng<R, Rsdr> where Rsdr: RngCore, R: BlockRngCore, <R as BlockRngCore>::Item = u32, R: SeedableRng, <R as BlockRngCore>::Results: AsRef<[u32]>, <R as BlockRngCore>::Results: AsMut<[u32]> {}
impl RngCore for SmallRng {}
impl RngCore for Hc128Rng {}
impl RngCore for EntropyRng {}
impl<R> RngCore for &mut R where R: RngCore {}
impl<R> RngCore for BlockRng64<R> where R: BlockRngCore, <R as BlockRngCore>::Item = u64, <R as BlockRngCore>::Results: AsRef<[u64]>, <R as BlockRngCore>::Results: AsMut<[u64]> {}
impl RngCore for StepRng {}
impl RngCore for OsRng {}
impl RngCore for OsRng {}
struct SessionID;
struct OwningRef<O, T>;
struct StdinRaw;
struct Never;
struct Good;
trait Interface {}
struct ViolationFn;
struct Bytes;
trait RawMutex {
type GuardMarker;
}
impl RawMutex for RawMutex {
type GuardMarker = GuardNoSend;
}
struct Either<A, B>;
struct Char;
struct FramedWrite<T, E>;
struct CrcReader<R>;
struct Utf8Lossy;
struct Option<T>;
impl Send for Waker {}
impl<T> Send for FromRawArc<T> where T: Sync, T: Send {}
impl<R, G, T> Send for ReentrantMutex<R, G, T> where R: RawMutex, R: Send, G: GetThreadId, G: Send, T: Send {}
impl Send for Registration {}
impl<T> Send for RawIterRange<T> {}
impl Send for NotifyHandle {}
impl<T> Send for Weak<T> where T: Sync, T: Send {}
impl<T> Send for Cell<T> where T: Send {}
impl<T> Send for MutexGuard<T> {}
impl<T> Send for RawIntoIter<T> where T: Send {}
impl<K, V, Type> Send for NodeRef<Owned, K, V, Type> where K: Send, V: Send {}
impl<D> Send for UnparkMutex<D> where D: Send {}
impl<T> Send for RwLockReadGuard<T> {}
impl<T> Send for Mutex<T> where T: Send {}
impl<T> Send for IterMut<T> where T: Send {}
impl<T> Send for Weak<T> {}
impl<T> Send for Queue<T> where T: Send {}
impl Send for Verifier {}
impl Send for Decompress {}
impl<T, S> Send for Chan<T, S> where T: Send, S: Send {}
impl<R, T> Send for RwLock<R, T> where R: RawRwLock, R: Send, T: Send {}
impl<T> Send for RawTable<T> where T: Send {}
impl<T> Send for Packet<T> where T: Send {}
impl<T> Send for Rc<T> {}
impl<T> Send for AtomicCell<T> where T: Send {}
impl<A> Send for TaskRc<A> where A: Send {}
impl<K, V> Send for RustcOccupiedEntry<K, V> where K: Send, V: Send {}
impl<T> Send for RawIterRange<T> {}
impl<T> Send for Iter<T> where T: Sync {}
impl<T> Send for FuturesUnordered<T> where T: Send {}
impl Send for Once {}
impl Send for Registration {}
impl<T> Send for &mut T where T: Send {}
impl Send for Overlapped {}
impl Send for Semaphore {}
impl<R, T> Send for Mutex<R, T> where R: RawMutex, R: Send, T: Send {}
impl<K, V, S> Send for OccupiedEntry<K, V, S> where K: Send, V: Send, S: Send {}
impl<T> Send for State<T> where T: Send {}
impl<K, V, S> Send for Entries<K, V, S> where K: Send, V: Send, S: Send {}
impl<U> Send for Inner<U> where U: Sync, U: Send {}
impl Send for Signer {}
impl<A> Send for Inner<A> where A: Actor {}
impl Send for Select {}
impl<T> Send for JoinHandle<T> {}
impl<T> Send for Packet<T> where T: Send {}
impl<U> Send for ArcNode<U> where U: Sync, U: Send {}
impl<K, V> Send for Root<K, V> where K: Send, V: Send {}
impl<T> Send for Bucket<T> {}
impl<R, T> Send for RwLock<R, T> where R: RawRwLock, R: Send, T: Send {}
impl<R, T> Send for MappedMutexGuard<R, T> where R: RawMutex, {error}, {error}, {unknown}: Send {}
impl<T> Send for RawIntoIter<T> where T: Send {}
impl<T> Send for Lock<T> where T: Send {}
impl<T> Send for RwLock<T> where T: Send {}
impl<T> Send for *mut T {}
impl<T> Send for StackRef<T> where T: Stackable, T: Send {}
impl<T> Send for RawParDrain<T> {}
impl<T> Send for IntoIter<T> where T: Send {}
impl<T> Send for Drain<T> where T: Send {}
impl<K, V> Send for Iter<K, V> where K: Send, V: Send {}
impl Send for WaitToken {}
impl Send for CompletionStatus {}
impl<R, T> Send for Mutex<R, T> where R: RawMutex, R: Send, T: Send {}
impl<R, T> Send for MappedRwLockWriteGuard<R, T> where R: RawRwLock, {error}, {error}, {unknown}: Send {}
impl Send for BioMethod {}
impl<K, V, Type> Send for NodeRef<Mut, K, V, Type> where K: Send, {error}, V: Send, {error} {}
impl<T> Send for ReentrantMutex<T> where T: Send {}
impl<K, V> Send for RustcOccupiedEntry<K, V> where K: Send, V: Send {}
impl<T> Send for Packet<T> where T: Send {}
impl<T> Send for RawDrain<T> where T: Send {}
impl<O, T> Send for OwningRef<O, T> where O: Send, &T: Send {}
impl<R, T> Send for MappedRwLockReadGuard<R, T> where R: RawRwLock, {error}, {error}, {unknown}: Send {}
impl Send for AtomicTask {}
impl<T> Send for ValueIterMut<T> where T: Send {}
impl Send for Hasher {}
impl Send for SetReadiness {}
impl<G, T> Send for MapGuard<G, T> where G: Send, &T: Send {}
impl Send for Drain {}
impl<T> Send for &T where T: Sync {}
impl<K, V, S> Send for LinkedHashMap<K, V, S> where K: Send, V: Send, S: Send {}
impl<T> Send for AtomicPtr<T> {}
impl Send for Args {}
impl<T> Send for ThreadBound<T> where T: Copy {}
impl<T> Send for LinkedList<T> where T: Send {}
impl<K, V, Type> Send for NodeRef<Immut, K, V, Type> where K: Sync, {error}, V: Sync, {error} {}
impl<A> Send for SmallVecData<A> where A: Array, A: Send {}
impl<T> Send for Drain<T> where T: Send {}
impl<T> Send for RwLock<T> where T: Send {}
impl<T> Send for Packet<T> where T: Send {}
impl<T> Send for Drain<T> where T: Send {}
impl<T> Send for Iter<T> where T: Sync {}
impl<T> Send for ArcNode<T> {}
impl<T> Send for ReentrantMutexGuard<T> {}
impl<T> Send for Sender<T> where T: Send {}
impl<T> Send for RawParDrain<T> {}
impl Send for Deriver {}
impl Send for Crypter {}
impl Send for ArgsOs {}
impl Send for Error {}
impl<R, T> Send for MappedMutexGuard<R, T> where R: RawMutex, {error}, {error}, {unknown}: Send {}
impl Send for Handle {}
impl<T> Send for Receiver<T> where T: Send {}
impl<A> Send for SmallVec<A> where A: Array, {unknown}: Send {}
impl<T> Send for Packet<T> where T: Send {}
impl<K, V> Send for IterMut<K, V> where K: Send, V: Send {}
impl<T> Send for Mutex<T> where T: Send {}
impl<T> Send for CachePadded<T> where T: Send {}
impl Send for Repr {}
impl<T> Send for IterMut<T> where T: Send {}
impl<R, T> Send for MappedRwLockReadGuard<R, T> where R: RawRwLock, {error}, {error}, {unknown}: Send {}
impl<T> Send for Inner<T> where T: Send {}
impl<T> Send for RawTable<T> where T: Send {}
impl Send for MaybeResolved {}
impl<T> Send for RwLockWriteGuard<T> {}
impl<T> Send for Once<T> where T: Send {}
impl<F> Send for Inner<F> where {error}, F: Send, {unknown}: Send, {unknown}: Sync, {unknown}: Send, {unknown}: Sync {}
impl<R, G, T> Send for ReentrantMutex<R, G, T> where R: RawMutex, R: Send, G: GetThreadId, G: Send, T: Send {}
impl Send for Compress {}
impl<Tz> Send for DateTime<Tz> where Tz: TimeZone, <Tz as TimeZone>::Offset: Send {}
impl Send for MessageDigest {}
impl<A, M> Send for SyncContextEnvelope<A, M> where A: Actor, <A as Actor>::Context = SyncContext<A>, A: Handler<M>, M: Message, M: Send {}
impl<T> Send for Inner<T> where T: Send {}
impl<T> Send for AtomicLazyCell<T> where T: Send {}
impl Send for Inner {}
impl Send for RegKey {}
impl<T> Send for SyncSender<T> where T: Send {}
impl<T> Send for NonNull<T> {}
impl<K, V, S> Send for OccupiedEntry<K, V, S> where K: Send, V: Send, S: Send {}
impl<T> Send for Queue<T> where T: Send {}
impl Send for Cipher {}
impl<R, T> Send for MappedRwLockWriteGuard<R, T> where R: RawRwLock, {error}, {error}, {unknown}: Send {}
impl<A, M> Send for SyncEnvelopeProxy<A, M> where M: Message, M: Send, {unknown}: Send {}
impl<R, G, T> Send for ReentrantMutex<R, G, T> where R: RawMutex, R: Send, G: GetThreadId, G: Send, T: Send {}
impl<T> Send for Bucket<T> {}
impl Send for EventedFdInner {}
impl<R, T> Send for RwLock<R, T> where R: RawRwLock, R: Send, T: Send {}
impl Send for Inner {}
impl<T> Send for Receiver<T> where T: Send {}
impl<T> Send for RefCell<T> where T: Send {}
impl<T> Send for Lock<T> where T: Send {}
impl Send for ReadinessQueue {}
impl<R, T> Send for MappedRwLockReadGuard<R, T> where R: RawRwLock, {error}, {error}, {unknown}: Send {}
impl<T> Send for Inner<T> where T: Send {}
impl<T> Send for Arc<T> where T: Sync, T: Send {}
impl<T> Send for ValueDrain<T> where T: Send {}
impl<T> Send for Stack<T> where T: Stackable, T: Send {}
impl<T> Send for RwLock<T> where T: Send {}
impl<T> Send for Iter<T> where T: Sync {}
impl<R, T> Send for Mutex<R, T> where R: RawMutex, R: Send, T: Send {}
impl<R, T> Send for MappedRwLockWriteGuard<R, T> where R: RawRwLock, {error}, {error}, {unknown}: Send {}
impl Send for Node {}
impl<K, V> Send for IntoIter<K, V> where K: Send, V: Send {}
impl<T> Send for ArcInner<T> where T: Sync, T: Send {}
impl Send for Entry {}
impl<T> Send for Unique<T> where T: Send {}
impl<Tz> Send for Date<Tz> where Tz: TimeZone, <Tz as TimeZone>::Offset: Send {}
impl<T> Send for RawDrain<T> where T: Send {}
impl<K, V> Send for IterMut<K, V> where K: Send, V: Send {}
impl<R, T> Send for MappedMutexGuard<R, T> where R: RawMutex, {error}, {error}, {unknown}: Send {}
impl<O, T> Send for OwningRefMut<O, T> where O: Send, &mut T: Send {}
impl Send for KeventList {}
impl<T> Send for IterMut<T> where T: Send {}
impl Send for AtomicTask {}
impl Send for SslMethod {}
impl<T> Send for *const T {}
impl<T> Send for Sender<T> where T: Send {}
impl<T> Send for Queue<T> where T: Send {}
impl<T, P, C> Send for Queue<T, P, C> where T: Send, P: Send, P: Sync, C: Send, C: Sync {}
impl Send for Overlapped {}
trait RawRwLock {
type GuardMarker;
}
impl RawRwLock for RawRwLock {
type GuardMarker = GuardNoSend;
}
struct ParKeys<K, V>;
impl<T> Actor for Mocker<T> where T: Sized, {error} {
type Context = Context<Mocker<T>>;
}
impl Actor for ActorWithSmallMailBox {
type Context = Context<ActorWithSmallMailBox>;
}
impl<A> Actor for SyncArbiter<A> where A: Actor, <A as Actor>::Context = SyncContext<A> {
type Context = Context<SyncArbiter<A>>;
}
impl Actor for Act {
type Context = Context<Act>;
}
impl Actor for Resolver {
type Context = Context<Resolver>;
}
trait Actor {
type Context;
}
struct Mocker<T>;
struct CapturesDebug;
struct Method;
trait GetThreadId {}
impl GetThreadId for RawThreadId {}
struct RangeInclusive<Idx>;
struct FrameTooBig;
struct DeflateDecoder<R>;
trait RawMutex {
type GuardMarker;
}
impl RawMutex for RawMutex {
type GuardMarker = GuardNoSend;
}
struct OsRng;
struct IoSlice;
struct EcKey<T>;
struct ResponseBuilder;
struct AtomicTask;
trait RawRwLock {
type GuardMarker;
}
impl RawRwLock for RawRwLock {
type GuardMarker = GuardNoSend;
}
struct HeadersFlag;
struct Response<B>;
struct Parts;
struct ChildStdout;
struct Punct;
struct BuildHasherDefault<H>;
struct BinaryHeap<T>;
struct ErrorHandlersMiddleware<S, B>;
struct RouteServiceWrapper<T>;
struct Params;
struct GzEncoder<R>;
struct Receiver<T>;
struct TcpListener;
struct IntoIter<K, V>;
struct BytesMut;
struct HandlePriv;
struct Frame<T>;
struct UnboundedSender<T>;
struct LoggerMiddleware<S>;
struct DataFlags;
struct YearFlags;
struct Child;
struct NormalizePathNormalization<S>;
struct EncodingOverride;
struct CustomResponder<T>;
struct IntoIter<K, V>;
struct EitherService<A, B>;
struct ClassUnicodeRange;
struct Chain<T, U>;
struct QueryState<C>;
struct Error;
struct Drain<T>;
struct Extensions;
struct BsDebug;
struct FilterMap<I, F>;
struct LinkedList<T>;
struct Empty<T>;
struct Condvar;
trait Sip {}
impl Sip for Sip13Rounds {}
impl Sip for Sip24Rounds {}
struct Framed<T, U>;
struct Iter<T>;
struct UnsafeCell<T>;
struct Version;
struct Cow<B>;
struct Repeat;
struct IoConnection<T>;
struct State;
struct UnixStream;
struct Array64<T>;
struct Tx<T>;
struct Empty<T, E>;
struct NonNull<T>;
struct AppRouting;
struct Pattern;
struct ResourceService;
struct PathSegment;
struct Literal;
struct Span;
struct Stdout;
trait Peer {
type Poll;
}
impl Peer for Peer {
type Poll = Request<()>;
}
impl Peer for Peer {
type Poll = Response<()>;
}
trait RefCnt {
type Base;
}
impl<T> RefCnt for Rc<T> {
type Base = T;
}
impl<T> RefCnt for Option<T> where T: RefCnt {
type Base = {unknown};
}
impl<T> RefCnt for Arc<T> {
type Base = T;
}
impl<T> RefCnt for Weak<T> {
type Base = T;
}
impl<T> RefCnt for Weak<T> {
type Base = T;
}
struct VaListImpl;
struct Json<T>;
struct Keys<K, V>;
struct Scheme;
struct ServiceFn<F, Req, Out>;
struct Uniform<X>;
struct Take<T>;
struct Sender<T>;
struct String<T>;
struct FramedWrite2<T>;
struct VarsOs;
struct Ident;
struct EscapeDefault;
struct TcpListener;
struct CString;
trait CloneStableDeref {}
impl<O, T> CloneStableDeref for OwningRef<O, T> where O: CloneStableDeref {}
impl<T> CloneStableDeref for &T {}
impl<T> CloneStableDeref for Rc<T> {}
impl<T> CloneStableDeref for Arc<T> {}
struct Receiver<T>;
struct Pos;
struct ByteRead;
struct Intersection<T>;
trait StableDeref {}
impl<R, T> StableDeref for MappedMutexGuard<R, T> where R: RawMutex, {error}, {error} {}
impl<T> StableDeref for Rc<T> {}
impl<T> StableDeref for Box<T> {}
impl<R, T> StableDeref for RwLockReadGuard<R, T> where R: RawRwLock, {error}, {error} {}
impl<T> StableDeref for RwLockReadGuard<T> {}
impl<O, T> StableDeref for OwningRef<O, T> {}
impl<R, T> StableDeref for RwLockUpgradableReadGuard<R, T> where R: RawRwLockUpgrade, {error}, {error} {}
impl<R, T> StableDeref for MappedRwLockReadGuard<R, T> where R: RawRwLock, {error}, {error} {}
impl<R, G, T> StableDeref for MappedReentrantMutexGuard<R, G, T> where R: RawMutex, {error}, G: GetThreadId, {error}, {error} {}
impl<R, G, T> StableDeref for ReentrantMutexGuard<R, G, T> where R: RawMutex, {error}, G: GetThreadId, {error}, {error} {}
impl<T> StableDeref for Ref<T> {}
impl<T> StableDeref for Vec<T> {}
impl<T> StableDeref for &mut T {}
impl<R, T> StableDeref for MutexGuard<R, T> where R: RawMutex, {error}, {error} {}
impl<T> StableDeref for RefMut<T> {}
impl<O, T> StableDeref for OwningRefMut<O, T> {}
impl<T> StableDeref for RwLockWriteGuard<T> {}
impl<O, H> StableDeref for OwningHandle<O, H> where O: StableDeref, H: StableDeref {}
impl<T> StableDeref for Arc<T> {}
impl StableDeref for String {}
impl<T> StableDeref for &T {}
impl<T> StableDeref for MutexGuard<T> {}
impl<R, T> StableDeref for RwLockWriteGuard<R, T> where R: RawRwLock, {error}, {error} {}
impl<R, T> StableDeref for MappedRwLockWriteGuard<R, T> where R: RawRwLock, {error}, {error} {}
trait Ord {}
impl Ord for Infallible {}
impl<T> Ord for Arc<T> where T: Ord {}
impl Ord for Blocks {}
impl<T> Ord for NonNull<T> {}
impl<O, T> Ord for OwningRef<O, T> where T: Ord {}
impl Ord for Ordering {}
impl Ord for Key {}
impl Ord for Ipv6Addr {}
impl Ord for Tm {}
impl<T> Ord for Vec<T> where T: Ord {}
impl Ord for NameServerStateInner {}
impl<T> Ord for [T] where T: Ord {}
impl Ord for OsStr {}
impl Ord for Ident {}
impl Ord for Span {}
impl Ord for CStr {}
impl Ord for Level {}
impl Ord for PrefixComponent {}
impl Ord for Ipv4Addr {}
impl Ord for PathBuf {}
impl<T> Ord for Unicode<T> where T: AsRef<str> {}
impl Ord for Name {}
impl<A> Ord for &mut A where A: Ord {}
impl Ord for DNSClass {}
impl Ord for Position {}
impl Ord for LevelFilter {}
impl<T> Ord for Reverse<T> where T: Ord {}
impl Ord for {unknown} {}
impl<K, V, S> Ord for LinkedHashMap<K, V, S> where K: Hash, K: Eq, K: Ord, V: Ord, S: BuildHasher {}
impl<T> Ord for *mut T {}
impl<T> Ord for Ascii<T> where T: AsRef<str> {}
impl<T> Ord for *const T {}
impl Ord for OsString {}
impl Ord for ! {}
impl Ord for NameServerStats {}
impl<K, V> Ord for BTreeMap<K, V> where K: Ord, V: Ord {}
impl<A> Ord for VecDeque<A> where A: Ord {}
impl Ord for bool {}
impl Ord for NameServerState {}
impl Ord for Components {}
impl Ord for Version {}
impl Ord for Lifetime {}
impl<T> Ord for Cell<T> where T: Ord, T: Copy {}
impl Ord for AcceptEncoding {}
impl Ord for Path {}
impl Ord for {unknown} {}
impl Ord for str {}
impl<C, P> Ord for NameServer<C, P> where C: DnsHandle, P: ConnectionProvider, <P as ConnectionProvider>::ConnHandle = C {}
impl<A> Ord for SmallVec<A> where A: Array, {unknown}: Ord {}
impl Ord for Mime {}
impl Ord for () {}
impl<B> Ord for Cow<B> where B: Ord, B: ToOwned {}
impl Ord for Url {}
impl<Tz> Ord for DateTime<Tz> where Tz: TimeZone {}
impl<T> Ord for Rc<T> where T: Ord {}
impl Ord for Bytes {}
impl Ord for HeaderValue {}
impl Ord for RData {}
impl<T> Ord for LinkedList<T> where T: Ord {}
impl<T> Ord for RefCell<T> where T: Ord {}
impl<T> Ord for OrderWrapper<T> {}
impl<O, T> Ord for OwningRefMut<O, T> where T: Ord {}
impl<T> Ord for UniCase<T> where T: AsRef<str> {}
impl Ord for Url {}
impl Ord for BytesMut {}
impl Ord for RecordType {}
impl<A> Ord for &A where A: Ord {}
impl Ord for Label {}
impl<Tz> Ord for Date<Tz> where Tz: TimeZone {}
struct EnterError;
struct ShortReader;
struct OpaqueStreamRef;
struct TransitionsRow;
struct Output;
struct IterMut<T>;
struct SendError<T>;
struct Form<T>;
struct StatusCode;
struct SemState;
trait Head {}
impl Head for RequestHead {}
struct RefMut<T>;
struct Entry<K, V>;
struct Builder;
struct MultiGzDecoder<R>;
struct SendTimeoutError<T>;
struct Authority;
struct BufReader<R>;
struct RwLockReadGuard<T>;
struct OsStr;
struct Utf8Range;
struct SystemTime;
trait ConnectionProvider {
type ConnHandle;
}
impl ConnectionProvider for StandardConnection {
type ConnHandle = ConnectionHandle;
}
struct NaiveDate;
struct BTreeSet<T>;
struct RetrySendFuture<H>;
struct Unique<T>;
struct Maybe<T>;
struct SpawnHandle<T, E>;
struct PushPromise;
struct LookupFuture<C>;
struct Context;
struct ParIter<T>;
struct Encoding;
struct TryIter<T>;
struct StdinLock;
struct OsString;
struct Wtf8Buf;
struct Duration;
struct CompressMiddleware<S>;
struct SpawnHandle<T, E>;
struct NotifyError<T>;
struct UnixReady;
struct Once<T, E>;
struct Builder;
struct TryLockError<T>;
struct NoColor<W>;
struct IntoIter<T>;
struct BufReader<R>;
trait AsyncContext<A> {}
impl<A> AsyncContext<A> for Context<A> where A: Actor, <A as Actor>::Context = Context<A> {}
struct TokenStream;
struct Iter<T>;
trait StateID {}
impl StateID for usize {}
impl StateID for u64 {}
impl StateID for u8 {}
impl StateID for u16 {}
impl StateID for u32 {}
struct Inner;
struct Command;
struct Iter<K, V>;
struct Weak<T>;
struct IterMut<T>;
trait Strategy {}
impl Strategy for OnUnwind {}
impl Strategy for OnSuccess {}
impl Strategy for Always {}
trait AsMut<T> {}
impl<O, T> AsMut<T> for OwningRefMut<O, T> {}
impl AsMut<[u8;_]> for Block {}
impl<A> AsMut<[{unknown}]> for SmallVec<A> where A: Array {}
impl<T> AsMut<[T]> for Array64<T> {}
impl<L, R, Target> AsMut<[Target]> for Either<L, R> where L: AsMut<[Target]>, R: AsMut<[Target]> {}
impl AsMut<[u8]> for BytesMut {}
impl<T> AsMut<[T]> for Vec<T> {}
impl<T> AsMut<[u8]> for Window<T> where T: AsMut<[u8]> {}
impl<T> AsMut<[T]> for [T] {}
impl<T, U> AsMut<U> for &mut T where T: AsMut<U> {}
impl<T> AsMut<Vec<T>> for Vec<T> {}
impl<T> AsMut<[T]> for IsaacArray<T> {}
impl<L, R, Target> AsMut<Target> for Either<L, R> where L: AsMut<Target>, R: AsMut<Target> {}
struct RawOccupiedEntryMut<K, V>;
struct Notify<U>;
struct NativeTlsAcceptorService<T, P>;
struct HttpRequest;
struct ClientSessionImpl;
struct Chan<T, S>;
struct TokenStream;
struct Connection<T, U>;
struct Ptr;
struct Either<L, R>;
struct UdpSocket;
struct Vec<T>;
struct HandlePriv;
struct Group;
struct Once;
struct MZODeflate;
struct UdpSocket;
struct Number;
struct Iter<T>;
struct Run;
struct Compiler;
struct Range<Idx>;
struct BarrierWaitResult;
struct Response<T>;
struct SockAddr;
struct ReuniteError<T>;
struct SslStream<S>;
struct State;
struct Fuse<T, U>;
struct PushPromiseFlag;
struct BrotliDecoder<W>;
trait Iterator {
type Item;
}
impl<A, B> Iterator for Zip<A, B> where A: Iterator, B: Iterator {
type Item = ({unknown}, {unknown});
}
impl Iterator for SetMatchesIter {
type Item = usize;
}
impl Iterator for Memchr {
type Item = usize;
}
impl<L, R> Iterator for Either<L, R> where L: Iterator, R: Iterator, <R as Iterator>::Item = {unknown} {
type Item = {unknown};
}
impl Iterator for RecordsAndRrsigsIter {
type Item = &Record;
}
impl<K, V> Iterator for Iter<K, V> where {error}, {error} {
type Item = (&K, &V);
}
impl<I> Iterator for Fuse<I> where I: FusedIterator {}
impl<T> Iterator for Once<T> {
type Item = T;
}
impl<T, S> Iterator for SymmetricDifference<T, S> where T: Eq, T: Hash, S: BuildHasher {
type Item = &T;
}
impl Iterator for PartIterator {
type Item = (Part, Part);
}
impl<T, S> Iterator for Union<T, S> where T: Eq, T: Hash, S: BuildHasher {
type Item = &T;
}
impl<T> Iterator for Iter<T> {
type Item = &T;
}
impl Iterator for ErrorIter {
type Item = &dyn Error + {error};
}
impl Iterator for Iter {
type Item = (&HeaderName, &HeaderValue);
}
impl<B> Iterator for Split<B> where B: BufRead {
type Item = Result<Vec<u8>, Error>;
}
impl<D, R, T> Iterator for DistIter<D, R, T> where D: Distribution<T>, R: Rng, {error} {
type Item = T;
}
impl Iterator for ConstParamsMut {
type Item = &mut ConstParam;
}
impl Iterator for ToLowercase {
type Item = char;
}
impl<K, V> Iterator for Iter<K, V> {
type Item = (&K, &V);
}
impl Iterator for Parse {
type Item = (Cow<{unknown}>, Cow<{unknown}>);
}
impl<I> Iterator for Skip<I> where I: Iterator {
type Item = <I as Iterator>::Item;
}
impl Iterator for Split {
type Item = &str;
}
impl Iterator for Causes {
type Item = &{unknown};
}
impl<R, T> Iterator for StreamDeserializer<R, T> where R: Read, T: Deserialize {
type Item = Result<T, Error>;
}
impl Iterator for SrvLookupIntoIter {
type Item = SRV;
}
impl<T, P> Iterator for SplitMut<T, P> where P: FnMut<{unknown}> {
type Item = &mut [T];
}
impl<K, V> Iterator for IterMut<K, V> {
type Item = (&K, &mut V);
}
impl<T> Iterator for Iter<T> {
type Item = T;
}
impl<I> Iterator for DecodeUtf16<I> where I: Iterator, <I as Iterator>::Item = u16 {
type Item = Result<char, DecodeUtf16Error>;
}
impl Iterator for LabelIter {
type Item = &[u8];
}
impl<T, S> Iterator for SymmetricDifference<T, S> where T: Eq, {error}, {error} {
type Item = &T;
}
impl<K, V> Iterator for ValuesMut<K, V> {
type Item = &mut V;
}
impl Iterator for ByteSerialize {
type Item = &{unknown};
}
impl Iterator for ConnectAddrsIter {
type Item = SocketAddr;
}
impl<T, P> Iterator for IntoPairs<T, P> {
type Item = Pair<T, P>;
}
impl<K, V> Iterator for Keys<K, V> {
type Item = &K;
}
impl<T> Iterator for RawIter<T> {
type Item = Bucket<T>;
}
impl<B> Iterator for Lines<B> where B: BufRead {
type Item = Result<String, Error>;
}
impl<K, V> Iterator for IterMut<K, V> {
type Item = (&K, &mut V);
}
impl<T> Iterator for ChunksMut<T> {
type Item = &mut [T];
}
impl Iterator for ConstParams {
type Item = &ConstParam;
}
impl<T> Iterator for IntoIter<T> {
type Item = T;
}
impl<T> Iterator for Drain<T> {
type Item = T;
}
impl<K, V> Iterator for ValuesMut<K, V> {
type Item = &mut V;
}
impl<A> Iterator for IterMut<A> {
type Item = &mut A;
}
impl<T> Iterator for ValueIterMut<T> where {error} {
type Item = &mut T;
}
impl<T, S> Iterator for SymmetricDifference<T, S> where T: Eq, {error}, {error} {
type Item = &T;
}
impl<I> Iterator for Take<I> where I: Iterator {
type Item = <I as Iterator>::Item;
}
impl Iterator for ListServicesIter {
type Item = &Name;
}
impl<T, P> Iterator for PrivateIterMut<T, P> {
type Item = &mut T;
}
impl<T> Iterator for Keys<T> {
type Item = &HeaderName;
}
impl<K, V> Iterator for Values<K, V> {
type Item = &V;
}
impl<A> Iterator for Repeat<A> where A: Clone {
type Item = A;
}
impl Iterator for LookupIter {
type Item = &RData;
}
impl<S> Iterator for Wait<S> where S: Stream {
type Item = Result<{unknown}, {unknown}>;
}
impl<T> Iterator for IterMut<T> {
type Item = &mut T;
}
impl<K, V> Iterator for Iter<K, V> {
type Item = (&K, &V);
}
impl Iterator for Parse {
type Item = (Cow<{unknown}>, Cow<{unknown}>);
}
impl<K> Iterator for Drain<K> {
type Item = K;
}
impl Iterator for PercentDecode {
type Item = u8;
}
impl<A> Iterator for Iter<A> {
type Item = &A;
}
impl<I, T, E> Iterator for ResultShunt<I, E> where I: Iterator, <I as Iterator>::Item = Result<T, E> {
type Item = T;
}
impl Iterator for PatternIter {
type Item = ({unknown}, Pattern);
}
impl<I, U> Iterator for Flatten<I> where I: Iterator, U: Iterator, {unknown}: IntoIterator, <{unknown} as IntoIterator>::IntoIter = U, <{unknown} as IntoIterator>::Item = {unknown} {
type Item = {unknown};
}
impl Iterator for InstPtrs {
type Item = usize;
}
impl<T> Iterator for IntoIter<T> {
type Item = T;
}
impl<T> Iterator for RawIterRange<T> {
type Item = Bucket<T>;
}
impl<K, V> Iterator for IntoIter<K, V> {
type Item = (K, V);
}
impl<I> Iterator for StepBy<I> where I: Iterator {
type Item = {unknown};
}
impl<K, V> Iterator for Values<K, V> {
type Item = &V;
}
impl<A> Iterator for RangeInclusive<A> where A: Step {
type Item = A;
}
impl Iterator for CaptureMatches {
type Item = Captures;
}
impl<T> Iterator for Drain<T> {
type Item = T;
}
impl<K, V> Iterator for IntoIter<K, V> {
type Item = (K, V);
}
impl Iterator for CaptureMatches {
type Item = Captures;
}
impl<T> Iterator for IterMut<T> where T: Send, {error} {
type Item = &mut Box<T>;
}
impl Iterator for LookupRecordIter {
type Item = &Record;
}
impl Iterator for Bytes {
type Item = u8;
}
impl Iterator for Forever {
type Item = i32;
}
impl Iterator for Iter {
type Item = Event;
}
impl<K, V> Iterator for Keys<K, V> {
type Item = &K;
}
impl<T> Iterator for IterBinomial<T> where T: Integer, T: Clone {
type Item = T;
}
impl<T, S> Iterator for Intersection<T, S> where T: Eq, T: Hash, S: BuildHasher {
type Item = &T;
}
impl<A> Iterator for Item<A> {
type Item = A;
}
impl Iterator for Wtf8CodePoints {
type Item = CodePoint;
}
impl Iterator for Utf8Sequences {
type Item = Utf8Sequence;
}
impl<A, F> Iterator for OnceWith<F> where F: FnOnce<{unknown}> {
type Item = A;
}
impl<T> Iterator for Iter<T> {
type Item = (usize, &T);
}
impl Iterator for EnumKeys {
type Item = Result<String, Error>;
}
impl Iterator for LinesAny {
type Item = &str;
}
impl<I, P> Iterator for SkipWhile<I, P> where I: Iterator, P: FnMut<{unknown}> {
type Item = {unknown};
}
impl Iterator for IndexVecIntoIter {
type Item = usize;
}
impl<T> Iterator for ValuesMut<T> {
type Item = &mut T;
}
impl<A> Iterator for IntoIter<A> {
type Item = A;
}
impl<T> Iterator for PathIter<T> where T: ResourcePath {
type Item = (&str, &str);
}
impl<K, V> Iterator for Keys<K, V> {
type Item = &K;
}
impl<T, S> Iterator for Intersection<T, S> where T: Eq, {error}, {error} {
type Item = &T;
}
impl<K, V> Iterator for Range<K, V> {
type Item = (&K, &V);
}
impl<B, I, F> Iterator for FilterMap<I, F> where I: Iterator, F: FnMut<{unknown}> {
type Item = B;
}
impl Iterator for Matches {
type Item = Match;
}
impl<T> Iterator for RawIntoIter<T> {
type Item = T;
}
impl<K> Iterator for Iter<K> {
type Item = &K;
}
impl<T> Iterator for IntoIter<T> {
type Item = T;
}
impl<I> Iterator for ChunkHintedIterator<I> where I: ExactSizeIterator, I: Iterator, I: Clone {
type Item = {unknown};
}
impl<K, V> Iterator for IterMut<K, V> {
type Item = (&K, &mut V);
}
impl Iterator for StrftimeItems {
type Item = Item;
}
impl<K, V> Iterator for IntoIter<K, V> {
type Item = (K, V);
}
impl<T, F> Iterator for Successors<T, F> where F: FnMut<{unknown}> {
type Item = T;
}
impl<I, U, F> Iterator for FlatMap<I, U, F> where I: Iterator, U: IntoIterator, F: FnMut<{unknown}> {
type Item = {unknown};
}
impl Iterator for EnumValues {
type Item = Result<(String, RegValue), Error>;
}
impl<T, S> Iterator for Difference<T, S> where T: Eq, T: Hash, S: BuildHasher {
type Item = &T;
}
impl<T, P> Iterator for Split<T, P> where P: FnMut<{unknown}> {
type Item = &[T];
}
impl Iterator for GetAll {
type Item = &HeaderValue;
}
impl Iterator for SetMatchesIntoIter {
type Item = usize;
}
impl Iterator for SplitPaths {
type Item = PathBuf;
}
impl<T> Iterator for IntoIter<T> {
type Item = T;
}
impl<I> Iterator for ChunkHintedIterator<I> where I: ExactSizeIterator, I: Iterator, I: Clone {
type Item = {unknown};
}
impl<T, P> Iterator for IntoIter<T, P> {
type Item = T;
}
impl<I, T> Iterator for Cloned<I> where {error}, I: Iterator, <I as Iterator>::Item = &T, T: Clone {
type Item = T;
}
impl<K, V> Iterator for Values<K, V> {
type Item = &V;
}
impl<T> Iterator for Windows<T> {
type Item = &[T];
}
impl<I> Iterator for WindowHintedIterator<I> where I: ExactSizeIterator, I: Iterator, I: Clone {
type Item = {unknown};
}
impl<T> Iterator for RChunksExact<T> {
type Item = &[T];
}
impl<T> Iterator for Drain<T> {
type Item = T;
}
impl Iterator for SplitAsciiWhitespace {
type Item = &str;
}
impl<K, V> Iterator for Keys<K, V> {
type Item = &K;
}
impl Iterator for SrvLookupIter {
type Item = &SRV;
}
impl Iterator for Chars {
type Item = {unknown};
}
impl<T> Iterator for TryIter<T> {
type Item = T;
}
impl Iterator for RrsetRecords {
type Item = &Record;
}
impl Iterator for SimpleFoldIter {
type Item = char;
}
impl<F> Iterator for IterMut<F> {
type Item = &mut F;
}
impl<T> Iterator for IntoIter<T> {
type Item = T;
}
impl<T> Iterator for IterMut<T> where T: Stackable {
type Item = &mut {unknown};
}
impl Iterator for CookieIter {
type Item = Cookie;
}
impl<S> Iterator for IterTransitionsMut<S> where S: StateID {
type Item = (u8, S);
}
impl<K, V> Iterator for IterMut<K, V> {
type Item = (&K, &mut V);
}
impl<T, P> Iterator for PairsMut<T, P> {
type Item = Pair<&mut T, &mut P>;
}
impl<T> Iterator for Range<T> {
type Item = &T;
}
impl<K, V> Iterator for ValuesMut<K, V> {
type Item = &mut V;
}
impl<R> Iterator for Bytes<R> where R: Read {
type Item = Result<u8, Error>;
}
impl<K, V, S> Iterator for Entries<K, V, S> where S: BuildHasher {
type Item = OccupiedEntry<K, V, S>;
}
impl<T> Iterator for IntoIter<T> {
type Item = T;
}
impl<K> Iterator for IntoIter<K> {
type Item = K;
}
impl Iterator for Input {
type Item = char;
}
impl<T> Iterator for ValueIter<T> where {error} {
type Item = &T;
}
impl Iterator for ByteSerialize {
type Item = &{unknown};
}
impl<A, B> Iterator for Chain<A, B> where A: Iterator, B: Iterator, <B as Iterator>::Item = {unknown} {
type Item = {unknown};
}
impl Iterator for CaptureNames {
type Item = Option<&str>;
}
impl<K, V> Iterator for Values<K, V> {
type Item = &V;
}
impl<T> Iterator for IterMut<T> {
type Item = &mut T;
}
impl Iterator for DomainIterInternal {
type Item = &String;
}
impl Iterator for ClassBytesIter {
type Item = &ClassBytesRange;
}
impl<T> Iterator for MockHintIter<T> where T: Iterator {
type Item = {unknown};
}
impl<S, T> Iterator for SliceChooseIter<S, T> where {error}, {error}, {error} {
type Item = &T;
}
impl<K> Iterator for Drain<K> {
type Item = K;
}
impl<K, V> Iterator for Values<K, V> {
type Item = &V;
}
impl Iterator for ParseIntoOwned {
type Item = (String, String);
}
impl<I> Iterator for StreamSafe<I> where I: Iterator, <I as Iterator>::Item = char {
type Item = char;
}
impl<I, P> Iterator for Filter<I, P> where I: Iterator, P: FnMut<{unknown}> {
type Item = {unknown};
}
impl<T> Iterator for Iter<T> where T: Stackable {
type Item = &{unknown};
}
impl<T, S1, S2> Iterator for SymmetricDifference<T, S1, S2> where T: Eq, T: Hash, S1: BuildHasher, S2: BuildHasher {
type Item = &T;
}
impl<K, V> Iterator for Iter<K, V> {
type Item = (&K, &V);
}
impl<R, S> Iterator for StreamFindIter<R, S> where R: Read, S: StateID {
type Item = Result<Match, Error>;
}
impl Iterator for EscapeUnicode {
type Item = char;
}
impl<K, V> Iterator for RangeMut<K, V> {
type Item = (&K, &mut V);
}
impl<K> Iterator for IntoIter<K> {
type Item = K;
}
impl<T, F> Iterator for DrainFilter<T, F> where F: FnMut<{unknown}> {
type Item = T;
}
impl Iterator for ProbeSeq {
type Item = usize;
}
impl<I, F> Iterator for Inspect<I, F> where I: Iterator, F: FnMut<{unknown}> {
type Item = {unknown};
}
impl<T> Iterator for IntoIter<T> where T: Send {
type Item = Box<T>;
}
impl<I> Iterator for Cycle<I> where I: Clone, I: Iterator {
type Item = <I as Iterator>::Item;
}
impl<I> Iterator for Recompositions<I> where I: Iterator, <I as Iterator>::Item = char {
type Item = char;
}
impl<T, S> Iterator for Difference<T, S> where T: Eq, {error}, {error} {
type Item = &T;
}
impl Iterator for ReadDir {
type Item = Result<DirEntry, Error>;
}
impl Iterator for Params {
type Item = (Name, Name);
}
impl Iterator for BitMaskIter {
type Item = usize;
}
impl Iterator for SocketAddrs {
type Item = SocketAddr;
}
impl<T> Iterator for RChunksExactMut<T> {
type Item = &mut [T];
}
impl<T, S> Iterator for Difference<T, S> where T: Eq, {error}, {error} {
type Item = &T;
}
impl Iterator for Iter {
type Item = Result<OsString, Error>;
}
impl Iterator for Split {
type Item = &[u8];
}
impl<D, R, T> Iterator for DistIter<D, R, T> where D: Distribution<T>, R: Rng {
type Item = T;
}
impl Iterator for Delta {
type Item = &Cookie;
}
impl Iterator for SubCaptureMatches {
type Item = Option<Match>;
}
impl<A, F> Iterator for RepeatWith<F> where F: FnMut<{unknown}> {
type Item = A;
}
impl Iterator for Iter {
type Item = Header<Option<HeaderName>>;
}
impl<K, V> Iterator for ValuesMut<K, V> {
type Item = &mut V;
}
impl<T> Iterator for RawIntoIter<T> {
type Item = T;
}
impl<T, I> Iterator for GenericSplitN<I> where I: SplitIter, {error} {
type Item = T;
}
impl Iterator for IndexVecIter {
type Item = usize;
}
impl Iterator for ArgsOs {
type Item = OsString;
}
impl<R> Iterator for CaptureMatches<R> where R: RegularExpression, {error}, {unknown}: AsRef<[u8]> {
type Item = Locations;
}
impl Iterator for EncodeWide {
type Item = u16;
}
impl<I> Iterator for &mut I where I: Iterator {
type Item = {unknown};
}
impl Iterator for Incoming {
type Item = Result<TcpStream, Error>;
}
impl<B, I, St, F> Iterator for Scan<I, St, F> where I: Iterator, F: FnMut<{unknown}> {
type Item = B;
}
impl Iterator for ByteClassRepresentatives {
type Item = u8;
}
impl Iterator for TokenTreeIter {
type Item = TokenTree;
}
impl<T> Iterator for Iter<T> {
type Item = &T;
}
impl<S> Iterator for FindOverlappingIter<S> where S: StateID {
type Item = Match;
}
impl<B, I, F> Iterator for Map<I, F> where I: Iterator, F: FnMut<{unknown}> {
type Item = B;
}
impl<T, F> Iterator for DrainFilter<T, F> where F: FnMut<{unknown}> {
type Item = T;
}
impl<T> Iterator for IntoIter<T> {
type Item = T;
}
impl<T> Iterator for Drain<T> {
type Item = T;
}
impl Iterator for Vars {
type Item = (String, String);
}
impl<T> Iterator for TryIter<T> {
type Item = T;
}
impl<T, P> Iterator for PrivateIter<T, P> {
type Item = &T;
}
impl<K, V> Iterator for IterMut<K, V> {
type Item = (&K, &mut V);
}
impl Iterator for Iter {
type Item = &Cookie;
}
impl<T> Iterator for Drain<T> where {error} {
type Item = T;
}
impl<T, S> Iterator for Difference<T, S> where T: Eq, T: Hash, S: BuildHasher {
type Item = &T;
}
impl<T> Iterator for IterMut<T> {
type Item = &mut T;
}
impl<T, P> Iterator for RSplitMut<T, P> where P: FnMut<{unknown}> {
type Item = &mut [T];
}
impl<I> Iterator for Decompositions<I> where I: Iterator, <I as Iterator>::Item = char {
type Item = char;
}
impl<T, S> Iterator for Union<T, S> where T: Eq, {error}, {error} {
type Item = &T;
}
impl Iterator for TypeParamsMut {
type Item = &mut TypeParam;
}
impl Iterator for EscapeDebug {
type Item = char;
}
impl<I> Iterator for UnhintedIterator<I> where I: Iterator, I: Clone {
type Item = {unknown};
}
impl<I, P> Iterator for TakeWhile<I, P> where I: Iterator, P: FnMut<{unknown}> {
type Item = {unknown};
}
impl<K, V> Iterator for Drain<K, V> {
type Item = (K, V);
}
impl<T, P> Iterator for RSplit<T, P> where P: FnMut<{unknown}> {
type Item = &[T];
}
impl<K, V> Iterator for IntoIter<K, V> {
type Item = (K, V);
}
impl<K, V> Iterator for Drain<K, V> {
type Item = (K, V);
}
impl Iterator for RrsigsByAlgorithms {
type Item = &Record;
}
impl Iterator for LookupIpIter {
type Item = IpAddr;
}
impl<T> Iterator for Iter<T> {
type Item = &T;
}
impl<A> Iterator for IntoIter<A> where A: Array {
type Item = {unknown};
}
impl Iterator for AgeIter {
type Item = &[(char, char)];
}
impl<I> Iterator for Enumerate<I> where I: Iterator {
type Item = ({unknown}, <I as Iterator>::Item);
}
impl<I> Iterator for UnhintedIterator<I> where I: Iterator, I: Clone {
type Item = {unknown};
}
impl Iterator for Ancestors {
type Item = &Path;
}
impl Iterator for AllBytesIter {
type Item = u8;
}
impl<I> Iterator for Fuse<I> where I: Iterator {
type Item = <I as Iterator>::Item;
}
impl<I> Iterator for Rev<I> where I: DoubleEndedIterator {
type Item = <I as Iterator>::Item;
}
impl Iterator for AtomicStackEntries {
type Item = Arc<Entry>;
}
impl<T> Iterator for IntoIter<T> {
type Item = T;
}
impl Iterator for Keys {
type Item = &HeaderName;
}
impl<T> Iterator for Iter<T> {
type Item = (&HeaderName, &T);
}
impl<K, V> Iterator for IterMut<K, V> {
type Item = (&K, &mut V);
}
impl Iterator for TypeParams {
type Item = &TypeParam;
}
impl<R> Iterator for Matches<R> where R: RegularExpression, {error}, {unknown}: AsRef<[u8]> {
type Item = (usize, usize);
}
impl<K, V> Iterator for Drain<K, V> {
type Item = (K, V);
}
impl Iterator for SetMatchesIntoIter {
type Item = usize;
}
impl<I> Iterator for Splice<I> where I: Iterator {
type Item = {unknown};
}
impl<K, V> Iterator for Keys<K, V> {
type Item = &K;
}
impl<T> Iterator for Iter<T> {
type Item = &T;
}
impl Iterator for SplitN {
type Item = &str;
}
impl Iterator for SplitWhitespace {
type Item = &str;
}
impl<T> Iterator for IntoIter<T> where T: Stackable {
type Item = T;
}
impl<K, V> Iterator for Iter<K, V> {
type Item = (&K, &V);
}
impl Iterator for BitMaskIter {
type Item = usize;
}
impl<T> Iterator for RawIter<T> {
type Item = Bucket<T>;
}
impl<K> Iterator for Drain<K> {
type Item = K;
}
impl<T> Iterator for RChunks<T> {
type Item = &[T];
}
impl Iterator for CaseMappingIter {
type Item = char;
}
impl Iterator for SubCaptureMatches {
type Item = Option<Match>;
}
impl<I, T> Iterator for OptionShunt<I> where I: Iterator, <I as Iterator>::Item = Option<T> {
type Item = T;
}
impl<I, U> Iterator for FlattenCompat<I, U> where I: Iterator, U: Iterator, {unknown}: IntoIterator, <{unknown} as IntoIterator>::IntoIter = U, <{unknown} as IntoIterator>::Item = {unknown} {
type Item = {unknown};
}
impl Iterator for Lines {
type Item = &str;
}
impl<K, V> Iterator for IntoIter<K, V> {
type Item = (K, V);
}
impl<T> Iterator for RawDrain<T> {
type Item = T;
}
impl<K, V> Iterator for IntoIter<K, V> {
type Item = (K, V);
}
impl Iterator for LifetimesMut {
type Item = &mut LifetimeDef;
}
impl Iterator for ProbeSeq {
type Item = usize;
}
impl Iterator for ParseIntoOwned {
type Item = (String, String);
}
impl Iterator for SupportedAlgorithmsIter {
type Item = Algorithm;
}
impl<E> Iterator for PercentEncode<E> where E: EncodeSet {
type Item = &{unknown};
}
impl Iterator for EncodeUtf16 {
type Item = u16;
}
impl<I> Iterator for Peekable<I> where I: Iterator {
type Item = {unknown};
}
impl<I> Iterator for IntervalSetIter<I> {
type Item = &I;
}
impl<T> Iterator for IterMut<T> {
type Item = (&HeaderName, &mut T);
}
impl Iterator for DomainIter {
type Item = &String;
}
impl Iterator for CharIndices {
type Item = (usize, {unknown});
}
impl<T> Iterator for RawIterRange<T> {
type Item = Bucket<T>;
}
impl<T> Iterator for Union<T> where T: Ord {
type Item = &T;
}
impl<T> Iterator for RawDrain<T> {
type Item = T;
}
impl<K, V> Iterator for Keys<K, V> {
type Item = &K;
}
impl<T> Iterator for ChunksExactMut<T> {
type Item = &mut [T];
}
impl Iterator for Fold {
type Item = char;
}
impl Iterator for Iter {
type Item = &OsStr;
}
impl<I, T> Iterator for Copied<I> where {error}, I: Iterator, <I as Iterator>::Item = &T, T: Copy {
type Item = T;
}
impl Iterator for FindIter {
type Item = Match;
}
impl<T> Iterator for Drain<T> {
type Item = T;
}
impl<K, V> Iterator for Drain<K, V> {
type Item = (K, V);
}
impl<K, V, I> Iterator for MergeIter<K, V, I> where K: Ord, I: Iterator, <I as Iterator>::Item = (K, V) {
type Item = (K, V);
}
impl Iterator for Utf8LossyChunksIter {
type Item = Utf8LossyChunk;
}
impl<K, V> Iterator for IterMut<K, V> where {error}, {error} {
type Item = (&K, &mut V);
}
impl Iterator for EscapeDefault {
type Item = u8;
}
impl Iterator for ConnectTakeAddrsIter {
type Item = SocketAddr;
}
impl Iterator for Matches {
type Item = Match;
}
impl<T> Iterator for Values<T> {
type Item = &T;
}
impl<T> Iterator for IntoIter<T> {
type Item = T;
}
impl<T> Iterator for Iter<T> where {error} {
type Item = u8;
}
impl Iterator for Pending {
type Item = i32;
}
impl<T> Iterator for Intersection<T> where T: Ord {
type Item = &T;
}
impl Iterator for Drain {
type Item = char;
}
impl<K, V> Iterator for Values<K, V> {
type Item = &V;
}
impl Iterator for IndexVecIntoIter {
type Item = usize;
}
impl<T> Iterator for RChunksMut<T> {
type Item = &mut [T];
}
impl<K> Iterator for IntoIter<K> {
type Item = K;
}
impl Iterator for Args {
type Item = String;
}
impl<T> Iterator for IntoIter<T> {
type Item = (Option<HeaderName>, T);
}
impl<K, V> Iterator for IntoIter<K, V> {
type Item = (K, V);
}
impl Iterator for Components {
type Item = Component;
}
impl<T, S> Iterator for Intersection<T, S> where T: Eq, T: Hash, S: BuildHasher {
type Item = &T;
}
impl<T, P> Iterator for Pairs<T, P> {
type Item = Pair<&T, &P>;
}
impl<T> Iterator for Drain<T> {
type Item = (HeaderName, ValueDrain<T>);
}
impl<S> Iterator for FindIter<S> where S: StateID {
type Item = Match;
}
impl<S, T> Iterator for SliceChooseIter<S, T> where {error}, {error}, {error} {
type Item = &T;
}
impl Iterator for EscapeDefault {
type Item = char;
}
impl Iterator for Memchr3 {
type Item = usize;
}
impl Iterator for EnumSetupInstances {
type Item = Result<SetupInstance, i32>;
}
impl<K> Iterator for Iter<K> {
type Item = &K;
}
impl<K, V> Iterator for ValuesMut<K, V> {
type Item = &mut V;
}
impl Iterator for VarsOs {
type Item = (OsString, OsString);
}
impl<A> Iterator for Range<A> where A: Step {
type Item = A;
}
impl Iterator for SplitN {
type Item = &[u8];
}
impl<T> Iterator for Iter<T> {
type Item = &T;
}
impl<T> Iterator for IterMut<T> {
type Item = &mut T;
}
impl<T, S> Iterator for Union<T, S> where T: Eq, T: Hash, S: BuildHasher {
type Item = &T;
}
impl Iterator for LookupIntoIter {
type Item = RData;
}
impl<K, V> Iterator for Iter<K, V> {
type Item = (&K, &V);
}
impl<T> Iterator for SymmetricDifference<T> where T: Ord {
type Item = &T;
}
impl<T> Iterator for Iter<T> {
type Item = &T;
}
impl Iterator for IntoIter {
type Item = Event;
}
impl<K, V> Iterator for Iter<K, V> {
type Item = (&K, &V);
}
impl Iterator for IntoIter {
type Item = TokenTree;
}
impl Iterator for Input {
type Item = char;
}
impl Iterator for PercentEncode {
type Item = &{unknown};
}
impl Iterator for Bytes {
type Item = u8;
}
impl Iterator for IndexVecIter {
type Item = usize;
}
impl<T> Iterator for ChunksExact<T> {
type Item = &[T];
}
impl Iterator for Memchr2 {
type Item = usize;
}
impl<T> Iterator for Chunks<T> {
type Item = &[T];
}
impl Iterator for ClassUnicodeIter {
type Item = &ClassUnicodeRange;
}
impl Iterator for LookupIpIntoIter {
type Item = IpAddr;
}
impl<T, S> Iterator for Intersection<T, S> where T: Eq, {error}, {error} {
type Item = &T;
}
impl<A> Iterator for RangeFrom<A> where A: Step {
type Item = A;
}
impl Iterator for LiteralIter {
type Item = &[u8];
}
impl<T> Iterator for Iter<T> {
type Item = T;
}
impl<I> Iterator for WindowHintedIterator<I> where I: ExactSizeIterator, I: Iterator, I: Clone {
type Item = {unknown};
}
impl<I> Iterator for LineColIterator<I> where I: Iterator, <I as Iterator>::Item = Result<u8, Error> {
type Item = Result<u8, Error>;
}
impl<T> Iterator for Iter<T> {
type Item = &T;
}
impl<T> Iterator for Empty<T> {
type Item = T;
}
impl<T> Iterator for Difference<T> where T: Ord {
type Item = &T;
}
impl Iterator for Lifetimes {
type Item = &LifetimeDef;
}
impl Iterator for ToUppercase {
type Item = char;
}
impl<K> Iterator for Iter<K> {
type Item = &K;
}
impl Iterator for SubCapturesPosIter {
type Item = Option<(usize, usize)>;
}
impl Iterator for X509NameEntries {
type Item = &{unknown};
}
impl<T> Iterator for ValueDrain<T> {
type Item = T;
}
impl Iterator for SetMatchesIter {
type Item = usize;
}
impl<T, S> Iterator for Union<T, S> where T: Eq, {error}, {error} {
type Item = &T;
}
impl Iterator for PercentDecode {
type Item = u8;
}
impl<T, F> Iterator for FromFn<F> where F: FnMut<{unknown}> {
type Item = T;
}
impl<T> Iterator for IterMut<T> {
type Item = (usize, &mut T);
}
impl Iterator for CaptureNames {
type Item = Option<&str>;
}
trait Hasher {}
impl Hasher for SipHasher13 {}
impl Hasher for IdHasher {}
impl Hasher for SipHasher {}
impl<S> Hasher for Hasher<S> where S: Sip {}
impl Hasher for FnvHasher {}
impl Hasher for Hasher {}
impl Hasher for IdHasher {}
impl Hasher for DefaultHasher {}
impl<H> Hasher for &mut H where H: Hasher {}
struct Handle;
struct UnixSocket;
struct ClassFrame;
struct Cell<T>;
struct ZlibEncoder<R>;
struct Span;
struct Label;
struct Repr;
struct Buffer<T>;
struct AccessError;
struct zx_guest_packet_t;
struct Arguments;
struct Request<P>;
struct DeflateEncoder<R>;
struct HeaderValue;
struct Wtf8;
struct Error;
struct Counter<T>;
struct DigestBytes;
struct Instant;
struct AppInitService<T, B>;
struct Successors<T, F>;
struct RW;
struct Map<K, V>;
struct EncodeUtf16;
struct SyncSender<T>;
struct RangeToInclusive<Idx>;
struct FramedWrite<T, B>;
struct Events;
trait Hash {}
impl Hash for OsStr {}
impl Hash for CodePoint {}
impl Hash for Scheme {}
impl Hash for Wtf8 {}
impl<O, T> Hash for OwningRefMut<O, T> where T: Hash {}
impl<T> Hash for &T where T: Hash {}
impl Hash for Lifetime {}
impl Hash for Path {}
impl Hash for PrefixComponent {}
impl<T> Hash for String<T> where T: AsRef<[u8]> {}
impl Hash for TraitItemVerbatim {}
impl Hash for Mime {}
impl Hash for ResourceDef {}
impl<S> Hash for Ascii<S> where S: AsRef<str> {}
impl Hash for PathBuf {}
impl<S> Hash for Unicode<S> where S: AsRef<str> {}
impl<Tz> Hash for Date<Tz> where Tz: TimeZone {}
impl Hash for MaybeLower {}
impl Hash for SocketAddrV6 {}
impl Hash for Uri {}
impl Hash for str {}
impl<O, T> Hash for OwningRef<O, T> where T: Hash {}
impl<T> Hash for *mut T {}
impl Hash for Index {}
impl<S> Hash for UniCase<S> where S: AsRef<str> {}
impl Hash for TokenStreamHelper {}
impl Hash for TypeVerbatim {}
impl Hash for Name {}
impl Hash for NaiveDateTime {}
impl<A> Hash for VecDeque<A> where A: Hash {}
impl<A> Hash for AddressSender<A> where A: Actor {}
impl Hash for Custom {}
impl<B> Hash for Cow<B> where B: Hash, B: ToOwned {}
impl Hash for Ident {}
impl Hash for Version {}
impl<T> Hash for NonNull<T> {}
impl Hash for SocketAddrV4 {}
impl Hash for ! {}
impl<K> Hash for KeyRef<K> where K: Hash {}
impl Hash for Url {}
impl Hash for Bytes {}
impl<A> Hash for Addr<A> where A: Actor {}
impl Hash for PatVerbatim {}
impl Hash for Attribute {}
impl Hash for Label {}
impl<M> Hash for Recipient<M> where M: Message, M: Send, {unknown}: Send {}
impl<T> Hash for Vec<T> where T: Hash {}
impl Hash for Encoding {}
impl Hash for bool {}
impl Hash for ItemVerbatim {}
impl<T> Hash for &mut T where T: Hash {}
impl<K, V, S> Hash for LinkedHashMap<K, V, S> where K: Hash, K: Eq, V: Hash, S: BuildHasher {}
impl<Tz> Hash for DateTime<Tz> where Tz: TimeZone {}
impl Hash for BytesMut {}
impl Hash for TokenTreeHelper {}
impl<T> Hash for LinkedList<T> where T: Hash {}
impl<Idx> Hash for RangeInclusive<Idx> where Idx: Hash {}
impl Hash for OsString {}
impl Hash for char {}
impl Hash for Ipv6Addr {}
impl<T> Hash for *const T {}
impl Hash for DeltaCookie {}
impl Hash for ExprVerbatim {}
impl Hash for ItemMacro2 {}
impl Hash for Key {}
impl Hash for Macro {}
impl Hash for Authority {}
impl Hash for Ipv4Addr {}
impl Hash for Wtf8Buf {}
impl<T> Hash for Discriminant<T> {}
impl<T> Hash for [T] where T: Hash {}
impl Hash for ForeignItemVerbatim {}
impl<T> Hash for Rc<T> where T: Hash {}
impl Hash for ImplItemVerbatim {}
impl Hash for Url {}
impl<K, V> Hash for BTreeMap<K, V> where K: Hash, V: Hash {}
impl Hash for String {}
impl<T> Hash for Arc<T> where T: Hash {}
impl Hash for NaiveTime {}
struct MZOInflate;
struct Literal;
struct Drain;
struct NotifyHandle;
struct BrotliEncoder<R>;
struct Display;
struct FuturesUnordered<F>;
struct UnparkEvent;
struct Flatten<S>;
struct SocketAddrV6;
struct Inspect<I, F>;
struct Slab<T>;
struct Scheduler<U>;
struct Io<T, P>;
struct SendError<T>;
struct Signer;
struct Condvar;
struct Pong;
struct Once;
struct CloneableService<T>;
struct FramedWrite2<T>;
struct Captures;
struct Hasher;
struct Group;
struct Captures;
struct UnixDatagram;
struct Fuse<T, U>;
struct Values<K, V>;
struct IterMut<T>;
struct SrvLookupFuture;
struct Level<T>;
struct Body;
struct Args;
struct ZlibDecoder<R>;
struct Inner<T>;
struct IntoIter<K>;
struct TrySendError<T>;
struct SpawnHandle<Item, Error>;
trait Encoder {
type Item;
type Error;
}
impl Encoder for BytesCodec {
type Item = Bytes;
type Error = Error;
}
impl Encoder for Codec {
type Item = Message;
type Error = ProtocolError;
}
impl Encoder for ClientCodec {
type Item = Message<(RequestHead, BodySize)>;
type Error = Error;
}
impl Encoder for LinesCodec {
type Item = String;
type Error = Error;
}
impl<T, U> Encoder for Fuse<T, U> where U: Encoder {
type Item = {unknown};
type Error = {unknown};
}
impl Encoder for LinesCodec {
type Item = String;
type Error = Error;
}
impl Encoder for Codec {
type Item = Message<(Response<()>, BodySize)>;
type Error = Error;
}
impl Encoder for BytesCodec {
type Item = Bytes;
type Error = Error;
}
impl<T, U> Encoder for Fuse<T, U> where U: Encoder {
type Item = {unknown};
type Error = {unknown};
}
impl Encoder for BytesCodec {
type Item = Bytes;
type Error = Error;
}
impl<T, U> Encoder for Fuse<T, U> where U: Encoder {
type Item = {unknown};
type Error = {unknown};
}
struct Codec;
struct Rx<T>;
struct Bad;
struct Mask;
struct Discriminant<T>;
struct Empty;
struct Range<K, V>;
struct Parts;
struct HeaderName;
struct FramedRead<T, D>;
struct UnboundedReceiver<T>;
struct Semaphore;
struct Values<K, V>;
struct Settings;
struct SendRequest<B>;
struct Extensions;
struct BrotliDecoder<R>;
struct ParseBuffer;
struct PingPong;
struct GzDecoder<R>;
struct Builder;
struct WriterInnerLock<W>;
trait Eq {}
impl<T> Eq for NonNull<T> {}
impl<K, V, S> Eq for HashMap<K, V, S> where K: Eq, {error}, V: Eq, {error} {}
impl Eq for Url {}
impl<T> Eq for HeaderMap<T> where T: Eq {}
impl Eq for Authority {}
impl Eq for Algorithm {}
impl Eq for Lifetime {}
impl Eq for ImplItemVerbatim {}
impl<A> Eq for SmallVec<A> where A: Array, {unknown}: Eq {}
impl Eq for Mime {}
impl Eq for OsString {}
impl<T> Eq for Vec<T> where T: Eq {}
impl Eq for InternalNumeric {}
impl<T> Eq for [T] where T: Eq {}
impl Eq for AcceptEncoding {}
impl<S> Eq for Ascii<S> where S: AsRef<str> {}
impl<O, T> Eq for OwningRef<O, T> where T: Eq {}
impl<T> Eq for Arc<T> where T: Eq {}
impl<K, V, S> Eq for IndexMap<K, V, S> where K: Eq, K: Hash, V: Eq, S: BuildHasher {}
impl Eq for Index {}
impl Eq for Ordering {}
impl<H> Eq for BuildHasherDefault<H> {}
impl<T> Eq for *mut T {}
impl Eq for Algorithm {}
impl<T, S> Eq for HashSet<T, S> where T: Eq, T: Hash, S: BuildHasher {}
impl Eq for Dropable {}
impl Eq for OsStr {}
impl Eq for {unknown} {}
impl<M> Eq for Recipient<M> where M: Message, M: Send, {unknown}: Send {}
impl Eq for SocketAddrV4 {}
impl Eq for PathAndQuery {}
impl Eq for Algorithm {}
impl Eq for BytesMut {}
impl<A> Eq for &mut A where A: Eq {}
impl<C, P> Eq for NameServer<C, P> where C: DnsHandle, P: ConnectionProvider, <P as ConnectionProvider>::ConnHandle = C {}
impl<A> Eq for &A where A: Eq {}
impl<T> Eq for LinkedList<T> where T: Eq {}
impl<A> Eq for VecDeque<A> where A: Eq {}
impl Eq for Components {}
impl Eq for Ident {}
impl<T> Eq for RefCell<T> where T: Eq {}
impl Eq for Dropable {}
impl Eq for Ipv6Addr {}
impl Eq for CStr {}
impl Eq for DeltaCookie {}
impl Eq for Path {}
impl<S> Eq for Unicode<S> where S: AsRef<str> {}
impl Eq for NameServerState {}
impl Eq for NameServerStateInner {}
impl<T> Eq for Discriminant<T> {}
impl<Tz> Eq for DateTime<Tz> where Tz: TimeZone {}
impl Eq for ContentType {}
impl Eq for ItemMacro2 {}
impl Eq for ExprVerbatim {}
impl Eq for Attribute {}
impl<T> Eq for Rc<T> where T: Eq {}
impl Eq for HeaderValue {}
impl<K, V, S> Eq for LinkedHashMap<K, V, S> where K: Hash, K: Eq, V: Eq, S: BuildHasher {}
impl<K, V, S> Eq for HashMap<K, V, S> where K: Eq, {error}, V: Eq, {error} {}
impl Eq for Macro {}
impl Eq for ! {}
impl Eq for ThreadPool {}
impl Eq for ForeignItemVerbatim {}
impl Eq for Bytes {}
impl Eq for Blocks {}
impl<Tz> Eq for Date<Tz> where Tz: TimeZone {}
impl<K, V, S> Eq for HashMap<K, V, S> where K: Eq, K: Hash, V: Eq, S: BuildHasher {}
impl<T, S> Eq for HashSet<T, S> where T: Eq, {error}, {error} {}
impl Eq for Algorithm {}
impl Eq for Encoding {}
impl Eq for Uri {}
impl Eq for TraitItemVerbatim {}
impl<A> Eq for AddressSender<A> where A: Actor {}
impl Eq for zx_guest_packet_t {}
impl<T, S> Eq for HashSet<T, S> where T: Eq, {error}, {error} {}
impl Eq for SocketAddrV6 {}
impl<T> Eq for OrderWrapper<T> {}
impl<O, T> Eq for OwningRefMut<O, T> where T: Eq {}
impl Eq for TypeVerbatim {}
impl<T> Eq for Cell<T> where T: Eq, T: Copy {}
impl<A> Eq for Addr<A> where A: Actor {}
impl Eq for PathBuf {}
impl Eq for Url {}
impl<T> Eq for *const T {}
impl Eq for Ipv4Addr {}
impl<K> Eq for KeyRef<K> where K: Eq {}
impl<S> Eq for UniCase<S> where S: AsRef<str> {}
impl Eq for PatVerbatim {}
impl Eq for Key {}
impl Eq for ResourceDef {}
impl<Idx> Eq for RangeInclusive<Idx> where Idx: Eq {}
impl<K, V> Eq for BTreeMap<K, V> where K: Eq, V: Eq {}
impl Eq for {unknown} {}
impl<B> Eq for Cow<B> where B: Eq, B: ToOwned {}
impl Eq for Scheme {}
impl Eq for ItemVerbatim {}
impl Eq for Algorithm {}
impl Eq for Infallible {}
impl Eq for str {}
impl<T, S> Eq for IndexSet<T, S> where T: Eq, T: Hash, S: BuildHasher {}
impl Eq for NameServerStats {}
struct Thread;
struct ThreadBound<T>;
struct MapErr<S, F>;
struct Drain<T>;
struct Task;
struct FramedWrite<T, E>;
struct Content;
struct SocketAddr;
struct Reason;
struct CStr;
struct Iter<T>;
struct Select;
struct Iter<T>;
struct AssertUnwindSafe<T>;
trait AsyncContextParts<A> {}
impl<A> AsyncContextParts<A> for Context<A> where A: Actor, <A as Actor>::Context = Context<A> {}
struct Port<T>;
struct Iter<T>;
struct RareByteOffsets;
struct VacantEntry<K, V>;
struct Result<T, E>;
struct Key;
struct IntoIter;
struct Overlapped;
struct Buf;
struct ScalarRange;
struct InnerConnectorResponseB<T, Io1, Io2>;
struct Framed<T, U>;
struct StdoutLock;
struct SkipWhile<I, P>;
struct ParseOptions;
struct Pin<P>;
struct c_void;
struct Rsa<T>;
struct TrySendError<T>;
struct Data<T>;
struct TokenTree;
struct IntoIter<K, V>;
struct IterResult<I>;
struct Weak<T>;
struct ZlibEncoder<R>;
struct MutexGuard<T>;
struct Receiver<T>;
struct SendError<T, E>;
struct Bound<T>;
struct SymmetricDifference<T>;
struct Url;
struct NaiveDateTime;
struct DeflateEncoder<R>;
struct RawEntryBuilder<K, V, S>;
struct RecvStream;
struct TcpListener;
struct Drain<K, V>;
struct Components;
struct SilentDebug<T>;
struct ByteClasses;
struct SourceFile;
struct ServiceResponse<B>;
struct Url;
trait Strategy {}
impl Strategy for OnUnwind {}
impl Strategy for OnSuccess {}
impl Strategy for Always {}
struct Punctuated<T, P>;
struct Iter<K, V>;
struct Handle;
struct Spawn<T>;
struct PathAndQuery;
struct SplitPaths;
struct MapInitErrFuture<A, F, E>;
struct CapturesDebug;
struct BrotliDecoder<R>;
struct OneshotDnsResponseReceiver<F>;
struct RangeFrom<Idx>;
struct Barrier;
struct Repeat<T, E>;
struct Value;
struct UnixListener;
struct PhantomData<T>;
struct RawEntryMut<K, V, S>;
struct PollOpt;
struct RegexSet;
struct Chunks<S>;
struct RxFields<T>;
struct InternalNumeric;
struct Stderr;
struct Span;
struct ActorWithSmallMailBox;
struct Regex;
struct Mime;
struct AtomicPtr<T>;
struct ServiceRequest;
struct FlattenStream<F>;
struct Selector;
struct IoSliceMut;
struct StderrLock;
struct BoxStd;
struct IterOk<I, E>;
struct Slot;
struct FramedRead<T, D>;
struct Key<T>;
struct Framed<T, B>;
struct BsDebug;
struct Ready;
struct ResponseBody<B>;
struct IntoIter<T>;
struct MultiGzDecoder<R>;
struct OwningRefMut<O, T>;
struct Iter<K>;
struct Mdf;
struct LookupIpFuture<C>;
struct SetReadiness;
struct Results<S, E>;
struct GzDecoder<W>;
struct Codec;
struct SourceFile;
struct LinesCodec;
struct Inner;
struct AtomicBool;
struct Keys<K, V>;
struct VecDeque<T>;
struct Buffered<S>;
struct AddressSender<A>;
struct Waker;
struct SpawnHandle<Item, Error>;
struct SocketAddrV4;
struct FromErr<S, E>;
struct Poll;
struct ClassBytesRange;
struct Certificate;
struct PoisonError<T>;
struct DirEntry;
struct Filter<I, P>;
struct Socket;
struct FramedWrite<T, E>;
struct Iter<I>;
struct Keys<K, V>;
struct TokenStream;
struct RegValue;
struct Key<T>;
struct TransformFromErrFuture<T, S, E>;
struct Reactor;
struct Task;
struct UdpSocket;
struct Error;
struct Error;
struct Ping;
struct TcpStream;
struct Mutex<T>;
struct Filter;
struct Literal;
struct ThreadRng;
struct Sender<T>;
struct SelectedOperation;
struct ActorResponse<A, I, E>;
struct Enter;
struct BorrowMutError;
struct TrySendError<T>;
struct InOrderError<E>;
struct Request<T>;
struct Isaac64Core;
struct Intersection<T, S>;
struct Ident;
struct ListServicesFuture;
struct BytesCodec;
struct Name;
struct Slice;
struct SyncFailure<T>;
struct Values<K, V>;
struct KeyValues;
struct ThreadPool;
struct Regex;
struct ParValues<K, V>;
struct AsyncResolver;
struct SendError<T>;
struct FramedRead<T, D>;
struct DeflateDecoder<R>;
struct Of;
struct Writer;
struct ThreadRng;
struct ServiceInfoFuture;
struct JoinHandle<T>;
struct InternalBacktrace;
struct CodePoint;
struct IntoParIter<K, V>;
struct Ipv6Addr;
trait MessageType {}
impl MessageType for Request<Box<dyn Stream<Item = Bytes, Error = PayloadError>>> {}
impl MessageType for ResponseHead {}
struct Once<T>;
struct GzEncoder<R>;
struct Hex;
struct SendError<T>;
struct Union<T>;
struct Response<I, E>;
struct RangeMut<K, V>;
struct Prioritized<B>;
struct FixedOffset;
struct SplitInternal<P>;
struct StateFlags;
struct IntoIter<T>;
struct Logger;
struct RwLockWriteGuard<T>;
struct Ref<T>;
struct OccupiedEntry<K, V>;
struct FromCache;
struct ClientCodec;
struct HeaderMap<T>;
struct Events;
struct Cell<T>;
struct Drain<K>;
struct AddressReceiver<A>;
struct Group;
struct TcpListener;
struct RegexSet;
struct GzDecoder<R>;
struct SyncArbiter<A>;
struct Ident;
struct Span;
struct ArrayToken;
struct Background<F, G>;
struct Decoder;
struct Scan<I, St, F>;
struct FromFn<F>;
struct UdpSocket;
struct TokenTreeIter;
struct IntoIter<T>;
struct ULiteral;
struct ZlibDecoder<R>;
struct LineWriter<W>;
struct SettingsFlags;
struct Sender<M>;
struct Map<I, F>;
struct MailboxError;
struct QueryFuture<C>;
struct ArbiterCommand;
struct ParIter<K, V>;
struct IntoIter<T>;
struct Vars;
struct RawValue;
struct RangeTo<Idx>;
struct InsertCache;
struct BytesCodec;
trait Ops {
type Flush;
}
impl Ops for {unknown} {
type Flush = {unknown};
}
impl Ops for {unknown} {
type Flush = {unknown};
}
struct WindowsBuffer;
struct DeflateDecoder<W>;
struct IoStandardStream;
struct Difference<T>;
struct WriterInner<W>;
struct Ansi<W>;
struct BrotliEncoder<W>;
struct CrcWriter<W>;
struct Writer;
struct WriteEarlyData;
struct GzEncoder<W>;
struct LossyStandardStream<W>;
struct BufferedStandardStream;
struct Hasher;
struct Writer;
struct ZlibDecoder<W>;
struct StdoutRaw;
struct StandardStreamLock;
struct ZlibEncoder<W>;
struct DeflateEncoder<W>;
struct Writer;
struct IoStandardStreamLock;
struct WriterFormatter;
struct StandardStream;
struct Buffer;
struct BorrowError;
struct Union<T, S>;
struct UnixSocket;
struct StreamOwned<S, T>;
struct Events;
struct Awakener;
struct ReceiverCtl;
struct UnixListener;
struct UnixListener;
struct UdpSocket;
struct TcpListener;
struct UnixDatagram;
struct Receiver<T>;
struct RefCell<T>;
struct EventedFd;
struct Timer<T>;
struct Awakener;
struct MyRegistration;
struct RawVacantEntryMut<K, V, S>;
struct SocketListener;
struct Stream<S, IO>;
struct LexError;
struct TcpBuilder;
struct BrotliEncoder<R>;
struct PathBuf;
struct Writer<W, D>;
struct Key<T>;
struct RequestHead;
struct Binding;
struct IsoWeek;
struct Sender<T>;
struct Position;
struct Utf8Sequence;
struct ReuniteError<T>;
struct Metadata;
struct Dsa<T>;
struct TakeWhile<I, P>;
struct NaiveTime;
struct MapErrFuture<A, F, E>;
struct SplitNInternal<P>;
struct Handshaking<T, B>;
struct BytesCodec;
struct WeakAddressSender<A>;
struct Split<B>;
struct PayloadDecoder;
struct Difference<T, S>;
struct SleepService;
struct StandardConnection;
struct Stack;
trait Now {}
impl Now for Clock {}
struct MatchIndicesInternal<P>;
struct Reverse<T>;
struct LinesCodec;
struct SymmetricDifference<T, S1, S2>;
struct Union<T, S>;
struct Date<Tz>;
struct MatchesInternal<P>;
struct ClientPayloadCodec;
struct ParIntersection<T, S1, S2>;
struct SymmetricDifference<T, S>;
struct SipHasher13;
struct IdHasher;
struct ParDifference<T, S1, S2>;
struct Entry<K, V>;
struct VacantEntry<K, V>;
struct SipHasher;
struct ParUnion<T, S1, S2>;
struct Builder;
struct Act;
struct Guard<T>;
struct Difference<T, S>;
struct ParSymmetricDifference<T, S1, S2>;
struct LruCache<K, V, S>;
struct DistIter<D, R, T>;
struct FnvHasher;
struct Intersection<T, S>;
struct CachedThreadLocal<T>;
struct Entered<P>;
struct DateTime<Tz>;
struct MessageDecoder<T>;
struct Mutex<R, T>;
struct Skip<I>;
struct WaitForConnection<Io>;
struct InnerConnectorResponseA<T, Io1, Io2>;
struct StreamDeserializer<R, T>;
struct ResolveError;
struct OccupiedEntry<K, V>;
struct DecodeUtf16<I>;
struct MatchKind;
struct Lines<B>;
struct CurrentThread<P>;
struct ScopeGuard<T, F, S>;
struct Take<I>;
struct Repeat<A>;
struct Connection<T, B>;
struct OpenConnection<F, Io>;
struct Wait<S>;
struct ResultShunt<I, E>;
struct IntoIter<T>;
struct Resolver;
struct IdHasher;
struct Connection<T, B>;
struct Drain<T>;
struct Encoder<B>;
struct IterBinomial<T>;
struct Item<A>;
struct Payload;
struct Srv;
struct Map<S, F>;
struct OnceWith<F>;
struct zx_packet_type_t;
struct EnumKeys;
struct Unfold<T, F, Fut>;
struct Decoder<S>;
struct IntoIter<A>;
struct ThreadLocal<T>;
struct FilterMap<S, F>;
struct Payload;
struct Receiver<T>;
struct Payload;
struct Payload<S>;
struct PlStream<Io>;
struct RawIntoIter<T>;
struct EnumValues;
struct ArcSwapAny<T, S>;
struct DefaultHasher;
struct TrustAnchor;
struct IntoIter<T>;
struct Cloned<I>;
struct Drain<T>;
struct UdpClientConnect<MF>;
struct Bytes<R>;
struct Drain<K>;
struct StreamFindIter<R, S>;
struct LinkedHashMap<K, V, S>;
struct IntoIter<K>;
struct Cycle<I>;
struct ReadDir;
struct Iter;
struct DistIter<D, R, T>;
struct RepeatWith<F>;
struct RawIntoIter<T>;
struct GenericSplitN<I>;
struct Handshake<T, B>;
struct Incoming;
struct HashMap<K, V, S>;
struct Resolver<T>;
struct TryIter<T>;
struct Drain<T>;
struct Fuse<I>;
struct Rev<T>;
struct IndexSet<T, S>;
struct IntoIter<T>;
struct Drain<K>;
struct StreamLog<B>;
struct OptionShunt<I>;
struct RawDrain<T>;
struct Context<A>;
struct RawDrain<T>;
struct Copied<I>;
struct TrySend<C, P>;
struct Drain<T>;
struct IntoIter<T>;
struct IntoIter<K>;
struct Blocks;
struct EnumSetupInstances;
struct Iter<T>;
struct LineColIterator<I>;
struct TimeoutService<S>;
struct ValueDrain<T>;
struct NFA<S>;
struct DnsExchangeConnectInner<F, S, R>;
struct Shutdown<A>;
struct ConnectError;
struct MapFuture<A, F, Response>;
Sign up for free to join this conversation on GitHub. Already have an account? Sign in to comment