comparison: src/instance.rs
src/instance.rs
- branch
- dev
- changeset 171
- fa8df5a14486
- parent 170
- 221728aeeb7e
- child 173
- 102421d462d1
equal
deleted
inserted
replaced
| 170:221728aeeb7e | 171:fa8df5a14486 |
|---|---|
| 326 X: Space, | 326 X: Space, |
| 327 D: Decomposition<X>, | 327 D: Decomposition<X>, |
| 328 { | 328 { |
| 329 /// Decomposes self according to `decomposer`, and evaluate `f` on the result. | 329 /// Decomposes self according to `decomposer`, and evaluate `f` on the result. |
| 330 /// Consumes self. | 330 /// Consumes self. |
| 331 #[inline] | |
| 331 fn eval_decompose<'b, R>(self, f: impl FnOnce(D::Decomposition<'b>) -> R) -> R | 332 fn eval_decompose<'b, R>(self, f: impl FnOnce(D::Decomposition<'b>) -> R) -> R |
| 332 where | 333 where |
| 333 X: 'b, | 334 X: 'b, |
| 334 Self: 'b; | 335 Self: 'b, |
| 336 { | |
| 337 f(self.decompose()) | |
| 338 } | |
| 335 | 339 |
| 336 /// Does a light decomposition of self `decomposer`, and evaluates `f` on the result. | 340 /// Does a light decomposition of self `decomposer`, and evaluates `f` on the result. |
| 337 /// Does not consume self. | 341 /// Does not consume self. |
| 338 fn eval_ref_decompose<'b, R>(&'b self, f: impl FnOnce(D::Reference<'b>) -> R) -> R | 342 fn eval_ref<'b, R>(&'b self, f: impl FnOnce(D::Reference<'b>) -> R) -> R |
| 339 where | 343 where |
| 340 X: 'b, | 344 X: 'b, |
| 341 Self: 'b; | 345 Self: 'b; |
| 342 | 346 |
| 343 #[inline] | 347 #[inline] |
| 344 /// Evaluates `f` or `g` depending on whether a reference or owned value is available. | 348 /// Evaluates `f` or `g` depending on whether a reference or owned value is available. |
| 345 fn either<'b, R>( | 349 fn either<'b, R>( |
| 346 self, | 350 self, |
| 347 f: impl FnOnce(D::Decomposition<'b>) -> R, | 351 f: impl FnOnce(D::Decomposition<'b>) -> R, |
| 348 g: impl FnOnce(D::Reference<'b>) -> R, | 352 _g: impl FnOnce(D::Reference<'b>) -> R, |
| 349 ) -> R | 353 ) -> R |
| 350 where | 354 where |
| 351 X: 'b, | 355 X: 'b, |
| 352 Self: 'b, | 356 Self: 'b, |
| 353 { | 357 { |
| 354 self.eval_decompose(f) | 358 self.eval_decompose(f) |
| 355 } | 359 } |
| 356 | 360 |
| 357 /// Returns an owned instance of `X`, cloning or converting non-true instances when necessary. | 361 /// Returns an owned instance of `X`, cloning or converting non-true instances when necessary. |
| 358 fn own(self) -> X::Principal; | 362 fn own(self) -> X::Principal; |
| 363 | |
| 364 fn decompose<'b>(self) -> D::Decomposition<'b> | |
| 365 where | |
| 366 Self: 'b; | |
| 359 | 367 |
| 360 /// Returns an owned instance or reference to `X`, converting non-true instances when necessary. | 368 /// Returns an owned instance or reference to `X`, converting non-true instances when necessary. |
| 361 /// | 369 /// |
| 362 /// Default implementation uses [`Self::own`]. Consumes the input. | 370 /// Default implementation uses [`Self::own`]. Consumes the input. |
| 363 fn cow<'b>(self) -> MyCow<'b, X::Principal> | 371 fn cow<'b>(self) -> MyCow<'b, X::Principal> |
| 385 { | 393 { |
| 386 f(MyCow::Owned(self)) | 394 f(MyCow::Owned(self)) |
| 387 } | 395 } |
| 388 | 396 |
| 389 #[inline] | 397 #[inline] |
| 390 fn eval_decompose<'b, R>(self, f: impl FnOnce(MyCow<'b, X>) -> R) -> R | 398 fn eval_ref<'b, R>(&'b self, f: impl FnOnce(&'b X) -> R) -> R |
| 391 where | |
| 392 X: 'b, | |
| 393 Self: 'b, | |
| 394 { | |
| 395 f(MyCow::Owned(self)) | |
| 396 } | |
| 397 | |
| 398 #[inline] | |
| 399 fn eval_ref_decompose<'b, R>(&'b self, f: impl FnOnce(&'b X) -> R) -> R | |
| 400 where | 399 where |
| 401 X: 'b, | 400 X: 'b, |
| 402 Self: 'b, | 401 Self: 'b, |
| 403 { | 402 { |
| 404 f(self) | 403 f(self) |
| 414 where | 413 where |
| 415 Self: 'b, | 414 Self: 'b, |
| 416 { | 415 { |
| 417 self.cow_owned() | 416 self.cow_owned() |
| 418 } | 417 } |
| 418 | |
| 419 #[inline] | |
| 420 fn decompose<'b>(self) -> MyCow<'b, X> | |
| 421 where | |
| 422 Self: 'b, | |
| 423 { | |
| 424 MyCow::Owned(self) | |
| 425 } | |
| 419 } | 426 } |
| 420 | 427 |
| 421 impl<'a, X: Space> Instance<X, BasicDecomposition> for &'a X { | 428 impl<'a, X: Space> Instance<X, BasicDecomposition> for &'a X { |
| 422 #[inline] | 429 #[inline] |
| 423 fn either<'b, R>(self, _f: impl FnOnce(MyCow<'b, X>) -> R, g: impl FnOnce(&'b X) -> R) -> R | 430 fn either<'b, R>(self, _f: impl FnOnce(MyCow<'b, X>) -> R, g: impl FnOnce(&'b X) -> R) -> R |
| 426 { | 433 { |
| 427 g(self) | 434 g(self) |
| 428 } | 435 } |
| 429 | 436 |
| 430 #[inline] | 437 #[inline] |
| 431 fn eval_decompose<'b, R>(self, f: impl FnOnce(MyCow<'b, X>) -> R) -> R | 438 fn eval_ref<'b, R>(&'b self, f: impl FnOnce(&'b X) -> R) -> R |
| 432 where | |
| 433 X: 'b, | |
| 434 Self: 'b, | |
| 435 { | |
| 436 f(MyCow::Borrowed(self)) | |
| 437 } | |
| 438 | |
| 439 #[inline] | |
| 440 fn eval_ref_decompose<'b, R>(&'b self, f: impl FnOnce(&'b X) -> R) -> R | |
| 441 where | 439 where |
| 442 X: 'b, | 440 X: 'b, |
| 443 Self: 'b, | 441 Self: 'b, |
| 444 { | 442 { |
| 445 f(*self) | 443 f(*self) |
| 455 where | 453 where |
| 456 Self: 'b, | 454 Self: 'b, |
| 457 { | 455 { |
| 458 self.cow_owned() | 456 self.cow_owned() |
| 459 } | 457 } |
| 458 | |
| 459 #[inline] | |
| 460 fn decompose<'b>(self) -> MyCow<'b, X> | |
| 461 where | |
| 462 Self: 'b, | |
| 463 { | |
| 464 MyCow::Borrowed(self) | |
| 465 } | |
| 460 } | 466 } |
| 461 | 467 |
| 462 impl<'a, X: Space> Instance<X, BasicDecomposition> for &'a mut X { | 468 impl<'a, X: Space> Instance<X, BasicDecomposition> for &'a mut X { |
| 463 #[inline] | 469 #[inline] |
| 464 fn either<'b, R>(self, _f: impl FnOnce(MyCow<'b, X>) -> R, g: impl FnOnce(&'b X) -> R) -> R | 470 fn either<'b, R>(self, _f: impl FnOnce(MyCow<'b, X>) -> R, g: impl FnOnce(&'b X) -> R) -> R |
| 467 { | 473 { |
| 468 g(self) | 474 g(self) |
| 469 } | 475 } |
| 470 | 476 |
| 471 #[inline] | 477 #[inline] |
| 472 fn eval_decompose<'b, R>(self, f: impl FnOnce(MyCow<'b, X>) -> R) -> R | 478 fn eval_ref<'b, R>(&'b self, f: impl FnOnce(&'b X) -> R) -> R |
| 473 where | |
| 474 X: 'b, | |
| 475 Self: 'b, | |
| 476 { | |
| 477 f(EitherDecomp::Borrowed(self)) | |
| 478 } | |
| 479 | |
| 480 #[inline] | |
| 481 fn eval_ref_decompose<'b, R>(&'b self, f: impl FnOnce(&'b X) -> R) -> R | |
| 482 where | 479 where |
| 483 X: 'b, | 480 X: 'b, |
| 484 Self: 'b, | 481 Self: 'b, |
| 485 { | 482 { |
| 486 f(*self) | 483 f(*self) |
| 496 where | 493 where |
| 497 Self: 'b, | 494 Self: 'b, |
| 498 { | 495 { |
| 499 self.cow_owned() | 496 self.cow_owned() |
| 500 } | 497 } |
| 498 | |
| 499 #[inline] | |
| 500 fn decompose<'b>(self) -> MyCow<'b, X> | |
| 501 where | |
| 502 Self: 'b, | |
| 503 { | |
| 504 MyCow::Borrowed(self) | |
| 505 } | |
| 501 } | 506 } |
| 502 | 507 |
| 503 impl<'a, X: Space> Instance<X, BasicDecomposition> for MyCow<'a, X> { | 508 impl<'a, X: Space> Instance<X, BasicDecomposition> for MyCow<'a, X> { |
| 504 #[inline] | 509 #[inline] |
| 505 fn either<'b, R>(self, f: impl FnOnce(MyCow<'b, X>) -> R, _g: impl FnOnce(&'b X) -> R) -> R | 510 fn either<'b, R>(self, f: impl FnOnce(MyCow<'b, X>) -> R, _g: impl FnOnce(&'b X) -> R) -> R |
| 508 { | 513 { |
| 509 f(self) | 514 f(self) |
| 510 } | 515 } |
| 511 | 516 |
| 512 #[inline] | 517 #[inline] |
| 513 fn eval_decompose<'b, R>(self, f: impl FnOnce(MyCow<'b, X>) -> R) -> R | 518 fn eval_ref<'b, R>(&'b self, f: impl FnOnce(&'b X) -> R) -> R |
| 514 where | |
| 515 X: 'b, | |
| 516 Self: 'b, | |
| 517 { | |
| 518 f(self) | |
| 519 } | |
| 520 | |
| 521 #[inline] | |
| 522 fn eval_ref_decompose<'b, R>(&'b self, f: impl FnOnce(&'b X) -> R) -> R | |
| 523 where | 519 where |
| 524 X: 'b, | 520 X: 'b, |
| 525 Self: 'b, | 521 Self: 'b, |
| 526 { | 522 { |
| 527 match self { | 523 match self { |
| 539 fn cow<'b>(self) -> MyCow<'b, X::Principal> | 535 fn cow<'b>(self) -> MyCow<'b, X::Principal> |
| 540 where | 536 where |
| 541 Self: 'b, | 537 Self: 'b, |
| 542 { | 538 { |
| 543 self.cow_owned() | 539 self.cow_owned() |
| 540 } | |
| 541 | |
| 542 #[inline] | |
| 543 fn decompose<'b>(self) -> MyCow<'b, X> | |
| 544 where | |
| 545 Self: 'b, | |
| 546 { | |
| 547 self | |
| 544 } | 548 } |
| 545 } | 549 } |
| 546 | 550 |
| 547 /// Marker type for mutable decompositions to be used with [`InstanceMut`]. | 551 /// Marker type for mutable decompositions to be used with [`InstanceMut`]. |
| 548 pub trait DecompositionMut<X: Space>: Sized { | 552 pub trait DecompositionMut<X: Space>: Sized { |
