delegate refresh to function

@@ -118,8 +118,8 @@ class _RxImpl<T> implements RxInterface<T> {
   // ignore: avoid_equals_and_hash_code_on_mutable_classes
   // ignore: avoid_equals_and_hash_code_on_mutable_classes
   bool operator ==(dynamic o) {
   bool operator ==(dynamic o) {
     // Todo, find a common implementation for the hashCode of different Types.
     // Todo, find a common implementation for the hashCode of different Types.
-    if (o is T) return _value == o;
-    if (o is RxInterface<T>) return _value == o.value;
+    if (o is T) return value == o;
+    if (o is RxInterface<T>) return value == o.value;
     return false;
     return false;
   }
   }
 
 
@@ -165,6 +165,7 @@ class _RxImpl<T> implements RxInterface<T> {
   }
   }
 
 
   Stream<T> get stream => subject.stream;
   Stream<T> get stream => subject.stream;
+
   StreamSubscription<T> listen(void Function(T) onData,
   StreamSubscription<T> listen(void Function(T) onData,
           {Function onError, void Function() onDone, bool cancelOnError}) =>
           {Function onError, void Function() onDone, bool cancelOnError}) =>
       stream.listen(onData, onError: onError, onDone: onDone);
       stream.listen(onData, onError: onError, onDone: onDone);

