A Dart package that helps to implement value based equality without needing to explicitly override == and hashCode.

Overview

logo

Simplify Equality Comparisons

Build Status Code Coverage Pub Package
Star on GitHub style: effective dart Discord MIT License


Overview

Being able to compare objects in Dart often involves having to override the == operator as well as hashCode.

Not only is it verbose and tedious, but failure to do so can lead to inefficient code which does not behave as we expect.

By default, == returns true if two objects are the same instance.

Let's say we have the following class:

class Person {
  const Person(this.name);

  final String name;
}

We can create create instances of Person like so:

void main() {
  final Person bob = Person("Bob");
}

Later if we try to compare two instances of Person either in our production code or in our tests we will run into a problem.

print(bob == Person("Bob")); // false

For more information about this, you can check out the official Dart Documentation.

In order to be able to compare two instances of Person we need to change our class to override == and hashCode like so:

class Person {
  const Person(this.name);

  final String name;

  @override
  bool operator ==(Object other) =>
    identical(this, other) ||
    other is Person &&
    runtimeType == other.runtimeType &&
    name == other.name;

  @override
  int get hashCode => name.hashCode;
}

Now if we run the following code again:

print(bob == Person("Bob")); // true

it will be able to compare different instances of Person.

You can see how this can quickly become a hassle when dealing with complex classes. This is where Equatable comes in!

What does Equatable do?

Equatable overrides == and hashCode for you so you don't have to waste your time writing lots of boilerplate code.

There are other packages that will actually generate the boilerplate for you; however, you still have to run the code generation step which is not ideal.

With Equatable there is no code generation needed and we can focus more on writing amazing applications and less on mundane tasks.

Usage

First, we need to do add equatable to the dependencies of the pubspec.yaml

dependencies:
  equatable: ^2.0.0

Next, we need to install it:

# Dart
pub get

# Flutter
flutter packages get

Lastly, we need to extend Equatable

import 'package:equatable/equatable.dart';

class Person extends Equatable {
  const Person(this.name);

  final String name;

  @override
  List<Object> get props => [name];
}

When working with json:

import 'package:equatable/equatable.dart';

class Person extends Equatable {
  const Person(this.name);

  final String name;

  @override
  List<Object> get props => [name];

  factory Person.fromJson(Map<String, dynamic> json) {
    return Person(json['name']);
  }
}

We can now compare instances of Person just like before without the pain of having to write all of that boilerplate. Note: Equatable is designed to only work with immutable objects so all member variables must be final (This is not just a feature of Equatable - overriding a hashCode with a mutable value can break hash-based collections).

Equatable also supports const constructors:

import 'package:equatable/equatable.dart';

class Person extends Equatable {
  const Person(this.name);

  final String name;

  @override
  List<Object> get props => [name];
}

toString Implementation

Equatable can implement toString method including all the given props. If you want that behaviour for a specific Equatable object, just include the following:

@override
bool get stringify => true;

For instance:

import 'package:equatable/equatable.dart';

class Person extends Equatable {
  const Person(this.name);

  final String name;

  @override
  List<Object> get props => [name];

  @override
  bool get stringify => true;
}

For the name Bob, the output will be:

Person(Bob)

This flag by default is false and toString will return just the type:

Person

EquatableConfig

stringify can also be configured globally for all Equatable instances via EquatableConfig

EquatableConfig.stringify = true;

If stringify is overridden for a specific Equatable class, then the value of EquatableConfig.stringify is ignored. In other words, the local configuration always takes precedence over the global configuration.

Note: EquatableConfig.stringify defaults to true in debug mode and false in release mode.

Recap

Without Equatable

class Person {
  const Person(this.name);

  final String name;

  @override
  bool operator ==(Object other) =>
    identical(this, other) ||
    other is Person &&
    runtimeType == other.runtimeType &&
    name == other.name;

  @override
  int get hashCode => name.hashCode;
}

With Equatable

import 'package:equatable/equatable.dart';

class Person extends Equatable {
  const Person(this.name);

  final String name;

  @override
  List<Object> get props => [name];
}

EquatableMixin

Sometimes it isn't possible to extend Equatable because your class already has a superclass. In this case, you can still get the benefits of Equatable by using the EquatableMixin.

Usage

Let's say we want to make an EquatableDateTime class, we can use EquatableMixin like so:

class EquatableDateTime extends DateTime with EquatableMixin {
  EquatableDateTime(
    int year, [
    int month = 1,
    int day = 1,
    int hour = 0,
    int minute = 0,
    int second = 0,
    int millisecond = 0,
    int microsecond = 0,
  ]) : super(year, month, day, hour, minute, second, millisecond, microsecond);

  @override
  List<Object> get props {
    return [year, month, day, hour, minute, second, millisecond, microsecond];
  }
}

Now if we want to create a subclass of EquatableDateTime, we can just override props.

class EquatableDateTimeSubclass extends EquatableDateTime {
  final int century;

  EquatableDateTimeSubclass(
    this.century,
    int year,[
    int month = 1,
    int day = 1,
    int hour = 0,
    int minute = 0,
    int second = 0,
    int millisecond = 0,
    int microsecond = 0,
  ]) : super(year, month, day, hour, minute, second, millisecond, microsecond);

  @override
  List<Object> get props => super.props..addAll([century]);
}

Performance

You might be wondering what the performance impact will be if you use Equatable.

Results (average over 10 runs)

Equality Comparison A == A

Class Runtime (μs)
Manual 0.193
Empty Equatable 0.191
Hydrated Equatable 0.190

Instantiation A()

Class Runtime (μs)
Manual 0.165
Empty Equatable 0.181
Hydrated Equatable 0.182

*Performance Tests run using: Dart VM version: 2.4.0

Maintainers

Comments
  • Equality for objects with a list parameter

    Equality for objects with a list parameter

    I'm playing around with the new library bloc_test for flutter and I implemented the following test

    blocTest('should return ReservationsLoadSucess when the use case returns a list of reservationsList',
    
        build: () {
          when(mockGetReservations(any)).thenAnswer((_) async => Right(reservationsList));
          return ReservationBloc(getReservations: mockGetReservations);
        },
        act: (bloc) async {
          bloc.add(ReservationsRequested(user));
        },
        expect: [
          ReservationsInitial(),
          ReservationsLoadInProgress(),
          ReservationsLoadSuccess(reservationsList),
        ],
      );
    

    This is the implementation of ReservationsLoadSuccess

    class ReservationsLoadSuccess extends ReservationState {
      final List<Reservation> list;
    
      ReservationsLoadSuccess(this.list);
    
      @override
      List<Object> get props => [list];
    }
    

    Where ReservationState extends Equatable Now, when running the test, you get the following error

    should return ReservationsLoadSucess when the use case returns a list of reservationsList:
    
    ERROR: Expected: [
                ReservationsInitial:ReservationsInitial,
                ReservationsLoadInProgress:ReservationsLoadInProgress,
                ReservationsLoadSuccess:ReservationsLoadSuccess
              ]
      Actual: [
                ReservationsInitial:ReservationsInitial,
                ReservationsLoadInProgress:ReservationsLoadInProgress,
                ReservationsLoadSuccess:ReservationsLoadSuccess
              ]
       Which: was ReservationsLoadSuccess:<ReservationsLoadSuccess> instead of ReservationsLoadSuccess:<ReservationsLoadSuccess> at location [2]
    

    Basically saying that the state ReservationsLoadSuccess at position 2 in the actual list is not equal to its peer in the expected list.

    I tried overriding the == operator in the ReservationsLoadSuccess class as follows

    class ReservationsLoadSuccess extends ReservationState {
      final List<Reservation> list;
    
      ReservationsLoadSuccess(this.list);
    
      final Function eq = const ListEquality().equals;
      @override
      List<Object> get props => [];
    
      @override
      bool operator ==(Object other) =>
          identical(this, other) ||
          other is ReservationsLoadSuccess &&
              runtimeType == other.runtimeType &&
              eq(list, other.list);
    }
    

    But that didn't seem to work and running the test still outputted the same error. The only way I got it to work is to leave the props method returning an empty list or adding any other dummy variable and pass it to the props list.

    Is there any way I can make the class equatable in regards to the list parameter?

    question 
    opened by HossamElharmeil 14
  • Support Nullable Types on props | Flutter 2.0 and Dart 2.12 upgrade

    Support Nullable Types on props | Flutter 2.0 and Dart 2.12 upgrade

    Describe the bug The props override property of an equatable doesn't support nullable (eg: String?) values.

    To Reproduce Steps to reproduce the behavior:

    1. Upgrade flutter on stable channel (flutter channel stable && flutter upgrade)
    2. Upgrade dart sdk version to sdk: ">=2.12.0 <3.0.0"
    3. Create an equatable with a nullable property (final String? name)
    4. Pass the 'name' property in the equatable props array
    @override
      List<Object> get props => [name];
    

    Expected behavior No IDE errors/build errors should show up

    A possible workaround on my side is to Assign a fallback value / ternary, which I would say is not reecommended

    @override
      List<Object> get props => [name ?? ''];
    

    Additional context The element type 'String?' can't be assigned to the list type 'Object'.

    question 
    opened by Edorin9 13
  • fix: support legacy equality overrides

    fix: support legacy equality overrides

    Status

    READY

    Breaking Changes

    NO

    Description

    Fixes the equality override not allowing Object? anymore with the null safety update. This had the effect of not permitting to mixin equatable on classes with an existing, e.g. dynamic equality override.

    Todos

    • [ ] Tests
    • [ ] Documentation
    • [ ] Examples
    bug 
    opened by creativecreatorormaybenot 12
  • Add @immutable annotation to Equatable class

    Add @immutable annotation to Equatable class

    Is your feature request related to a problem? Please describe.

    At the moment Equatable only work for immutable classes, but you can extends Equatable in a classes that not are immutable

    https://github.com/felangel/equatable/issues/21 https://github.com/felangel/equatable/issues/22

    Describe the solution you'd like You can add the @immutable annotation, and now you get analysis warning.

    @immutable
    class Equatable ....
    

    Describe alternatives you've considered Equatable can override the hashCode and == for not immutable objects.

    Additional Also like the same behavior for EquatableMixin but i don't know how to do that.

    enhancement 
    opened by basketball-ico 12
  • updated List equality produces false negative

    updated List equality produces false negative

    Describe the bug The new list equality check introduces false negatives in my tests when comparing identical lists with different runtime types. In consequence of other business logic in my code, I end up with a GrowableList in one side of the equality and a CopyOnWriteList on the other. Contents are identical but the runtime check fails.

    To Reproduce In my test I generate dummy data with List.generate(). This produces a GrowableList. However in my code I am using BuildList which has a toList() method that returns a CopyOnWriteList. The equality check worked as expected with older code.

    Expected behavior Deep equals check should find that the list contents are identical

    Screenshots Screen Shot 2019-05-27 at 7 46 53 AM

    Version Dart VM version: 2.3.0 (Fri May 3 10:32:31 2019 +0200) on "macos_x64"

    Additional context I'm able to work around this in my tests by wrapping my original dummy data in a BuiltList and using the toList() to compare. But this is a bit more work than I would expect and might be confusing to future maintainers. Thanks!

    bug 
    opened by dustin-graham 12
  • Mark a props equals if is identical

    Mark a props equals if is identical

    @felangel Is it possible to mark an specific prop that is equal when it's identical?

    import 'package:equatable/equatable.dart';
    
    class Person extends Equatable {
      final String name;
      final List<int> orders;
    
      Person(this.name,this.orders);
    
      @override
      List<Object> get props => [name,orders];
    }
    

    I need a way to told dart that two person in equal if has same name but has identical orders not deep equal orders

    I think we can achieve by following way

    import 'package:equatable/equatable.dart';
    
    class Person extends Equatable {
      final String name;
      final List<int> orders;
    
      Person(this.name,this.orders);
    
      @override
      List<Object> get props => [name];
    
      @override
      List<Object> get identicalProps => [orders];
    }
    
    question 
    opened by sm2017 11
  • Lists even if elements are Equatable don't cause changes

    Lists even if elements are Equatable don't cause changes

    Describe the bug If a list is one of the properties on an object, then add/remove and per item comparisons fail which causes things like FlutterBloc etc. that rely on equitable to determine if something has changed, to also fail.

    To Reproduce

    1. Create an object, add a List property and add it to props
    2. Add an item to the list, note that nothing changes and equatable still doesn't equal and as a result FlutterBloc etc. won't update.
    3. Remove an item from the list. Note that nothing changes in the status of equatable.

    Expected behavior Equatable should by default inspect all elements for equatableness of a list and flag the property dirty based on an mismatch in size or specific elements changing. Alternatively this should be a setting that you can configure, or there should be a specific type of list (EquatableList<>) that will explicitly cause the same.

    Version Dart SDK version: 2.10.0-7.3.beta (beta) (Wed Aug 26 09:46:50 2020 +0200) on "windows_x64"

    question 
    opened by JohnGalt1717 9
  • Default stringify to true

    Default stringify to true

    Status

    READY

    Breaking Changes

    NO

    Description

    Defaulting stringify to true takes away some boilerplate. Related issue: #60. Not sure if this should be seen as a breaking change.

    Todos

    • [x] Tests
    • [x] Documentation
    • [x] Examples
    enhancement 
    opened by zepfietje 9
  • Implement toString feature

    Implement toString feature

    Status

    READY

    Breaking Changes

    NO

    Description

    I implemented the toString method feature using the props.

    I think it is a very useful feature for testing and debugging that most of developers that use this library would like to use. It could be able to do this through an own subclass of equatable or another library but I think that it is overkill for this small feature. This library override already that method and there is no impact implementing this.

    Related PRs

    No related PRs.

    Todos

    There is no TODOs

    • [X] Tests
    • [X] Documentation
    • [X] Examples

    Impact to Remaining Code Base

    This new feature will not have impact in the code base, functionality or performance. It is disabled by default and does not force the user to do changes.

    enhancement 
    opened by nfdz 9
  • Default props to empty list

    Default props to empty list

    Status

    READY

    Breaking Changes

    NO

    Description

    Defaulting props to an empty list takes away some boilerplate. Both null and const [] were options, but I'm not sure if either of those has advantages over the other.

    enhancement 
    opened by zepfietje 8
  • Provider stronger hash codes

    Provider stronger hash codes

    I was looking for ways to ease operator == and hashCode in Dart and found equatable.

    It seems a reasonable approach overall.

    But, looking at the implementation, it looks like it uses XOR to combine hashes. This would mean, for example, that

    class Point {
      final int x = 3;
      final int y = 4;
    }
    

    and

    class Point {
      final int x = 4;
      final int y = 3;
    }
    

    will hash to the same value. Did I miss something?

    I think the correct approach would be to use something like

    https://en.wikipedia.org/wiki/Jenkins_hash_function

    --which is what package:quiver uses

    https://github.com/google/quiver-dart/blob/master/lib/src/core/hash.dart

    Good news is it should be possible to add this within the current implementation with no changes to how it's used :)

    Thanks!

    enhancement 
    opened by davidmorgan 8
  • Enum implementing Equatable related classes

    Enum implementing Equatable related classes

    I've created a class that only takes Enums as parameters. I figured I could create a third Enum where I would manually put every option so they have a better naming.

    E.g.:

    Configuration

    enum A {
      a,
      b;
    }
    enum B {
      c,
      d;
    }
    
    class Class with EquatableMixin {
      const EveryDayOfYear({required this.aValue, required this.bValue});
    
      final A aValue;
      final B bValue;
      
      @override
      List<Object?> get props => [aValue, bValue];
    }
    
    enum C implements Class {
      ac(Class(aValue: A.a, bValue: B.c)),
      ad(Class(aValue: A.a, bValue: B.d)),
      bc(Class(aValue: A.b, bValue: B.c)),
      bd(Class(aValue: A.b, bValue: B.d));
    
      const C(this._handler);
    
      final Class _handler;
    
      @override
      A get aValue => _handler.aValue;
    
      @override
      B get bValue => _handler.bValue;
    
      @override
      List<Object?> get props => [aValue, bValue];
    }
    

    Objective

    final instance = Class(aValue: A.a, bValue: B.c);
    instance == C.ac; // I would like something so this operation returns true.
    

    Context

    As I said here:

    As commented by @Levi-Lesches here the answer to my problem was to override my operator ==:

      @override
      // ignore: hash_and_equals, already implemented by EquatableMixin
      bool operator ==(Object other) {
        return (super == other) ||
            ((other is Class) &&
                (aValue == other.aValue) &&
                (bValue == other.bValue));
      }
    

    This solved my problem and is fair since my class instance is not an Enum, but my enum constant is actually my class instance.

    Suggestion

    Enable some kind of option or by default so that extended classes are also equal to the base class not by testing the runtimeType but by testing if the object is from the current class/equatable related.

    opened by FMorschel 3
  • feat request: add `stringifyProps`

    feat request: add `stringifyProps`

    Is your feature request related to a problem? Please describe. Currently there's no way to easily specify a sub-set of props you want stringified.

    Describe the solution you'd like Would be useful to have another getter similar to props, which would allow to override the props you want stringified.

    Describe alternatives you've considered Manually overriding toString.

    opened by narcodico 0
  • Equatable doesn't checks for Equality for variables in parent class

    Equatable doesn't checks for Equality for variables in parent class

    I have a state bloc

    abstract class BaseState extends Equatable{
        List<MyObject> listA;
        List<MyObject> listB;
        BaseState(this.listA, this.listB);
    
        @override
        List<Object> get props => [listA, listB]
    }
    
    class StateA extends BaseState{
        BaseState(List<MyObject> newListA, List<MyObject> newListB): super(List.of(newListA), List.of(newListA));
    }
    

    As the example above, while receiving StateA from BlocBuilder using flutter_bloc, Equatable is not able to detect the difference in StateA hence the UI is not updated.

    Is my implementation and the way of using Equatable correct in this regard?

    opened by LeeBoonKong 0
  • Simplified toString

    Simplified toString

    Status

    READY

    Breaking Changes

    YES

    Description

    The goal is to simplify toString method on Equatable and EquatableMixin and remove repetitive logic.

    Related PRs

    List related PRs against other branches:

    Todos

    • [x] Tests
    • [ ] Documentation
    • [ ] Examples
    opened by Amir-P 1
  • Feat: Add derived object comparability

    Feat: Add derived object comparability

    Status

    IN DEVELOPMENT

    Breaking Changes

    NO

    Description

    When comparing derived (sub) classes to it's base class, the result it always false. I would expect that, if the base props matches the derived class's base props, the result would be true.

    Todos

    • [x] Tests
    • [x] Documentation
    • [ ] Examples

    Steps to Test or Reproduce

    Outline the steps to test or reproduce the PR here.

    import 'package:equatable/equatable.dart';
    
    class A extends Equatable {
      const A(this.value);
      final String value;
    
      @override
      List<Object?> get props => [value];
    }
    
    class B extends A {
      const B(String a, this.code) : super(a);
      final int code;
    
      @override
      List<Object?> get props => [...super.props, code];
    
      @override
      Set<Type> get derived => {A};
    }
    
    class C extends B {
      const C(
        String value,
        int code, {
        required this.isCool,
      }) : super(value, code);
    
      final bool isCool;
    
      @override
      Set<Type> get derived => {B, ...super.derived};
    
      @override
      List<Object?> get props => [...super.props, isCool];
    }
    
    void main() {
      final notEqualA = const A('not-equal');
    
      final instanceA = const A('a');
      final instanceB = const B('a', 1);
      final instanceC = const C('a', 1, isCool: true);
    
      print(notEqualA == instanceA); // false
    
      print(instanceA == instanceB); // true
      print(instanceA == instanceC); // true
    
      print(instanceB == instanceA); // true
      print(instanceB == instanceC); // true
    
      print(instanceC == instanceA); // true
      print(instanceC == instanceB); // true
    
      // reversed
      print(instanceB == instanceA); // true
      print(instanceC == instanceA); // true
    
      print(instanceA == instanceB); // true
      print(instanceC == instanceB); // true
    
      print(instanceA == instanceC); // true
      print(instanceB == instanceC); // true
    }
    

    Impact to Remaining Code Base

    This PR will affect:

    • This should have no impact on the Code Base

    Possible Concerns

    By manipulating the == to match derivatives from the base class, the hashCode will not return the same result as the == operator. This only occurs when derived is overridden, otherwise the results ARE the same.

    HashCode Docs

    /*
    Base:        instanceA
    Derivative:  instanceB
    */
    
    print(instanceA == instanceB); // true
    print(instanceA.hashCode == instanceB.hashCode); // false
    
    opened by mrgnhnt96 1
  • testing equality of derived types

    testing equality of derived types

    Describe the bug I have two types:

    
    class GenericDevice extends Equatable {
      final String name;
      final String id;
    
      GenericDevice({@required this.name, @required this.id});
    
      @override
      bool get stringify => true;
    
      // named constructor
      GenericDevice.fromJson(Map<String, dynamic> json)
          : name = json['name'],
            id = json['id'];
    
      // method
      Map<String, dynamic> toJson() {
        return {
          'name': name,
          'id': id,
        };
      }
    
      @override
      String toString() {
        return 'GenericDevice{name: $name, id: $id}';
      }
    
      @override
      List<Object> get props => [name, id];
    }
    

    and

    class BleDevice<T> extends GenericDevice with Disposable {
      BleDevice({@required this.device, @required String name, @required String id})
          : super(name: name, id: id);
    
      final T device;
    }
    

    I Wrote a test like this:

      test(
        'Generic Device Test - Equatable test',
        () {
          var device1 = GenericDevice(id: '1234', name: 'deviceName');
          var device2 = BleDevice<int>(id: '1234', name: 'deviceName', device: 6);
          var device3 = BleDevice<int>(id: '12345', name: 'deviceName', device: 6);
          print(device1);
          print(device2);
          print(device3);
    
          expect(device1 == device2, equals(true));
          expect(device1, isNot(equals(device3)));
        },
      );
    
    

    I expected the test to pass but because because Equality is looking into the runtime type its failed

      @override
      bool operator ==(Object other) {
        return identical(this, other) ||
            other is EquatableMixin &&
                runtimeType == other.runtimeType &&
                equals(props, other.props);
      }
    

    Any suggestions ideas - is that really how it should be?

    Makes me wonder if that could not be enough:

    @override
      bool operator ==(Object other) =>
          identical(this, other) ||
          other is Equatable && equals(props, other.props);
    

    Is the dart analyzer not catching that I compare not comparable types?

    question waiting for response 
    opened by ride4sun 9
Releases(v2.0.5)
Owner
Felix Angelov
software engineer by day, software engineer by night.
Felix Angelov
A new Flutter package which helps you to implement Ticket Widget in your app.

flutter_ticket_widget A new Flutter package which helps you to implement Ticket Widget in your app. The source code is 100% Dart, and everything resid

Mohak Gupta 112 Dec 22, 2022
A string generator that helps to implement real-time editing of an ordered sequence.

About A string generator that helps to implement real-time editing of an ordered sequence. It makes reordering, sorting, and interleaving transactions

Minsik Kim 3 May 15, 2022
Get or set persistent storage value based on MMKV framework.

mmkv_flutter Plugin that allow Flutter to read value from persistent storage or save value to persistent storage based on MMKV framework Getting Start

OpenFlutter 101 Jan 17, 2022
This package allows you to scroll/select the value directly from the dropdown with less effort and time.

Direct Select This package allows you to scroll/select the value directly from the dropdown with less effort and time. Inspired by Virgil Pana shot Sa

Diego Velásquez López 62 Nov 25, 2022
Lightweight and blazing fast key-value database written in pure Dart.

Fast, Enjoyable & Secure NoSQL Database Hive is a lightweight and blazing fast key-value database written in pure Dart. Inspired by Bitcask. Documenta

