Python, Functional Programming: I need help with my iterator class and it's methods. The idea is that I can turn any of my hash array mapped trie objects into an iterable object and use sytem functions like map on it$.$ I know that I need to take whatever my root node's $($firstitem$)$ non$-$None children and put them into a list and the repeat the process on each child, but I can't seem to be able to turn the hamt object into an object of HamtIter.

from functools import reduce

class hamt:

DEG $=4$ # Children per node $($can be set to any power of $2)$

BITS $=2$ # Should be log$2($DEG$),$ bits needed to select child

MASK $=0$b$11$ # Should be BITS one$-$bits

def $\_\_$init$\_\_($self$,$ item $=$ None, children $=$ None$)$:

self.$\_$item $=$ item

if children $==$ None:

self.$\_$children $=[$None$]*$ hamt.DEG # List of DEG Nones

else:

self.$\_$children $=$ children

# returns copy of self node with child i set to node x

def updatechild$($self$,$ i$,$ x$)$:

updatedchildlist $=$ list$($self$.\_$children$)$ # copy self's child list

updatedchildlist$[$i$]=$ x # update child i

return hamt$($self$.\_$item, updatedchildlist$)$ # build and return new node

# Returns reference to new root if change made, else None

def $\_$add$($self$,$ item, hashbits$)$:

if self.$\_$item $==$ item:

# This node matches item. Return None to indicate no change.

return None

else:

# Continue search using hashbits to pick direction

child$\_$num $=$ hashbits & hamt.MASK

if self.$\_$children$[$child$\_$num$]==$ None:

# item not in trie. Add it as new leaf node.

return self.updatechild$($child$\_$num, hamt$($item$))$

else:

# Ask appropriate child to add item, receive updated reference

shiftedhashbits $=$ hashbits $>>$ hamt.BITS

newchild $=$ self.$\_$children$[$child$\_$num$].\_$add$($item$,$ shiftedhashbits$)$

if newchild $==$ None:

return None

else:

return self.updatechild$($child$\_$num, newchild$)$

def add$($self$,$ item$)$:

# Pass item and hashbits to private recursive helper

return self.$\_$add$($item$,$ hash$($item$))$

# Returns True if trie has no items, else False. Rutime O$(1).$

def empty$($self$)$:

return self.$\_$item $==$ None and all$($child $==$ None for child in self.$\_$children$)$

# Returns True if item in trie, else False. Expected rutime O$($log n$).$

def contains$($self$,$ item$)$:

if self.$\_$item $==$ item:

return True

else:

child$\_$num $=$ hash$($item$)$ & hamt.MASK

if self.$\_$children$[$child$\_$num$]==$ None:

return False

else:

shiftedhashbits $=$ hash$($item$)>>$ hamt.BITS

return self.$\_$children$[$child$\_$num$].$contains$($item$,$ shiftedhashbits$)$

# Returns number of items in trie. Runtime O$($n$).$

def $\_\_$len$\_\_($self$)$:

if self.$\_$item $==$ None:

return $0$

else:

return sum$(1$ for child in self.$\_$children if child $!=$ None$)+1$

# Returns HAMT that is union of self and other. Expected rutime O$($n log n$).$

def union$($self$,$ other$)$:

result $=$ hamt$()$

for item in self:

result $=$ result.add$($item$)$

for item in other:

result $=$ result.add$($item$)$

return result

def $\_\_$iter$\_\_($self$)$:

return HamtIter$($self$)$

# Adds self's item string to acc list, then ask each child to do the same

def $\_$str$($self$,$ acc$)$:

if self.$\_$item $!=$ None: # Don't do anything in fake root node

acc.append$($str$($self$.\_$item$))$

for child in self.$\_$children:

if child $!=$ None:

child.$\_$str$($acc$)$

class HamtIter:

def $\_\_$init$\_\_($self$,$ firstitem$)$:

def $\_\_$next$\_\_($self$)$: