Dart Documentation › enumerators › Finite<A>

Finite<A> class 

class Finite<A> extends IterableBase<A> {
 final int length;
 final _Operation op;

 Finite._(this.length, this.op);

 factory Finite.empty() => new Finite._(0, new _OEmpty());
 factory Finite.singleton(A x) => new Finite._(1, new _OSingleton(x));

 /**
  * Union.
  */
 Finite<A> operator +(Finite<A> fin) =>
     new Finite._(this.length + fin.length, new _OAdd(this, fin));

 /**
  * Cartesian product.
  */
 Finite<Pair> operator *(Finite fin) =>
     new Finite._(this.length * fin.length, new _OMult(this, fin));

 /**
  * [Finite] is a functor.
  */
 Finite map(f(A x)) => new Finite._(this.length, new _OMap(this, f));

 /**
  * [Finite] is an applicative functor.
  */
 Finite apply(Finite fin) =>
     (this * fin).map((pair) => (pair.fst as Function)(pair.snd));

 A operator [](int index) => _eval(this, index);

 static _eval(Finite finite, int index) {
   bool evalOp = true;

   var val;
   final stack = <_Instruction>[new _IDone()];
   var op = finite.op;

   while (true) {
     if (evalOp) {
       switch(op.tag) {
         case _Operation.ADD:
           if (index < op.fin1.length) {
             op = op.fin1.op;
           } else {
             final f1 = op.fin1;
             op = op.fin2.op;
             index = index - f1.length;
           }
           break;
         case _Operation.EMPTY:
           throw new RangeError(index);
           break;
         case _Operation.MULT:
           int q = index ~/ op.fin2.length;
           int r = index % op.fin2.length;
           index = q;
           stack.add(new _IPair1(op.fin2, r));
           op = op.fin1.op;
           break;
         case _Operation.SINGLETON:
           if (index == 0) {
             val = op.val;
             evalOp = false;
           } else {
             throw new RangeError(index);
           }
           break;
         case _Operation.MAP:
           stack.add(new _IMap(op.fun));
           op = op.fin.op;
           break;
       }
     } else {
       final instr = stack.removeLast();
       switch (instr.tag) {
         case _Instruction.DONE:
           return val;
         case _Instruction.MAP:
           val = instr.fun(val);
           break;
         case _Instruction.PAIR2:
           val = new Pair(instr.snd, val);
           break;
         case _Instruction.PAIR1:
           op = instr.fin2.op;
           index = instr.r;
           stack.add(new _IPair2(val));
           evalOp = true;
           break;
       }
     }
   }
 }

 String toString() {
   final strings = toLazyList().map((f) => f.toString()).toList();
   return "{${strings.join(", ")}}";
 }

 Iterator<A> get iterator => new _FiniteIterator<A>(this);

 LazyList<A> toLazyList() {
   aux(i) => (i == this.length)
       ? new LazyList.empty()
       : new LazyList.cons(this[i], () => aux(i+1));
   return aux(0);
 }

 // optimized Iterable methods

 bool get isEmpty => length == 0;

 A elementAt(int index) => this[index];

 A get first {
   if (isEmpty) {
     throw new StateError('Cannot access first element of an empty set.');
   }
   return this[0];
 }

 A get last {
   if (isEmpty) {
     throw new StateError('Cannot access last element of an empty set.');
   }
   return this[length - 1];
 }
}

Extends

IterableBase<A> > Finite<A>

Constructors

factory Finite.empty() #

factory Finite.empty() => new Finite._(0, new _OEmpty());

factory Finite.singleton(A x) #

factory Finite.singleton(A x) => new Finite._(1, new _OSingleton(x));

Properties

final A first #

Returns the first element.

If this is empty throws a StateError. Otherwise this method is equivalent to this.elementAt(0)

docs inherited from Iterable<E> 
A get first {
 if (isEmpty) {
   throw new StateError('Cannot access first element of an empty set.');
 }
 return this[0];
}

final bool isEmpty #

Returns true if there is no element in this collection.

docs inherited from Iterable<E> 
bool get isEmpty => length == 0;

final bool isNotEmpty #

inherited from IterableBase

Returns true if there is at least one element in this collection.

docs inherited from Iterable<E> 
bool get isNotEmpty => !isEmpty;

final Iterator<A> iterator #

Returns an Iterator that iterates over this Iterable object.

docs inherited from Iterable<E> 
Iterator<A> get iterator => new _FiniteIterator<A>(this);

final A last #

Returns the last element.

If this is empty throws a StateError.

docs inherited from Iterable<E> 
A get last {
 if (isEmpty) {
   throw new StateError('Cannot access last element of an empty set.');
 }
 return this[length - 1];
}

final int length #

Returns the number of elements in this.

Counting all elements may be involve running through all elements and can therefore be slow.

docs inherited from Iterable<E> 
final int length

