Weird compile error: Illegal EachIn expression

BlitzMax Forums/BlitzMax Programming/Weird compile error: Illegal EachIn expression

Pineapple

(Posted 2013) [#1]

I get that compile error when attempting to run this:

For Local t$=EachIn hash.ObjectEnumerator()
	Print t
Next

While this compiles fine and works as expected:

For Local t$=EachIn hash
	Print t
Next

What's going on?

Here's the rest of the code.

Local hash:hash2d=hash2d.Create(256,32)
Local n%=0
For Local i%=2 Until 4
For Local j%=0 Until 8
	hash.insert i,j,String(n)
	Print n
	n:+1
Next
Next
Print "---------"
For Local t$=EachIn hash.ObjectEnumerator()
	Print t
Next


Type hash2denum
	Field hashindex%,nextindex%,hash:hash2d,link:TLink
	Field nodeenum%=0
	Function Create:hash2denum(hash:hash2d,nodeenum%)
		Local n:hash2denum=New hash2denum
		n.hash=hash
		n.nodeenum=nodeenum
		n.init
		Return n
	End Function
	Method init()
		hashindex=-1;nextindex=-1
		Local index%=0
		Repeat
			If hash.content[index] And (Not hash.content[index].isempty())
				If hashindex=-1 Then
					hashindex=index
					link=hash.content[index]._head._succ
				Else
					nextindex=index
					Exit
				EndIf
			EndIf
			index:+1
			If index>=hash.size Then Exit
		Forever
	End Method
	Method HasNext%()
		Return nextindex>-1 Or (link And link<>link._value)'link._succ<>link._succ._value)
	End Method
	Method NextObject:Object()
		Assert link
		Local value:Object=link._value
		link=link._succ
		If link=link._value And nextindex>-1 Then
			hashindex=nextindex
			link=hash.content[hashindex]._head._succ
			Repeat
				nextindex:+1
				If nextindex>=hash.size Then nextindex=-1;Exit
				If hash.content[nextindex] And (Not hash.content[nextindex].isempty()) Then Exit
			Forever
		EndIf
		If nodeenum
			Return value
		Else
			Return hash2dnode(value).value
		EndIf
	End Method
End Type
Type hash2d
	Field size%,pitch%
	Field count%
	Field content:TList[]
	Function Create:hash2d(size%,pitch%=128)
		Local n:hash2d=New hash2d
		n.setsize(size)
		n.pitch=pitch
		Return n
	End Function
	Method setsize(nsize%)
		size=nsize
		content=New TList[size]
		count=0
	End Method
	Method findnode:hash2dnode(x%,y%)
		Local index%=contentindex(x,y)
		Local list:TList=content[index]
		If list Then
			Local link:TLink=list._head._succ
			While link<>content[index]._head
				Local node:hash2dnode=hash2dnode(link._value)
				If node.x=x And node.y=y Then
					link._pred._succ=link._succ
					link._succ._pred=link._pred
					link._succ=list._head._succ
					link._pred=list._head
					list._head._succ._pred=link
					list._head._succ=link
					Return node
				EndIf
				link=link._succ
			Wend
		EndIf
		Return Null
	End Method
	Method find:Object(x%,y%)
		Local node:hash2dnode=findnode(x,y)
		If node Then
			Return node.value
		Else
			Return Null
		EndIf
	End Method
	Method insert:hash2dnode(x%,y%,value:Object)
		Local index%=contentindex(x,y)
		Local node:hash2dnode=hash2dnode.Create(x,y,value)
		If Not content[index] Then content[index]=CreateList()
		content[index].addfirst node
		count:+1
		Return node
	End Method
	Method removenode%(node:hash2dnode)
		Assert node
		Local index%=contentindex(node.x,node.y)
		Local list:TList=content[index]
		If list.remove(node)
			count:-1
			If list.isempty() content[index]=Null
			Return True
		Else
			Return False
		EndIf
	End Method
	Method remove%(x%,y%)
		Local node:hash2dnode=findnode(x,y)
		If node Then
			Return removenode(node)
		Else
			Return False
		EndIf
	End Method
	Method contentindex%(x%,y%)
		Return (((x+y*pitch) Mod size)+size) Mod size
	End Method
	Method ObjectEnumerator:hash2denum()
		Return hash2denum.Create(Self,0)
	End Method
	Method NodeEnumerator:hash2denum()
		Return hash2denum.Create(Self,1)
	End Method
End Type
Type hash2dnode
	Field x%,y%
	Field value:Object
	Function Create:hash2dnode(x%,y%,value:Object)
		Local n:hash2dnode=New hash2dnode
		n.x=x;n.y=y;n.value=value
		Return n
	End Function
End Type

Brucey

(Posted 2013) [#2]

I believe ObjectEnumerator() is a "private" method which implements the enumeration stuff, but which you don't use yourself.
When you use Eachin, BlitzMax expects the argument to be of a certain structure - either an array or an Object which has the enumeration functionality.

Yasha

(Posted 2013) [#3]

To put it another way: EachIn calls ObjectEnumerator on the object passed as collection. If you call ObjectEnumerator yourself, you're no longer passing a collection that can be enumerated by EachIn (unless you work some naughtiness so that your enumerator is also a collection, which is conceptually just plain wrong); the thing you're passing has the wrong structure for what EachIn expects to do with it (but you don't get a type error because this is implemented separately from type checking; in Monkey you would presumably get a type error indicating the wrong interface).

It's a type error, with a weird message. An enumerator is not a collection.

Analogous situation: say you have a function that returns the width of an image prepended with "Foo":

Strict

Function Foopify:String(img:TImage)
    Return "Foo " + ImageWidth(img)
End Function

Local img:TImage = CreateImage(256, 256)

Print Foopify(img)        ' Fine, prints "Foo 256"

Print Foopify(ImageWidth(img))    ' Type error: we need a TImage, not a number

By trying to do one step of the internal process yourself, you change the type of the value and render the whole thing invalid. BlitzMax doesn't actually call it a type error because its type system doesn't include interfaces, but it is the same thing.

Pineapple

(Posted 2013) [#4]

How do the functions which return iterators such as MapKeys work, then? And the error isn't isolated to the ObjectEnumerator method, the error also occurs when trying to use NodeEnumerator, which is the one I was really expecting to use. And I've written similar code in the past that worked without issue.

This code executes without any error and runs as expected:

Import pine.HashTable

Local hash:HashTable=CreateHash(32)
HashInsert hash,"foo","bar"

For Local s$=EachIn hash.ObjectEnumerator()
	Print s
Next

And the pine.HashTable module is available here, for any relevant code: http://blitzbasic.com/Community/post.php?topic=97992&post=1141947

I'm only trying to reproduce the same basic thing that I did before, and I'm not sure what's different about the enumeration code.

Pineapple

(Posted 2013) [#5]

Okay, I found the issue. It was a very easy fix.

I merely added this to my hash2denum type:

Method ObjectEnumerator:hash2denum()
	Return Self
End Method