HiveDB 3.4k Dec 30, 2022
Lightweight and blazing fast key-value database written in pure Dart.

Fast, Enjoyable & Secure NoSQL Database Hive is a lightweight and blazing fast key-value database written in pure Dart. Inspired by Bitcask. Documenta

HiveDB 3.4k Dec 30, 2022
How to get the most value from Dart static analysis

This package is deprecated. Before it was deprecated, it was the way to get analysis options matching those used internally at Google. This was useful

Google 324 Nov 4, 2022
How to get the most value from Dart static analysis

This package is deprecated. Before it was deprecated, it was the way to get analysis options matching those used internally at Google. This was useful

Google 324 Nov 4, 2022
Neha Tanwar 4 Feb 2, 2022
Immutable value types, enum classes, and serialization.

Built Values for Dart Introduction Built Value provides: Immutable value types; EnumClass, classes that behave like enums; JSON serialization. Immutab

Google 816 Dec 23, 2022
A fast, extra light and synchronous key-value storage to Get framework

get_storage A fast, extra light and synchronous key-value in memory, which backs up data to disk at each operation. It is written entirely in Dart and

Jonny Borges 257 Dec 21, 2022
ITS A SIMPLE CRYPTO APP THAT GIVES OR DISPLAYS PRICES - %CHANGE AND CHANGE VALUE OF TICKER (VARIOUS CRYPTO ASSERTS)

btcpricetracker A new Flutter project. Getting Started This project is a starting point for a Flutter application. A few resources to get you started

jatin upadhyay 0 Dec 28, 2021
Its a simple app which gives Weather Update, Bit Coin Value Comparator, and Flash Chat Application

Bundle_App_MajorProject Description : Its a simple app which is a bundle of Weather Update App, Bit Coin Value Comparator App, and Flash Chat Applicat

Avinandan Bose 2 Sep 9, 2022
This package helps developer to sort the flutter/dart packages and plugins alphabetically, This makes it easier when managing too many packages and when working with teams

Package helps to sort the flutter/dart packages and plugins alphabetically, This makes it easier when managing too many packages and when working with

DANCHE 7 Dec 21, 2022
A Package to implement, change and use Themes in Flutter

Modern Themes Github: https://github.com/Jules-Media/Modern_Themes Pub.dev: https://pub.dev/packages/modern_themes About With this Plugin you can impl

Jules Media 2 Jun 22, 2022
Value listenable test - Assists in testing ValueListenable objects (ex: ValueNotifier).

value_listenable_test Assists in testing ValueListenable objects (ex: ValueNotifier). install Added in your pubspec.yaml as dev dependency: dev_depend

Flutterando 3 Feb 23, 2022
Return a result ErrorOr with either a value T or an error Object.

ErrorOr Return a result ErrorOr with either a value T or an error Object. Features Always return a value ErrorOr from an async function. Let the calle

Erlend 6 Nov 6, 2022
An rx stream builder widget that is able to pre-populate a flutter StreamBuilder with data from an rx stream if the stream is either a value or a replay observable.

An rx stream builder widget that is able to pre-populate a flutter StreamBuilder with data from an rx stream if the stream is either a value or a replay observable. For example the RX stream is a BehaviorSubject or a ReplaySubject.

Jon Samwell 8 Jan 22, 2022