Difference between revisions of "Iterable Immutable List Assignment"

From CSE425S Wiki
Jump to navigation Jump to search
 
(51 intermediate revisions by the same user not shown)
Line 1: Line 1:
−
=Code To Implement=
+
=Exercise To Revisit=
−
==DefaultImmutableList==
+
In this studio we will complete the <code>EmptyImmutableList</code> and <code>NonEmptyImmutableList</code> implementations from the [[ImmutableList_Assignment|ImmutableList exercise]].
−
{{JavaToImplement|DefaultImmutableList|head<br>tail<br>isEmpty<br>iterator|immutable.list.assignment}}
+
 
−
===default constructor===
+
==ImmutableList==
−
===head and tail constructor===
+
The [https://www.cse.wustl.edu/~cosgroved/courses/cse425s/spring20/apidocs/immutable/list/core/ImmutableList.html ImmutableList] interface extends [https://docs.oracle.com/javase/8/docs/api/java/lang/Iterable.html Iterable] which has one method: [https://docs.oracle.com/javase/8/docs/api/java/lang/Iterable.html#iterator-- iterator()].
−
===head===
+
 
−
===tail===
+
<nowiki>public interface ImmutableList<E> extends Iterable<E> {
−
===isEmpty===
+
E head();
−
===iterator===
+
ImmutableList<E> tail();
 +
boolean isEmpty();
 +
}</nowiki>
 +
 
 +
==Iterable==
 +
[https://docs.oracle.com/javase/8/docs/api/java/lang/Iterable.html interface java.lang.Iterable<T>]
 +
#[https://docs.oracle.com/javase/8/docs/api/java/lang/Iterable.html#iterator-- Iterator<T> iterator()]
 +
 
 +
==Iterator==
 +
[https://docs.oracle.com/javase/8/docs/api/java/util/Iterator.html interface java.util.Iterator<T>]
 +
#[https://docs.oracle.com/javase/8/docs/api/java/util/Iterator.html#hasNext-- boolean hasNext()]
 +
#[https://docs.oracle.com/javase/8/docs/api/java/util/Iterator.html#next-- T next()]
 +
 
 +
=Examples=
 +
==Using Iterable==
 +
<youtube>A-rTJTHq5B4</youtube>
 +
==Implementing Iterable: DOM NodeList==
 +
<youtube>4ycpqdJ4yb4</youtube>
 +
 
 +
=Example=
 +
{{Example|IterableImmutableListExample|immutable.list.example}}
 +
 
 +
The code:
 +
<nowiki>ImmutableList<Integer> numbers = Lists.brackets(4, 66, 99);
 +
for (Integer i : numbers) {
 +
System.out.println(i);
 +
}</nowiki>
 +
 
 +
produces:
 +
<nowiki>4
 +
66
 +
99</nowiki>
 +
 
 +
=Diagrams=
 +
==ImmutableList==
 +
<nowiki>ImList<Char> letters = Lists.brackets('A', 'B', 'C'); </nowiki>
 +
 
 +
[[File:ImmutableList_letters.svg|600px]]
 +
 
 +
==Initial Iterator State==
 +
 
 +
<nowiki>ImList<Char> letters = Lists.brackets('A', 'B', 'C');
 +
Iterator<Char> iter = letters.iterator(); </nowiki>
 +
 
 +
[[File:ImmutableList_iterator.svg|600px]]
 +
 
 +
==Iterator State after next()==
 +
 
 +
<nowiki>ImList<Char> letters = Lists.brackets('A', 'B', 'C');
 +
Iterator<Char> iter = letters.iterator();
 +
if(iter.hasNext()) {
 +
    char a = iter.next();
 +
} </nowiki>
  
−
==Lists==
+
[[File:ImmutableList_iterator_next.svg|600px]]
−
<code>Lists</code> is a class which holds a number of static methods.  As we know, in [https://steve-yegge.blogspot.com/2006/03/execution-in-kingdom-of-nouns.html the Kingdom of Nouns], Verbs must always have an escort.
 
  
−
The first two static methods <code>nil</code> and <code>cons</code> will each call a constructor of the <code>DefaultImmutableList</code> class. The third method <code>brackets</code> will use <code>nil</code> and <code>cons</code> to build up the desired ImmutableList.
+
==Iterator State after next() next()==
 +
<nowiki>ImList<Char> letters = Lists.brackets('A', 'B', 'C');
 +
Iterator<Char> iter = letters.iterator();
 +
if(iter.hasNext()) {
 +
    char a = iter.next();
 +
    if(iter.hasNext()) {
 +
        char b = iter.next();
 +
    }
 +
} </nowiki>
  
−
{{JavaToImplement|Lists|nil<br>cons<br>brackets|immutable.list.assignment}}
+
[[File:ImmutableList_iterator_next_next.svg|600px]]
−
===nil===
+
==Iterator State after next() next() next()==
−
  <nowiki>public static <E> ImmutableList<E> nil()</nowiki>
+
  <nowiki>ImList<Char> letters = Lists.brackets('A', 'B', 'C');
 +
Iterator<Char> iter = letters.iterator();
 +
if(iter.hasNext()) {
 +
    char a = iter.next();
 +
    if(iter.hasNext()) {
 +
        char b = iter.next();
 +
        if(iter.hasNext()) {
 +
            char c = iter.next();
 +
        }
 +
    }
 +
} </nowiki>
  
−
Analogous to the [http://sml-family.org/Basis/list.html SML List] [http://sml-family.org/Basis/list.html#SIG:LIST.nil:TY nil constructor].
+
[[File:ImmutableList_iterator_next_next_next.svg|600px]]
  
−
Note: often SML programs use empty brackets <code>[]</code> instead of <code>nil</code>.
+
=Code To Implement=
 +
==enum EmptyImmutableList==
 +
{{JavaToImplement|EmptyImmutableList|iterator|immutable.list.assignment}}
 +
===iterator()===
 +
return an [https://docs.oracle.com/javase/8/docs/api/java/util/Iterator.html Iterator] for the EmptyImmutableList.
  
−
===cons===
+
Question to ask yourself: Does an iterator for an EmptyImmutableList ever have a next?
−
<nowiki>public static <E> ImmutableList<E> cons(E head, ImmutableList<E> tail)</nowiki>
 
  
−
Analogous to the [http://sml-family.org/Basis/list.html SML List] [http://sml-family.org/Basis/list.html#SIG:LIST.:::TY :: constructor].
+
==class NonEmptyImmutableList==
 +
{{JavaToImplement|NonEmptyImmutableList|iterator|immutable.list.assignment}}
 +
===iterator()===
 +
return an [https://docs.oracle.com/javase/8/docs/api/java/util/Iterator.html Iterator] for this instance of NonEmptyImmutableList.
  
−
===brackets===
+
Note: If you are within an anonymous inner class, the way to get the outer class's this instance is to qualify it with the out class identifier. For example:
−
  <nowiki>@SafeVarargs
 
−
public static <E> ImmutableList<E> brackets(E... elements)</nowiki>
 
  
−
<code>brackets</code> accepts [https://docs.oracle.com/javase/8/docs/technotes/guides/language/varargs.html variable length arguments] as specified by the <code>...</code> syntax.  When implementing the <code>brackets</code> method you can treat <code>elements</code> as an array.  Combining generics and varargs can be problematic if the implementation lets the E[] escape since it will actually be an Object[].  The [[https://docs.oracle.com/javase/7/docs/api/java/lang/SafeVarargs.html @SafeVarargs]] annotation indicates a promise that you will rely [https://stackoverflow.com/questions/14231037/java-safevarargs-annotation-does-a-standard-or-best-practice-exist only on the elements of the array being of type E].  This should not be a problem.
+
<nowiki>NonEmptyImmutableList.this</nowiki>
  
 
=Test=
 
=Test=
−
{{TestSuite|ListsTestSuite|immutable.list.assignment}}
+
{{TestSuite|IterableAssignmentTestSuite|immutable.list.util.exercise}}
 +
 
 +
:{{TestSuite|ImmutableListIteratorMethodTestSuite|immutable.list.util.exercise}}

Latest revision as of 19:05, 24 April 2022

Exercise To Revisit

In this studio we will complete the EmptyImmutableList and NonEmptyImmutableList implementations from the ImmutableList exercise.

ImmutableList

The ImmutableList interface extends Iterable which has one method: iterator(). 

public interface ImmutableList<E> extends Iterable<E> {
	E head();
	ImmutableList<E> tail();
	boolean isEmpty();
}

Iterable

interface java.lang.Iterable<T>

  1. Iterator<T> iterator()

Iterator

interface java.util.Iterator<T>

  1. boolean hasNext()
  2. T next()

Examples

Using Iterable

Implementing Iterable: DOM NodeList

Example

class: IterableImmutableListExample.java Presentation icon-72a7cf.svg
package: immutable.list.example
source folder: src/main/java

The code: 

ImmutableList<Integer> numbers = Lists.brackets(4, 66, 99);
for (Integer i : numbers) {
	System.out.println(i);
}

produces: 

4
66
99

Diagrams

ImmutableList

ImList<Char> letters = Lists.brackets('A', 'B', 'C');

ImmutableList letters.svg

Initial Iterator State

ImList<Char> letters = Lists.brackets('A', 'B', 'C');
Iterator<Char> iter = letters.iterator();

ImmutableList iterator.svg

Iterator State after next()

ImList<Char> letters = Lists.brackets('A', 'B', 'C');
Iterator<Char> iter = letters.iterator();
if(iter.hasNext()) {
    char a = iter.next();
}

ImmutableList iterator next.svg

Iterator State after next() next()

ImList<Char> letters = Lists.brackets('A', 'B', 'C');
Iterator<Char> iter = letters.iterator();
if(iter.hasNext()) {
    char a = iter.next();
    if(iter.hasNext()) {
        char b = iter.next();
    }
}

ImmutableList iterator next next.svg

Iterator State after next() next() next()

ImList<Char> letters = Lists.brackets('A', 'B', 'C');
Iterator<Char> iter = letters.iterator();
if(iter.hasNext()) {
    char a = iter.next();
    if(iter.hasNext()) {
        char b = iter.next();
        if(iter.hasNext()) {
            char c = iter.next();
        }
    }
}

ImmutableList iterator next next next.svg

Code To Implement

enum EmptyImmutableList

class: EmptyImmutableList.java Java.png
methods: iterator
package: immutable.list.assignment
source folder: src/main/java

iterator()

return an Iterator for the EmptyImmutableList.

Question to ask yourself: Does an iterator for an EmptyImmutableList ever have a next?

class NonEmptyImmutableList

class: NonEmptyImmutableList.java Java.png
methods: iterator
package: immutable.list.assignment
source folder: src/main/java

iterator()

return an Iterator for this instance of NonEmptyImmutableList.

Note: If you are within an anonymous inner class, the way to get the outer class's this instance is to qualify it with the out class identifier. For example: 

NonEmptyImmutableList.this

Test

class: IterableAssignmentTestSuite.java Junit.png
package: immutable.list.util.exercise
source folder: src/test/java
class: ImmutableListIteratorMethodTestSuite.java Junit.png
package: immutable.list.util.exercise
source folder: src/test/java
Retrieved from "http://classes.engineering.wustl.edu/cse425s/index.php?title=Iterable_Immutable_List_Assignment&oldid=1656"