@@ -3,13 +3,13 @@ part of 'rx_impl.dart';
 /// Base Rx class for all num Rx's.
 /// Base Rx class for all num Rx's.
 class _BaseRxNum<T extends num> extends _RxImpl<T> {
 class _BaseRxNum<T extends num> extends _RxImpl<T> {
   /// Addition operator. */
   /// Addition operator. */
-  num operator +(num other) => _value + other;
+  num operator +(num other) => value + other;
 
 
   /// Subtraction operator.
   /// Subtraction operator.
-  num operator -(num other) => _value - other;
+  num operator -(num other) => value - other;
 
 
   /// Multiplication operator.
   /// Multiplication operator.
-  num operator *(num other) => _value * other;
+  num operator *(num other) => value * other;
 
 
   /// Euclidean modulo operator.
   /// Euclidean modulo operator.
   ///
   ///
@@ -24,10 +24,10 @@ class _BaseRxNum<T extends num> extends _RxImpl<T> {
   /// The sign of the returned value `r` is always positive.
   /// The sign of the returned value `r` is always positive.
   ///
   ///
   /// See [remainder] for the remainder of the truncating division.
   /// See [remainder] for the remainder of the truncating division.
-  num operator %(num other) => _value % other;
+  num operator %(num other) => value % other;
 
 
   /// Division operator.
   /// Division operator.
-  double operator /(num other) => _value / other;
+  double operator /(num other) => value / other;
 
 
   /// Truncating division operator.
   /// Truncating division operator.
   ///
   ///
@@ -36,10 +36,10 @@ class _BaseRxNum<T extends num> extends _RxImpl<T> {
   ///
   ///
   /// If both operands are [int]s then `a ~/ b` performs the truncating
   /// If both operands are [int]s then `a ~/ b` performs the truncating
   /// integer division.
   /// integer division.
-  int operator ~/(num other) => _value ~/ other;
+  int operator ~/(num other) => value ~/ other;
 
 
   /// Negate operator.
   /// Negate operator.
-  num operator -() => -_value;
+  num operator -() => -value;
 
 
   /// Returns the remainder of the truncating division of `this` by [other].
   /// Returns the remainder of the truncating division of `this` by [other].
   ///
   ///
@@ -47,40 +47,40 @@ class _BaseRxNum<T extends num> extends _RxImpl<T> {
   /// `this == (this ~/ other) * other + r`.
   /// `this == (this ~/ other) * other + r`.
   /// As a consequence the remainder `r` has the same sign as the divider
   /// As a consequence the remainder `r` has the same sign as the divider
   /// `this`.
   /// `this`.
-  num remainder(num other) => _value.remainder(other);
+  num remainder(num other) => value.remainder(other);
 
 
   /// Relational less than operator.
   /// Relational less than operator.
-  bool operator <(num other) => _value < other;
+  bool operator <(num other) => value < other;
 
 
   /// Relational less than or equal operator.
   /// Relational less than or equal operator.
-  bool operator <=(num other) => _value <= other;
+  bool operator <=(num other) => value <= other;
 
 
   /// Relational greater than operator.
   /// Relational greater than operator.
-  bool operator >(num other) => _value > other;
+  bool operator >(num other) => value > other;
 
 
   /// Relational greater than or equal operator.
   /// Relational greater than or equal operator.
-  bool operator >=(num other) => _value >= other;
+  bool operator >=(num other) => value >= other;
 
 
   /// True if the number is the double Not-a-Number value; otherwise, false.
   /// True if the number is the double Not-a-Number value; otherwise, false.
-  bool get isNaN => _value.isNaN;
+  bool get isNaN => value.isNaN;
 
 
   /// True if the number is negative; otherwise, false.
   /// True if the number is negative; otherwise, false.
   ///
   ///
   /// Negative numbers are those less than zero, and the double `-0.0`.
   /// Negative numbers are those less than zero, and the double `-0.0`.
-  bool get isNegative => _value.isNegative;
+  bool get isNegative => value.isNegative;
 
 
   /// True if the number is positive infinity or negative infinity; otherwise,
   /// True if the number is positive infinity or negative infinity; otherwise,
   /// false.
   /// false.
-  bool get isInfinite => _value.isInfinite;
+  bool get isInfinite => value.isInfinite;
 
 
   /// True if the number is finite; otherwise, false.
   /// True if the number is finite; otherwise, false.
   ///
   ///
   /// The only non-finite numbers are NaN, positive infinity, and
   /// The only non-finite numbers are NaN, positive infinity, and
   /// negative infinity.
   /// negative infinity.
-  bool get isFinite => _value.isFinite;
+  bool get isFinite => value.isFinite;
 
 
   /// Returns the absolute value of this [num].
   /// Returns the absolute value of this [num].
-  num abs() => _value.abs();
+  num abs() => value.abs();
 
 
   /// Returns minus one, zero or plus one depending on the sign and
   /// Returns minus one, zero or plus one depending on the sign and
   /// numerical value of the number.
   /// numerical value of the number.
@@ -98,7 +98,7 @@ class _BaseRxNum<T extends num> extends _RxImpl<T> {
   ///     n == n.sign * n.abs()
   ///     n == n.sign * n.abs()
   ///
   ///
   /// for all numbers `n` (except NaN, because NaN isn't `==` to itself).
   /// for all numbers `n` (except NaN, because NaN isn't `==` to itself).
-  num get sign => _value.sign;
+  num get sign => value.sign;
 
 
   /// Returns the integer closest to `this`.
   /// Returns the integer closest to `this`.
   ///
   ///
@@ -106,23 +106,23 @@ class _BaseRxNum<T extends num> extends _RxImpl<T> {
   ///  `(3.5).round() == 4` and `(-3.5).round() == -4`.
   ///  `(3.5).round() == 4` and `(-3.5).round() == -4`.
   ///
   ///
   /// If `this` is not finite (`NaN` or infinity), throws an [UnsupportedError].
   /// If `this` is not finite (`NaN` or infinity), throws an [UnsupportedError].
-  int round() => _value.round();
+  int round() => value.round();
 
 
   /// Returns the greatest integer no greater than `this`.
   /// Returns the greatest integer no greater than `this`.
   ///
   ///
   /// If `this` is not finite (`NaN` or infinity), throws an [UnsupportedError].
   /// If `this` is not finite (`NaN` or infinity), throws an [UnsupportedError].
-  int floor() => _value.floor();
+  int floor() => value.floor();
 
 
   /// Returns the least integer no smaller than `this`.
   /// Returns the least integer no smaller than `this`.
   ///
   ///
   /// If `this` is not finite (`NaN` or infinity), throws an [UnsupportedError].
   /// If `this` is not finite (`NaN` or infinity), throws an [UnsupportedError].
-  int ceil() => _value.ceil();
+  int ceil() => value.ceil();
 
 
   /// Returns the integer obtained by discarding any fractional
   /// Returns the integer obtained by discarding any fractional
   /// digits from `this`.
   /// digits from `this`.
   ///
   ///
   /// If `this` is not finite (`NaN` or infinity), throws an [UnsupportedError].
   /// If `this` is not finite (`NaN` or infinity), throws an [UnsupportedError].
-  int truncate() => _value.truncate();
+  int truncate() => value.truncate();
 
 
   /// Returns the double integer value closest to `this`.
   /// Returns the double integer value closest to `this`.
   ///
   ///
@@ -140,7 +140,7 @@ class _BaseRxNum<T extends num> extends _RxImpl<T> {
   /// The result is always a double.
   /// The result is always a double.
   /// If this is a numerically large integer, the result may be an infinite
   /// If this is a numerically large integer, the result may be an infinite
   /// double.
   /// double.
-  double roundToDouble() => _value.roundToDouble();
+  double roundToDouble() => value.roundToDouble();
 
 
   /// Returns the greatest double integer value no greater than `this`.
   /// Returns the greatest double integer value no greater than `this`.
   ///
   ///
@@ -153,7 +153,7 @@ class _BaseRxNum<T extends num> extends _RxImpl<T> {
   /// The result is always a double.
   /// The result is always a double.
   /// If this is a numerically large integer, the result may be an infinite
   /// If this is a numerically large integer, the result may be an infinite
   /// double.
   /// double.
-  double floorToDouble() => _value.floorToDouble();
+  double floorToDouble() => value.floorToDouble();
 
 
   /// Returns the least double integer value no smaller than `this`.
   /// Returns the least double integer value no smaller than `this`.
   ///
   ///
@@ -166,7 +166,7 @@ class _BaseRxNum<T extends num> extends _RxImpl<T> {
   /// The result is always a double.
   /// The result is always a double.
   /// If this is a numerically large integer, the result may be an infinite
   /// If this is a numerically large integer, the result may be an infinite
   /// double.
   /// double.
-  double ceilToDouble() => _value.ceilToDouble();
+  double ceilToDouble() => value.ceilToDouble();
 
 
   /// Returns the double integer value obtained by discarding any fractional
   /// Returns the double integer value obtained by discarding any fractional
   /// digits from the double value of `this`.
   /// digits from the double value of `this`.
@@ -181,7 +181,7 @@ class _BaseRxNum<T extends num> extends _RxImpl<T> {
   /// The result is always a double.
   /// The result is always a double.
   /// If this is a numerically large integer, the result may be an infinite
   /// If this is a numerically large integer, the result may be an infinite
   /// double.
   /// double.
-  double truncateToDouble() => _value.truncateToDouble();
+  double truncateToDouble() => value.truncateToDouble();
 
 
   /// Returns this [num] clamped to be in the range [lowerLimit]-[upperLimit].
   /// Returns this [num] clamped to be in the range [lowerLimit]-[upperLimit].
   ///
   ///
@@ -192,17 +192,17 @@ class _BaseRxNum<T extends num> extends _RxImpl<T> {
   /// The arguments [lowerLimit] and [upperLimit] must form a valid range where
   /// The arguments [lowerLimit] and [upperLimit] must form a valid range where
   /// `lowerLimit.compareTo(upperLimit) <= 0`.
   /// `lowerLimit.compareTo(upperLimit) <= 0`.
   num clamp(num lowerLimit, num upperLimit) =>
   num clamp(num lowerLimit, num upperLimit) =>
-      _value.clamp(lowerLimit, upperLimit);
+      value.clamp(lowerLimit, upperLimit);
 
 
   /// Truncates this [num] to an integer and returns the result as an [int]. */
   /// Truncates this [num] to an integer and returns the result as an [int]. */
-  int toInt() => _value.toInt();
+  int toInt() => value.toInt();
 
 
   /// Return this [num] as a [double].
   /// Return this [num] as a [double].
   ///
   ///
   /// If the number is not representable as a [double], an
   /// If the number is not representable as a [double], an
   /// approximation is returned. For numerically large integers, the
   /// approximation is returned. For numerically large integers, the
   /// approximation may be infinite.
   /// approximation may be infinite.
-  double toDouble() => _value.toDouble();
+  double toDouble() => value.toDouble();
 
 
   /// Returns a decimal-point string-representation of `this`.
   /// Returns a decimal-point string-representation of `this`.
   ///
   ///
@@ -227,7 +227,7 @@ class _BaseRxNum<T extends num> extends _RxImpl<T> {
   ///     10000000000000000.toStringAsFixed(4); // 10000000000000000.0000
   ///     10000000000000000.toStringAsFixed(4); // 10000000000000000.0000
   ///     5.25.toStringAsFixed(0); // 5
   ///     5.25.toStringAsFixed(0); // 5
   String toStringAsFixed(int fractionDigits) =>
   String toStringAsFixed(int fractionDigits) =>
-      _value.toStringAsFixed(fractionDigits);
+      value.toStringAsFixed(fractionDigits);
 
 
   /// Returns an exponential string-representation of `this`.
   /// Returns an exponential string-representation of `this`.
   ///
   ///
@@ -248,7 +248,7 @@ class _BaseRxNum<T extends num> extends _RxImpl<T> {
   ///     123456.toStringAsExponential(3); // 1.235e+5
   ///     123456.toStringAsExponential(3); // 1.235e+5
   ///     123.toStringAsExponential(0);    // 1e+2
   ///     123.toStringAsExponential(0);    // 1e+2
   String toStringAsExponential([int fractionDigits]) =>
   String toStringAsExponential([int fractionDigits]) =>
-      _value.toStringAsExponential(fractionDigits);
+      value.toStringAsExponential(fractionDigits);
 
 
   /// Converts `this` to a double and returns a string representation with
   /// Converts `this` to a double and returns a string representation with
   /// exactly [precision] significant digits.
   /// exactly [precision] significant digits.
@@ -267,48 +267,48 @@ class _BaseRxNum<T extends num> extends _RxImpl<T> {
   ///     0.00000012345.toStringAsPrecision(15); // 1.23450000000000e-7
   ///     0.00000012345.toStringAsPrecision(15); // 1.23450000000000e-7
   ///     0.0000012345.toStringAsPrecision(15);  // 0.00000123450000000000
   ///     0.0000012345.toStringAsPrecision(15);  // 0.00000123450000000000
   String toStringAsPrecision(int precision) =>
   String toStringAsPrecision(int precision) =>
-      _value.toStringAsPrecision(precision);
+      value.toStringAsPrecision(precision);
 }
 }
 
 
 class RxNum extends _BaseRxNum<num> {}
 class RxNum extends _BaseRxNum<num> {}
 
 
 class RxDouble extends _BaseRxNum<double> {
 class RxDouble extends _BaseRxNum<double> {
   RxDouble([double initial]) {
   RxDouble([double initial]) {
-    _value = initial;
+    value = initial;
   }
   }
 
 
   /// Addition operator.
   /// Addition operator.
-  double operator +(num other) => _value + other;
+  double operator +(num other) => value + other;
 
 
   /// Subtraction operator.
   /// Subtraction operator.
-  double operator -(num other) => _value - other;
+  double operator -(num other) => value - other;
 
 
   /// Multiplication operator.
   /// Multiplication operator.
-  double operator *(num other) => _value * other;
+  double operator *(num other) => value * other;
 
 
-  double operator %(num other) => _value % other;
+  double operator %(num other) => value % other;
 
 
   /// Division operator.
   /// Division operator.
-  double operator /(num other) => _value / other;
+  double operator /(num other) => value / other;
 
 
   /// Truncating division operator.
   /// Truncating division operator.
   ///
   ///
   /// The result of the truncating division `a ~/ b` is equivalent to
   /// The result of the truncating division `a ~/ b` is equivalent to
   /// `(a / b).truncate()`.
   /// `(a / b).truncate()`.
-  int operator ~/(num other) => _value ~/ other;
+  int operator ~/(num other) => value ~/ other;
 
 
   /// Negate operator. */
   /// Negate operator. */
-  double operator -() => -_value;
+  double operator -() => -value;
 
 
   /// Returns the absolute value of this [double].
   /// Returns the absolute value of this [double].
-  double abs() => _value.abs();
+  double abs() => value.abs();
 
 
   /// Returns the sign of the double's numerical value.
   /// Returns the sign of the double's numerical value.
   ///
   ///
   /// Returns -1.0 if the value is less than zero,
   /// Returns -1.0 if the value is less than zero,
   /// +1.0 if the value is greater than zero,
   /// +1.0 if the value is greater than zero,
   /// and the value itself if it is -0.0, 0.0 or NaN.
   /// and the value itself if it is -0.0, 0.0 or NaN.
-  double get sign => _value.sign;
+  double get sign => value.sign;
 
 
   /// Returns the integer closest to `this`.
   /// Returns the integer closest to `this`.
   ///
   ///
@@ -316,23 +316,23 @@ class RxDouble extends _BaseRxNum<double> {
   ///  `(3.5).round() == 4` and `(-3.5).round() == -4`.
   ///  `(3.5).round() == 4` and `(-3.5).round() == -4`.
   ///
   ///
   /// If `this` is not finite (`NaN` or infinity), throws an [UnsupportedError].
   /// If `this` is not finite (`NaN` or infinity), throws an [UnsupportedError].
-  int round() => _value.round();
+  int round() => value.round();
 
 
   /// Returns the greatest integer no greater than `this`.
   /// Returns the greatest integer no greater than `this`.
   ///
   ///
   /// If `this` is not finite (`NaN` or infinity), throws an [UnsupportedError].
   /// If `this` is not finite (`NaN` or infinity), throws an [UnsupportedError].
-  int floor() => _value.floor();
+  int floor() => value.floor();
 
 
   /// Returns the least integer no smaller than `this`.
   /// Returns the least integer no smaller than `this`.
   ///
   ///
   /// If `this` is not finite (`NaN` or infinity), throws an [UnsupportedError].
   /// If `this` is not finite (`NaN` or infinity), throws an [UnsupportedError].
-  int ceil() => _value.ceil();
+  int ceil() => value.ceil();
 
 
   /// Returns the integer obtained by discarding any fractional
   /// Returns the integer obtained by discarding any fractional
   /// digits from `this`.
   /// digits from `this`.
   ///
   ///
   /// If `this` is not finite (`NaN` or infinity), throws an [UnsupportedError].
   /// If `this` is not finite (`NaN` or infinity), throws an [UnsupportedError].
-  int truncate() => _value.truncate();
+  int truncate() => value.truncate();
 
 
   /// Returns the integer double value closest to `this`.
   /// Returns the integer double value closest to `this`.
   ///
   ///
@@ -346,7 +346,7 @@ class RxDouble extends _BaseRxNum<double> {
   /// and `-0.0` is therefore considered closer to negative numbers than `0.0`.
   /// and `-0.0` is therefore considered closer to negative numbers than `0.0`.
   /// This means that for a value, `d` in the range `-0.5 < d < 0.0`,
   /// This means that for a value, `d` in the range `-0.5 < d < 0.0`,
   /// the result is `-0.0`.
   /// the result is `-0.0`.
-  double roundToDouble() => _value.roundToDouble();
+  double roundToDouble() => value.roundToDouble();
 
 
   /// Returns the greatest integer double value no greater than `this`.
   /// Returns the greatest integer double value no greater than `this`.
   ///
   ///
@@ -355,7 +355,7 @@ class RxDouble extends _BaseRxNum<double> {
   ///
   ///
   /// For the purpose of rounding, `-0.0` is considered to be below `0.0`.
   /// For the purpose of rounding, `-0.0` is considered to be below `0.0`.
   /// A number `d` in the range `0.0 < d < 1.0` will return `0.0`.
   /// A number `d` in the range `0.0 < d < 1.0` will return `0.0`.
-  double floorToDouble() => _value.floorToDouble();
+  double floorToDouble() => value.floorToDouble();
 
 
   /// Returns the least integer double value no smaller than `this`.
   /// Returns the least integer double value no smaller than `this`.
   ///
   ///
@@ -364,7 +364,7 @@ class RxDouble extends _BaseRxNum<double> {
   ///
   ///
   /// For the purpose of rounding, `-0.0` is considered to be below `0.0`.
   /// For the purpose of rounding, `-0.0` is considered to be below `0.0`.
   /// A number `d` in the range `-1.0 < d < 0.0` will return `-0.0`.
   /// A number `d` in the range `-1.0 < d < 0.0` will return `-0.0`.
-  double ceilToDouble() => _value.ceilToDouble();
+  double ceilToDouble() => value.ceilToDouble();
 
 
   /// Returns the integer double value obtained by discarding any fractional
   /// Returns the integer double value obtained by discarding any fractional
   /// digits from `this`.
   /// digits from `this`.
@@ -375,12 +375,12 @@ class RxDouble extends _BaseRxNum<double> {
   /// For the purpose of rounding, `-0.0` is considered to be below `0.0`.
   /// For the purpose of rounding, `-0.0` is considered to be below `0.0`.
   /// A number `d` in the range `-1.0 < d < 0.0` will return `-0.0`, and
   /// A number `d` in the range `-1.0 < d < 0.0` will return `-0.0`, and
   /// in the range `0.0 < d < 1.0` it will return 0.0.
   /// in the range `0.0 < d < 1.0` it will return 0.0.
-  double truncateToDouble() => _value.truncateToDouble();
+  double truncateToDouble() => value.truncateToDouble();
 }
 }
 
 
 class RxInt extends _BaseRxNum<int> {
 class RxInt extends _BaseRxNum<int> {
   RxInt([int initial]) {
   RxInt([int initial]) {
-    _value = initial;
+    value = initial;
   }
   }
 
 
   /// Bit-wise and operator.
   /// Bit-wise and operator.
@@ -391,7 +391,7 @@ class RxInt extends _BaseRxNum<int> {
   ///
   ///
   /// If both operands are negative, the result is negative, otherwise
   /// If both operands are negative, the result is negative, otherwise
   /// the result is non-negative.
   /// the result is non-negative.
-  int operator &(int other) => _value & other;
+  int operator &(int other) => value & other;
 
 
   /// Bit-wise or operator.
   /// Bit-wise or operator.
   ///
   ///
@@ -401,7 +401,7 @@ class RxInt extends _BaseRxNum<int> {
   ///
   ///
   /// If both operands are non-negative, the result is non-negative,
   /// If both operands are non-negative, the result is non-negative,
   /// otherwise the result is negative.
   /// otherwise the result is negative.
-  int operator |(int other) => _value | other;
+  int operator |(int other) => value | other;
 
 
   /// Bit-wise exclusive-or operator.
   /// Bit-wise exclusive-or operator.
   ///
   ///
@@ -411,7 +411,7 @@ class RxInt extends _BaseRxNum<int> {
   ///
   ///
   /// If the operands have the same sign, the result is non-negative,
   /// If the operands have the same sign, the result is non-negative,
   /// otherwise the result is negative.
   /// otherwise the result is negative.
-  int operator ^(int other) => _value ^ other;
+  int operator ^(int other) => value ^ other;
 
 
   /// The bit-wise negate operator.
   /// The bit-wise negate operator.
   ///
   ///
@@ -419,7 +419,7 @@ class RxInt extends _BaseRxNum<int> {
   /// the result is a number with the opposite bits set.
   /// the result is a number with the opposite bits set.
   ///
   ///
   /// This maps any integer `x` to `-x - 1`.
   /// This maps any integer `x` to `-x - 1`.
-  int operator ~() => ~_value;
+  int operator ~() => ~value;
 
 
   /// Shift the bits of this integer to the left by [shiftAmount].
   /// Shift the bits of this integer to the left by [shiftAmount].
   ///
   ///
@@ -431,7 +431,7 @@ class RxInt extends _BaseRxNum<int> {
   /// mask.
   /// mask.
   ///
   ///
   /// It is an error if [shiftAmount] is negative.
   /// It is an error if [shiftAmount] is negative.
-  int operator <<(int shiftAmount) => _value << shiftAmount;
+  int operator <<(int shiftAmount) => value << shiftAmount;
 
 
   /// Shift the bits of this integer to the right by [shiftAmount].
   /// Shift the bits of this integer to the right by [shiftAmount].
   ///
   ///
@@ -440,13 +440,13 @@ class RxInt extends _BaseRxNum<int> {
   ///`pow(2, shiftIndex)`.
   ///`pow(2, shiftIndex)`.
   ///
   ///
   /// It is an error if [shiftAmount] is negative.
   /// It is an error if [shiftAmount] is negative.
-  int operator >>(int shiftAmount) => _value >> shiftAmount;
+  int operator >>(int shiftAmount) => value >> shiftAmount;
 
 
   /// Returns this integer to the power of [exponent] modulo [modulus].
   /// Returns this integer to the power of [exponent] modulo [modulus].
   ///
   ///
   /// The [exponent] must be non-negative and [modulus] must be
   /// The [exponent] must be non-negative and [modulus] must be
   /// positive.
   /// positive.
-  int modPow(int exponent, int modulus) => _value.modPow(exponent, modulus);
+  int modPow(int exponent, int modulus) => value.modPow(exponent, modulus);
 
 
   /// Returns the modular multiplicative inverse of this integer
   /// Returns the modular multiplicative inverse of this integer
   /// modulo [modulus].
   /// modulo [modulus].
@@ -454,7 +454,7 @@ class RxInt extends _BaseRxNum<int> {
   /// The [modulus] must be positive.
   /// The [modulus] must be positive.
   ///
   ///
   /// It is an error if no modular inverse exists.
   /// It is an error if no modular inverse exists.
-  int modInverse(int modulus) => _value.modInverse(modulus);
+  int modInverse(int modulus) => value.modInverse(modulus);
 
 
   /// Returns the greatest common divisor of this integer and [other].
   /// Returns the greatest common divisor of this integer and [other].
   ///
   ///
@@ -467,13 +467,13 @@ class RxInt extends _BaseRxNum<int> {
   /// For any integer `x`, `x.gcd(x)` is `x.abs()`.
   /// For any integer `x`, `x.gcd(x)` is `x.abs()`.
   ///
   ///
   /// If both `this` and `other` is zero, the result is also zero.
   /// If both `this` and `other` is zero, the result is also zero.
-  int gcd(int other) => _value.gcd(other);
+  int gcd(int other) => value.gcd(other);
 
 
   /// Returns true if and only if this integer is even.
   /// Returns true if and only if this integer is even.
-  bool get isEven => _value.isEven;
+  bool get isEven => value.isEven;
 
 
   /// Returns true if and only if this integer is odd.
   /// Returns true if and only if this integer is odd.
-  bool get isOdd => _value.isOdd;
+  bool get isOdd => value.isOdd;
 
 
   /// Returns the minimum number of bits required to store this integer.
   /// Returns the minimum number of bits required to store this integer.
   ///
   ///
@@ -495,7 +495,7 @@ class RxInt extends _BaseRxNum<int> {
   /// (-3).bitLength == 2;  // 11111101
   /// (-3).bitLength == 2;  // 11111101
   /// (-4).bitLength == 2;  // 11111100
   /// (-4).bitLength == 2;  // 11111100
   /// ```
   /// ```
-  int get bitLength => _value.bitLength;
+  int get bitLength => value.bitLength;
 
 
   /// Returns the least significant [width] bits of this integer as a
   /// Returns the least significant [width] bits of this integer as a
   /// non-negative number (i.e. unsigned representation).  The returned value
   /// non-negative number (i.e. unsigned representation).  The returned value
@@ -517,7 +517,7 @@ class RxInt extends _BaseRxNum<int> {
   /// ```
   /// ```
   /// x == x.toUnsigned(x.bitLength);
   /// x == x.toUnsigned(x.bitLength);
   /// ```
   /// ```
-  int toUnsigned(int width) => _value.toUnsigned(width);
+  int toUnsigned(int width) => value.toUnsigned(width);
 
 
   /// Returns the least significant [width] bits of this integer, extending the
   /// Returns the least significant [width] bits of this integer, extending the
   /// highest retained bit to the sign.  This is the same as truncating the
   /// highest retained bit to the sign.  This is the same as truncating the
@@ -547,46 +547,46 @@ class RxInt extends _BaseRxNum<int> {
   /// ```
   /// ```
   /// x == x.toSigned(x.bitLength + 1);
   /// x == x.toSigned(x.bitLength + 1);
   /// ```
   /// ```
-  int toSigned(int width) => _value.toSigned(width);
+  int toSigned(int width) => value.toSigned(width);
 
 
   /// Return the negative value of this integer.
   /// Return the negative value of this integer.
   ///
   ///
   /// The result of negating an integer always has the opposite sign, except
   /// The result of negating an integer always has the opposite sign, except
   /// for zero, which is its own negation.
   /// for zero, which is its own negation.
-  int operator -() => -_value;
+  int operator -() => -value;
 
 
   /// Returns the absolute value of this integer.
   /// Returns the absolute value of this integer.
   ///
   ///
   /// For any integer `x`, the result is the same as `x < 0 ? -x : x`.
   /// For any integer `x`, the result is the same as `x < 0 ? -x : x`.
-  int abs() => _value.abs();
+  int abs() => value.abs();
 
 
   /// Returns the sign of this integer.
   /// Returns the sign of this integer.
   ///
   ///
   /// Returns 0 for zero, -1 for values less than zero and
   /// Returns 0 for zero, -1 for values less than zero and
   /// +1 for values greater than zero.
   /// +1 for values greater than zero.
-  int get sign => _value.sign;
+  int get sign => value.sign;
 
 
   /// Returns `this`.
   /// Returns `this`.
-  int round() => _value.round();
+  int round() => value.round();
 
 
   /// Returns `this`.
   /// Returns `this`.
-  int floor() => _value.floor();
+  int floor() => value.floor();
 
 
   /// Returns `this`.
   /// Returns `this`.
-  int ceil() => _value.ceil();
+  int ceil() => value.ceil();
 
 
   /// Returns `this`.
   /// Returns `this`.
-  int truncate() => _value.truncate();
+  int truncate() => value.truncate();
 
 
   /// Returns `this.toDouble()`.
   /// Returns `this.toDouble()`.
-  double roundToDouble() => _value.roundToDouble();
+  double roundToDouble() => value.roundToDouble();
 
 
   /// Returns `this.toDouble()`.
   /// Returns `this.toDouble()`.
-  double floorToDouble() => _value.floorToDouble();
+  double floorToDouble() => value.floorToDouble();
 
 
   /// Returns `this.toDouble()`.
   /// Returns `this.toDouble()`.
-  double ceilToDouble() => _value.ceilToDouble();
+  double ceilToDouble() => value.ceilToDouble();
 
 
   /// Returns `this.toDouble()`.
   /// Returns `this.toDouble()`.
-  double truncateToDouble() => _value.truncateToDouble();
+  double truncateToDouble() => value.truncateToDouble();
 }
 }

@@ -36,6 +36,10 @@ class RxList<E> implements List<E>, RxInterface<List<E>> {
 
 
   void operator []=(int index, E val) {
   void operator []=(int index, E val) {
     _list[index] = val;
     _list[index] = val;
+    refresh();
+  }
+
+  void refresh() {
     subject.add(_list);
     subject.add(_list);
   }
   }
 
 
@@ -43,7 +47,7 @@ class RxList<E> implements List<E>, RxInterface<List<E>> {
   /// inside the List,
   /// inside the List,
   RxList<E> operator +(Iterable<E> val) {
   RxList<E> operator +(Iterable<E> val) {
     addAll(val);
     addAll(val);
-    subject.add(_list);
+    refresh();
     return this;
     return this;
   }
   }
 
 
@@ -53,13 +57,13 @@ class RxList<E> implements List<E>, RxInterface<List<E>> {
 
 
   void add(E item) {
   void add(E item) {
     _list.add(item);
     _list.add(item);
-    subject.add(_list);
+    refresh();
   }
   }
 
 
   @override
   @override
   void addAll(Iterable<E> item) {
   void addAll(Iterable<E> item) {
     _list.addAll(item);
     _list.addAll(item);
-    subject.add(_list);
+    refresh();
   }
   }
 
 
   /// Add [item] to [List<E>] only if [item] is not null.
   /// Add [item] to [List<E>] only if [item] is not null.
@@ -87,13 +91,13 @@ class RxList<E> implements List<E>, RxInterface<List<E>> {
   @override
   @override
   void insert(int index, E item) {
   void insert(int index, E item) {
     _list.insert(index, item);
     _list.insert(index, item);
-    subject.add(_list);
+    refresh();
   }
   }
 
 
   @override
   @override
   void insertAll(int index, Iterable<E> iterable) {
   void insertAll(int index, Iterable<E> iterable) {
     _list.insertAll(index, iterable);
     _list.insertAll(index, iterable);
-    subject.add(_list);
+    refresh();
   }
   }
 
 
   @override
   @override
@@ -108,7 +112,7 @@ class RxList<E> implements List<E>, RxInterface<List<E>> {
   bool remove(Object item) {
   bool remove(Object item) {
     final hasRemoved = _list.remove(item);
     final hasRemoved = _list.remove(item);
     if (hasRemoved) {
     if (hasRemoved) {
-      subject.add(_list);
+      refresh();
     }
     }
     return hasRemoved;
     return hasRemoved;
   }
   }
@@ -116,39 +120,39 @@ class RxList<E> implements List<E>, RxInterface<List<E>> {
   @override
   @override
   E removeAt(int index) {
   E removeAt(int index) {
     final item = _list.removeAt(index);
     final item = _list.removeAt(index);
-    subject.add(_list);
+    refresh();
     return item;
     return item;
   }
   }
 
 
   @override
   @override
   E removeLast() {
   E removeLast() {
     final item = _list.removeLast();
     final item = _list.removeLast();
-    subject.add(_list);
+    refresh();
     return item;
     return item;
   }
   }
 
 
   @override
   @override
   void removeRange(int start, int end) {
   void removeRange(int start, int end) {
     _list.removeRange(start, end);
     _list.removeRange(start, end);
-    subject.add(_list);
+    refresh();
   }
   }
 
 
   @override
   @override
   void removeWhere(bool Function(E) test) {
   void removeWhere(bool Function(E) test) {
     _list.removeWhere(test);
     _list.removeWhere(test);
-    subject.add(_list);
+    refresh();
   }
   }
 
 
   @override
   @override
   void clear() {
   void clear() {
     _list.clear();
     _list.clear();
-    subject.add(_list);
+    refresh();
   }
   }
 
 
   @override
   @override
   void sort([int compare(E a, E b)]) {
   void sort([int compare(E a, E b)]) {
     _list.sort(compare);
     _list.sort(compare);
-    subject.add(_list);
+    refresh();
   }
   }
 
 
   @override
   @override
@@ -168,7 +172,7 @@ class RxList<E> implements List<E>, RxInterface<List<E>> {
 
 
   void update(void fn(Iterable<E> value)) {
   void update(void fn(Iterable<E> value)) {
     fn(value);
     fn(value);
-    subject.add(_list);
+    refresh();
   }
   }
 
 
   /// Replaces all existing items of this list with [items]
   /// Replaces all existing items of this list with [items]
@@ -197,7 +201,7 @@ class RxList<E> implements List<E>, RxInterface<List<E>> {
   set value(List<E> val) {
   set value(List<E> val) {
     if (_list == val) return;
     if (_list == val) return;
     _list = val;
     _list = val;
-    subject.add(_list);
+    refresh();
   }
   }
 
 
   Stream<List<E>> get stream => subject.stream;
   Stream<List<E>> get stream => subject.stream;
@@ -262,7 +266,7 @@ class RxList<E> implements List<E>, RxInterface<List<E>> {
   @override
   @override
   void fillRange(int start, int end, [E fillValue]) {
   void fillRange(int start, int end, [E fillValue]) {
     _list.fillRange(start, end, fillValue);
     _list.fillRange(start, end, fillValue);
-    subject.add(_list);
+    refresh();
   }
   }
 
 
   @override
   @override
@@ -323,7 +327,7 @@ class RxList<E> implements List<E>, RxInterface<List<E>> {
   @override
   @override
   set length(int newLength) {
   set length(int newLength) {
     _list.length = newLength;
     _list.length = newLength;
-    subject.add(_list);
+    refresh();
   }
   }
 
 
   @override
   @override
@@ -339,13 +343,13 @@ class RxList<E> implements List<E>, RxInterface<List<E>> {
   @override
   @override
   void replaceRange(int start, int end, Iterable<E> replacement) {
   void replaceRange(int start, int end, Iterable<E> replacement) {
     _list.replaceRange(start, end, replacement);
     _list.replaceRange(start, end, replacement);
-    subject.add(_list);
+    refresh();
   }
   }
 
 
   @override
   @override
   void retainWhere(bool Function(E) test) {
   void retainWhere(bool Function(E) test) {
     _list.retainWhere(test);
     _list.retainWhere(test);
-    subject.add(_list);
+    refresh();
   }
   }
 
 
   @override
   @override
@@ -354,19 +358,19 @@ class RxList<E> implements List<E>, RxInterface<List<E>> {
   @override
   @override
   void setAll(int index, Iterable<E> iterable) {
   void setAll(int index, Iterable<E> iterable) {
     _list.setAll(index, iterable);
     _list.setAll(index, iterable);
-    subject.add(_list);
+    refresh();
   }
   }
 
 
   @override
   @override
   void setRange(int start, int end, Iterable<E> iterable, [int skipCount = 0]) {
   void setRange(int start, int end, Iterable<E> iterable, [int skipCount = 0]) {
     _list.setRange(start, end, iterable, skipCount);
     _list.setRange(start, end, iterable, skipCount);
-    subject.add(_list);
+    refresh();
   }
   }
 
 
   @override
   @override
   void shuffle([Random random]) {
   void shuffle([Random random]) {
     _list.shuffle(random);
     _list.shuffle(random);
-    subject.add(_list);
+    refresh();
   }
   }
 
 
   @override
   @override
@@ -425,13 +429,13 @@ class RxList<E> implements List<E>, RxInterface<List<E>> {
   @override
   @override
   set first(E value) {
   set first(E value) {
     _list.first = value;
     _list.first = value;
-    subject.add(_list);
+    refresh();
   }
   }
 
 
   @override
   @override
   set last(E value) {
   set last(E value) {
     _list.last = value;
     _list.last = value;
-    subject.add(_list);
+    refresh();
   }
   }
 }
 }
 
 

@@ -26,6 +26,10 @@ class RxMap<K, V> implements RxInterface<Map<K, V>>, Map<K, V> {
     return _value;
     return _value;
   }
   }
 
 
+  void refresh() {
+    subject.add(_value);
+  }
+
   String get string => value.toString();
   String get string => value.toString();
 
 
   bool get canUpdate {
   bool get canUpdate {
@@ -54,7 +58,7 @@ class RxMap<K, V> implements RxInterface<Map<K, V>>, Map<K, V> {
   set value(Map<K, V> val) {
   set value(Map<K, V> val) {
     if (_value == val) return;
     if (_value == val) return;
     _value = val;
     _value = val;
-    subject.add(_value);
+    refresh();
   }
   }
 
 
   Stream<Map<K, V>> get stream => subject.stream;
   Stream<Map<K, V>> get stream => subject.stream;
@@ -73,14 +77,14 @@ class RxMap<K, V> implements RxInterface<Map<K, V>>, Map<K, V> {
 
 
   void add(K key, V value) {
   void add(K key, V value) {
     _value[key] = value;
     _value[key] = value;
-    subject.add(_value);
+    refresh();
   }
   }
 
 
   void addIf(dynamic condition, K key, V value) {
   void addIf(dynamic condition, K key, V value) {
     if (condition is Condition) condition = condition();
     if (condition is Condition) condition = condition();
     if (condition is bool && condition) {
     if (condition is bool && condition) {
       _value[key] = value;
       _value[key] = value;
-      subject.add(_value);
+      refresh();
     }
     }
   }
   }
 
 
@@ -97,25 +101,25 @@ class RxMap<K, V> implements RxInterface<Map<K, V>>, Map<K, V> {
   @override
   @override
   void operator []=(K key, V value) {
   void operator []=(K key, V value) {
     _value[key] = value;
     _value[key] = value;
-    subject.add(_value);
+    refresh();
   }
   }
 
 
   @override
   @override
   void addAll(Map<K, V> other) {
   void addAll(Map<K, V> other) {
     _value.addAll(other);
     _value.addAll(other);
-    subject.add(_value);
+    refresh();
   }
   }
 
 
   @override
   @override
   void addEntries(Iterable<MapEntry<K, V>> entries) {
   void addEntries(Iterable<MapEntry<K, V>> entries) {
     _value.addEntries(entries);
     _value.addEntries(entries);
-    subject.add(_value);
+    refresh();
   }
   }
 
 
   @override
   @override
   void clear() {
   void clear() {
     _value.clear();
     _value.clear();
-    subject.add(_value);
+    refresh();
   }
   }
 
 
   @override
   @override
@@ -154,21 +158,21 @@ class RxMap<K, V> implements RxInterface<Map<K, V>>, Map<K, V> {
   @override
   @override
   V putIfAbsent(K key, V Function() ifAbsent) {
   V putIfAbsent(K key, V Function() ifAbsent) {
     final val = _value.putIfAbsent(key, ifAbsent);
     final val = _value.putIfAbsent(key, ifAbsent);
-    subject.add(_value);
+    refresh();
     return val;
     return val;
   }
   }
 
 
   @override
   @override
   V remove(Object key) {
   V remove(Object key) {
     final val = _value.remove(key);
     final val = _value.remove(key);
-    subject.add(_value);
+    refresh();
     return val;
     return val;
   }
   }
 
 
   @override
   @override
   void removeWhere(bool Function(K, V) test) {
   void removeWhere(bool Function(K, V) test) {
     _value.removeWhere(test);
     _value.removeWhere(test);
-    subject.add(_value);
+    refresh();
   }
   }
 
 
   @override
   @override
@@ -180,14 +184,14 @@ class RxMap<K, V> implements RxInterface<Map<K, V>>, Map<K, V> {
   @override
   @override
   V update(K key, V Function(V) update, {V Function() ifAbsent}) {
   V update(K key, V Function(V) update, {V Function() ifAbsent}) {
     final val = _value.update(key, update, ifAbsent: ifAbsent);
     final val = _value.update(key, update, ifAbsent: ifAbsent);
-    subject.add(_value);
+    refresh();
     return val;
     return val;
   }
   }
 
 
   @override
   @override
   void updateAll(V Function(K, V) update) {
   void updateAll(V Function(K, V) update) {
     _value.updateAll(update);
     _value.updateAll(update);
-    subject.add(_value);
+    refresh();
   }
   }
 }
 }
 
 

@@ -42,25 +42,29 @@ class RxSet<E> implements Set<E>, RxInterface<Set<E>> {
     if (condition is bool && condition) addAll(items);
     if (condition is bool && condition) addAll(items);
   }
   }
 
 
+  void refresh() {
+    subject.add(_set);
+  }
+
   /// Special override to push() element(s) in a reactive way
   /// Special override to push() element(s) in a reactive way
   /// inside the List,
   /// inside the List,
   RxSet<E> operator +(Set<E> val) {
   RxSet<E> operator +(Set<E> val) {
     addAll(val);
     addAll(val);
-    subject.add(_set);
+    refresh();
     return this;
     return this;
   }
   }
 
 
   @override
   @override
   bool add(E value) {
   bool add(E value) {
     final val = _set.add(value);
     final val = _set.add(value);
-    subject.add(_set);
+    refresh();
     return val;
     return val;
   }
   }
 
 
   @override
   @override
   void addAll(Iterable<E> item) {
   void addAll(Iterable<E> item) {
     _set.addAll(item);
     _set.addAll(item);
-    subject.add(_set);
+    refresh();
   }
   }
 
 
   /// Adds only if [item] is not null.
   /// Adds only if [item] is not null.
@@ -83,19 +87,19 @@ class RxSet<E> implements Set<E>, RxInterface<Set<E>> {
   bool remove(Object item) {
   bool remove(Object item) {
     var hasRemoved = _set.remove(item);
     var hasRemoved = _set.remove(item);
     if (hasRemoved) {
     if (hasRemoved) {
-      subject.add(_set);
+      refresh();
     }
     }
     return hasRemoved;
     return hasRemoved;
   }
   }
 
 
   void removeWhere(bool Function(E) test) {
   void removeWhere(bool Function(E) test) {
     _set.removeWhere(test);
     _set.removeWhere(test);
-    subject.add(_set);
+    refresh();
   }
   }
 
 
   void clear() {
   void clear() {
     _set.clear();
     _set.clear();
-    subject.add(_set);
+    refresh();
   }
   }
 
 
   void close() {
   void close() {
@@ -114,7 +118,7 @@ class RxSet<E> implements Set<E>, RxInterface<Set<E>> {
 
 
   void update(void fn(Iterable<E> value)) {
   void update(void fn(Iterable<E> value)) {
     fn(value);
     fn(value);
-    subject.add(_set);
+    refresh();
   }
   }
 
 
   /// Replaces all existing items of this list with [items]
   /// Replaces all existing items of this list with [items]
@@ -145,7 +149,7 @@ class RxSet<E> implements Set<E>, RxInterface<Set<E>> {
   set value(Set<E> val) {
   set value(Set<E> val) {
     if (_set == val) return;
     if (_set == val) return;
     _set = val;
     _set = val;
-    subject.add(_set);
+    refresh();
   }
   }
 
 
   Stream<Set<E>> get stream => subject.stream;
   Stream<Set<E>> get stream => subject.stream;
@@ -309,19 +313,19 @@ class RxSet<E> implements Set<E>, RxInterface<Set<E>> {
   @override
   @override
   void removeAll(Iterable<Object> elements) {
   void removeAll(Iterable<Object> elements) {
     _set.removeAll(elements);
     _set.removeAll(elements);
-    subject.add(_set);
+    refresh();
   }
   }
 
 
   @override
   @override
   void retainAll(Iterable<Object> elements) {
   void retainAll(Iterable<Object> elements) {
     _set.retainAll(elements);
     _set.retainAll(elements);
-    subject.add(_set);
+    refresh();
   }
   }
 
 
   @override
   @override
   void retainWhere(bool Function(E) E) {
   void retainWhere(bool Function(E) E) {
     _set.retainWhere(E);
     _set.retainWhere(E);
-    subject.add(_set);
+    refresh();
   }
   }
 
 
   @override
   @override