Datatype comparisons, choosing opposite condition

Monkey Forums/Monkey Beginners/Datatype comparisons, choosing opposite condition

consty

(Posted 2014) [#1]

Strict

Class Entity
End

Class Person Extends Entity
End

Class Cat Extends Entity
End

Function Main:Int()
	Local p:Person = new Person
	Local c:Cat = new Cat

	If Person(p)
		Print("The p object is an instance of the Person class")
	End

	If Entity(p) And Entity(c)
		Print("Both p and c objects are derived from the Entity base class")
	End
	
	Return 0
End

I am interested to know if it is possible to make negative type comparisons.

For example if c variable is checked against the Person class
Person(c)

Instead of not letting the program compile, it would be better to just take it as a false and ignore the if statement.

I don't know if this brings troubles and incompatibilities, anyway I just wanted to mention it here for the sake of it and we will see what happens.

Pharmhaus

(Posted 2014) [#2]

Instead of not letting the program compile, it would be better to just take it as a false and ignore the if statement.

Do you mean that you like to remove 'Person' some times?
You could use the preprocessor for that.

#PERSON = false

Class Entity

End

Class Cat Extends Entity

End

Function Main:Int()
	#if PERSON
		Local p:Person = New Person
		Local c:Cat = new Cat
	
		If Person(p)
			Print("The p object is an instance of the Person class")
		End
	#else
		Local p:Entity = New Entity
		Local c:Cat = New Cat
	#endif
	
	If Entity(p) And Entity(c)
		Print("Both p and c objects are derived from the Entity base class")
	End
	
	Return 0
End

Or something like this?

Strict

Const ENTITY:Int = 1
Const PERSON:Int = 2
Const CAT:Int = 3

Class Entity

	Method Type:Int() Property
		Return ENTITY
	End

End

Class Person Extends Entity

	Method Type:Int() Property
		Return PERSON
	End
	
End

Class Cat Extends Entity

	Method Type:Int() Property
		Return CAT
	End
End

Function Main:Int()
	Local p:Person = new Person
	Local c:Cat = new Cat

	If Entity(p).Type = PERSON
		Print("The p object is an instance of the Person class")
	End

	If Entity(p) And Entity(c)
		Print("Both p and c objects are derived from the Entity base class")
	End
	
	Return 0
End

consty

(Posted 2014) [#3]

Hi Pharmhaus, thanks for responding. I liked the second example you offered, that this is also correct approach.

What I am bothered mostly is about having precise type to type comparison. I found that the code works only if the objects are derived from a base class, otherwise the comparison will never happen.

What Monkey understands is that you try to convert a person to a cat in order to compare it's datatype. Which this is impossible and hence the program fails to compile.

Strict

Class Entity
End

Class Person Extends Entity
End

Class Cat Extends Entity
End

Function DoIt:Void(entity:Entity)
	If Cat(entity)
		Print("Meow!")
	End
	If Person(entity)
		Print("Hello!")
	End
End

Function Main:Int()
	Local p:Person = new Person
	Local c:Cat = new Cat
	DoIt(p)
	DoIt(c)

	' This won't compile
	'If Cat(p)
	''	Print("")
	'End

	If Cat(Entity(p))
		Print("Please replace logic processing unit")
	Else
		Print("Correct: Person object is not instance of Cat class")
	End
	Return 0
End

I don't know what is this about, as far I understand is a concept very familiar to C programmers. Personally I have used only PHP and C# so I am more convenient with reflection and dynamism.

Pharmhaus

(Posted 2014) [#4]

Ahh, I see you try to do something similiar to duck typing.
sorry, that is not possible in the way you would like to do it, you would like to use polymorphism instead.
Anyway, I remeber that I wrote something like this some time ago, I will see if it is still around somewhere.

Using simple polymorphism:

Strict

Class Entity

	Method DoIt:Void()
		Print "Entity here."
	End
	
End

Class Person Extends Entity

	Method DoIt:Void()
		Print("Hello!")
	End
	
End

Class Cat Extends Entity

	Method DoIt:Void()
		Print("Meow!")
		Super.DoIt() ' Calling a 'hidden' method from the entity class
	End
	
End

Function Main:Int()
	Local p:Entity = New Person ' We can eliminate the need for a person variable by placing a 'Person' in an 'Entity' variable
	Local c:Entity = New Cat ' This way, a part of our program can use a Class without knowing it (see function below), all we need is a method in Entity to call

	p.DoIt() ' Person 'DoIt' now 'hides' Entity 'DoIt' (Both still exist, but Person DoIt is now called when we call DoIt on a person)
	c.DoIt() ' same goes for cats

	DoSomething(p)
	DoSomething(c)
	
	Return 0
End


Function DoSomething:Void(e:Entity)
	e.DoIt() ' Will call different DoIt depending on the real Class of 'e' this allows you to write very generic code
End

Using reflection to get some type of ducktyping/type checking:
(Please note: reflection increases compilation time and is not the fastest)

Strict

#rem
	SAVE AS ducktyping.monkey
#END

#REFLECTION_FILTER="ducktyping"  'only reflect this file or we will wait for the app forever to compile
Import reflection


Class MyClass
	Field X:int = 10
End

Class MyA Extends MyClass
	Field Y:int = 1567
End

Class MyB Extends MyClass
	Field Y:int
End

Function Main:Int()
	Local Test:MyClass = New MyA
	Local Copy:MyB = MyB(Ducktyping(Test, "MyB")) ' Converts a 'MyA' to 'MyB' without security checks so be careful
	
	If TypeComparison(Test, "MyA") Then ' Check if 'Test' is of type 'MyA' (please note: does not check if Test extends from 'MyA', so (Test,"MyClass") will return false )
		Print "Its of type MyA!"
	EndIf
	
	If TypeComparison(Copy, "MyB") Then
		Print "Its of type MyB!"
	EndIf
	
	Print Copy.X
	Print Copy.Y
	
	Return 0
End

Function Ducktyping:Object(SrcClass:Object, DestClass:String)
	Local C1:ClassInfo = GetClass(SrcClass)
	Local C2:ClassInfo = GetClass(DestClass)
	Local O:Object
	Local F:FieldInfo
	
	If C2 = Null Then
		Error "Class " + DestClass + " does not exist (Missing #REFLECTION_FILTER ?)"
	EndIf
	
	O = C2.NewInstance()
	
	For Local i:FieldInfo = EachIn C2.GetFields(True)
		F = C1.GetField(i.Name, True)
		If F Then
			i.SetValue(O, F.GetValue(SrcClass))
		EndIf
	Next
	
	Return O
End

Function TypeComparison:bool(First:Object, Second:String)
	If First = Null And Second = "" Then
		Return True
	ElseIf First = Null or Second = ""
		Return False
	EndIf
	
	Local FirstInfo:ClassInfo = GetClass(First)
	Local SecondInfo:ClassInfo = GetClass(Second)
	
	If SecondInfo = Null Then Return False
	
	If FirstInfo.Name = SecondInfo.Name Then
		Return True
	Else
		Return False
	EndIf
End

consty

(Posted 2014) [#5]

Wow this example took it to the next level. Monkey is indeed powerful language. Thanks for posting.