final _Operation op # 

final _Operation op

final E single #

inherited from IterableBase

Returns the single element in this.

If this is empty or has more than one element throws a StateError.

docs inherited from Iterable<E> 
E get single {
 Iterator it = iterator;
 if (!it.moveNext()) throw new StateError("No elements");
 E result = it.current;
 if (it.moveNext()) throw new StateError("More than one element");
 return result;
}

Operators

A operator [](int index) #

A operator [](int index) => _eval(this, index);

Finite<A> operator +(Finite<A> fin) #

Union.

Finite<A> operator +(Finite<A> fin) =>
   new Finite._(this.length + fin.length, new _OAdd(this, fin));

Finite<Pair> operator *(Finite fin) #

Cartesian product.

Finite<Pair> operator *(Finite fin) =>
   new Finite._(this.length * fin.length, new _OMult(this, fin));

Methods

bool any(bool f(E element)) #

inherited from IterableBase

Returns true if one element of this collection satisfies the predicate test. Returns false otherwise.

docs inherited from Iterable<E> 
bool any(bool f(E element)) {
 for (E element in this) {
   if (f(element)) return true;
 }
 return false;
}

Finite apply(Finite fin) #

Finite is an applicative functor.

Finite apply(Finite fin) =>
   (this * fin).map((pair) => (pair.fst as Function)(pair.snd));

bool contains(Object element) #

inherited from IterableBase

Returns true if the collection contains an element equal to element.

docs inherited from Iterable<E> 
bool contains(Object element) {
 for (E e in this) {
   if (e == element) return true;
 }
 return false;
}

A elementAt(int index) #

Returns the indexth element.

If this has fewer than index elements throws a RangeError.

Note: if this does not have a deterministic iteration order then the function may simply return any element without any iteration if there are at least index elements in this.

docs inherited from Iterable<E> 
A elementAt(int index) => this[index];

bool every(bool f(E element)) #

inherited from IterableBase

Returns true if every elements of this collection satisify the predicate test. Returns false otherwise.

docs inherited from Iterable<E> 
bool every(bool f(E element)) {
 for (E element in this) {
   if (!f(element)) return false;
 }
 return true;
}

Iterable expand(Iterable f(E element)) #

inherited from IterableBase

Expands each element of this Iterable into zero or more elements.

The resulting Iterable runs through the elements returned by f for each element of this, in order.

The returned Iterable is lazy, and calls f for each element of this every time it's iterated.

docs inherited from Iterable<E> 
Iterable expand(Iterable f(E element)) =>
   new ExpandIterable<E, dynamic>(this, f);

dynamic firstWhere(bool test(E value), {Object orElse()}) #

inherited from IterableBase

Returns the first element that satisfies the given predicate test.

If none matches, the result of invoking the orElse function is returned. By default, when orElse is null, a StateError is thrown.

docs inherited from Iterable<E> 
dynamic firstWhere(bool test(E value), { Object orElse() }) {
 for (E element in this) {
   if (test(element)) return element;
 }
 if (orElse != null) return orElse();
 throw new StateError("No matching element");
}

dynamic fold(initialValue, combine(previousValue, E element)) #

inherited from IterableBase

Reduces a collection to a single value by iteratively combining each element of the collection with an existing value using the provided function.

Use initialValue as the initial value, and the function combine to create a new value from the previous one and an element.

Example of calculating the sum of an iterable:

iterable.fold(0, (prev, element) => prev + element);
docs inherited from Iterable<E> 
dynamic fold(var initialValue,
            dynamic combine(var previousValue, E element)) {
 var value = initialValue;
 for (E element in this) value = combine(value, element);
 return value;
}

void forEach(void f(E element)) #

inherited from IterableBase

Applies the function f to each element of this collection.

docs inherited from Iterable<E> 
void forEach(void f(E element)) {
 for (E element in this) f(element);
}

String join([String separator = ""]) #

inherited from IterableBase

Converts each element to a String and concatenates the strings.

Converts each element to a String by calling Object.toString on it. Then concatenates the strings, optionally separated by the separator string.

docs inherited from Iterable<E> 
String join([String separator = ""]) {
 Iterator<E> iterator = this.iterator;
 if (!iterator.moveNext()) return "";
 StringBuffer buffer = new StringBuffer();
 if (separator == null || separator == "") {
   do {
     buffer.write("${iterator.current}");
   } while (iterator.moveNext());
 } else {
   buffer.write("${iterator.current}");
   while (iterator.moveNext()) {
     buffer.write(separator);
     buffer.write("${iterator.current}");
   }
 }
 return buffer.toString();
}

dynamic lastWhere(bool test(E value), {Object orElse()}) #

inherited from IterableBase

Returns the last element that satisfies the given predicate test.

If none matches, the result of invoking the orElse function is returned. By default, when orElse is null, a StateError is thrown.

docs inherited from Iterable<E> 
dynamic lastWhere(bool test(E value), { Object orElse() }) {
 E result = null;
 bool foundMatching = false;
 for (E element in this) {
   if (test(element)) {
     result = element;
     foundMatching = true;
   }
 }
 if (foundMatching) return result;
 if (orElse != null) return orElse();
 throw new StateError("No matching element");
}

Finite map(f(A x)) #

Finite is a functor.

Finite map(f(A x)) => new Finite._(this.length, new _OMap(this, f));

E reduce(E combine(E value, E element)) #

inherited from IterableBase

Reduces a collection to a single value by iteratively combining elements of the collection using the provided function.

Example of calculating the sum of an iterable:

iterable.reduce((value, element) => value + element);
docs inherited from Iterable<E> 
E reduce(E combine(E value, E element)) {
 Iterator<E> iterator = this.iterator;
 if (!iterator.moveNext()) {
   throw new StateError("No elements");
 }
 E value = iterator.current;
 while (iterator.moveNext()) {
   value = combine(value, iterator.current);
 }
 return value;
}

E singleWhere(bool test(E value)) #

inherited from IterableBase

Returns the single element that satisfies test. If no or more than one element match then a StateError is thrown.

docs inherited from Iterable<E> 
E singleWhere(bool test(E value)) {
 E result = null;
 bool foundMatching = false;
 for (E element in this) {
   if (test(element)) {
     if (foundMatching) {
       throw new StateError("More than one matching element");
     }
     result = element;
     foundMatching = true;
   }
 }
 if (foundMatching) return result;
 throw new StateError("No matching element");
}

Iterable<E> skip(int n) #

inherited from IterableBase

Returns an Iterable that skips the first n elements.

If this has fewer than n elements, then the resulting Iterable is empty.

It is an error if n is negative.

docs inherited from Iterable<E> 
Iterable<E> skip(int n) {
 return new SkipIterable<E>(this, n);
}

Iterable<E> skipWhile(bool test(E value)) #

inherited from IterableBase

Returns an Iterable that skips elements while test is satisfied.

The filtering happens lazily. Every new Iterator of the returned Iterable iterates over all elements of this.

As long as the iterator's elements satisfy test they are discarded. Once an element does not satisfy the test the iterator stops testing and uses every later element unconditionally. That is, the elements of the returned Iterable are the elements of this starting from the first element that does not satisfy test.

docs inherited from Iterable<E> 
Iterable<E> skipWhile(bool test(E value)) {
 return new SkipWhileIterable<E>(this, test);
}

Iterable<E> take(int n) #

inherited from IterableBase

Returns an Iterable with at most n elements.

The returned Iterable may contain fewer than n elements, if this contains fewer than n elements.

It is an error if n is negative.

docs inherited from Iterable<E> 
Iterable<E> take(int n) {
 return new TakeIterable<E>(this, n);
}

Iterable<E> takeWhile(bool test(E value)) #

inherited from IterableBase

Returns an Iterable that stops once test is not satisfied anymore.

The filtering happens lazily. Every new Iterator of the returned Iterable starts iterating over the elements of this.

When the iterator encounters an element e that does not satisfy test, it discards e and moves into the finished state. That is, it does not get or provide any more elements.

docs inherited from Iterable<E> 
Iterable<E> takeWhile(bool test(E value)) {
 return new TakeWhileIterable<E>(this, test);
}

LazyList<A> toLazyList() #

LazyList<A> toLazyList() {
 aux(i) => (i == this.length)
     ? new LazyList.empty()
     : new LazyList.cons(this[i], () => aux(i+1));
 return aux(0);
}

List<E> toList({bool growable: true}) #

inherited from IterableBase

Creates a List containing the elements of this Iterable.

The elements are in iteration order. The list is fixed-length if growable is false.

docs inherited from Iterable<E> 
List<E> toList({ bool growable: true }) =>
   new List<E>.from(this, growable: growable);

Set<E> toSet() #

inherited from IterableBase

Creates a Set containing the elements of this Iterable.

docs inherited from Iterable<E> 
Set<E> toSet() => new Set<E>.from(this);

String toString() #

Returns a string representation of this object.

docs inherited from Object 
String toString() {
 final strings = toLazyList().map((f) => f.toString()).toList();
 return "{${strings.join(", ")}}";
}

Iterable<E> where(bool f(E element)) #

inherited from IterableBase

Returns a lazy Iterable with all elements that satisfy the predicate test.

This method returns a view of the mapped elements. As long as the returned Iterable is not iterated over, the supplied function test will not be invoked. Iterating will not cache results, and thus iterating multiple times over the returned Iterable will invoke the supplied function test multiple times on the same element.

docs inherited from Iterable<E> 
Iterable<E> where(bool f(E element)) => new WhereIterable<E>(this, f);
This page was generated at 2013-10-03 01:35:38.048