Trying to understand a few things…

[jondecker76Participant]

Monkey

#Import "<std>" Using std.. Global test:= New Map<String,String> test["test"]="Hello" Function Main() Print test["test"] End

1 2 3 4 5 6 7 8 9 10 11 12

#Import "<std>" Using std..   Global test:= New Map<String,String> test["test"]="Hello"     Function Main() Print test["test"] End

I’m trying to learn the language but I’m not understanding why this won’t build.  I’m assuming that we can’t define variables outside of a function?  I hope this isn’t the case as it would make things extremely ugly.  I’m trying to port some old code and I need to define a map of a few dozen items.  Having to do it inside of a function just seems strange to me.  Is there something that I’m missing?

[DruggedBunnyParticipant]

That’s basically right, though simple assignments can be done if you can define them on the same line, eg. Global a:=1.

You can of course assign them in Main, which, if you think about it, is really what defining variables ‘outside of functions’ was in Blitz & co. Monkey/Monkey2 just adopted the more formal approach of having an explicit Main…

Monkey

#Import "<std>" Using std.. Global a:= 1 Global test:= New Map<String,String> Function Main() test["test"]="Hello" test["temp"]="Bye" Print test["test"] Print test["temp"] End

1 2 3 4 5 6 7 8 9 10 11 12 13 14 15 16 17

#Import "<std>"   Using std..   Global a:= 1 Global test:= New Map<String,String>       Function Main() test["test"]="Hello" test["temp"]="Bye" Print test["test"] Print test["temp"] End

I tried a few variations but I don’t think there’s a way to initiate the string data on the global line in this case. (Could be wrong… )

[DaniloParticipant]

It is possible if you use your own class that extends Map.

With simple-type Arrays it is possible to initialize when declaring it:

Monkey

#Import "<std>" Using std.. Global intArr1D := New Int[] ( 9, 8, 7, 6 ) Global intArr2D := New Int[][] ( New Int[]( 0, 1, 2, 3, 4, 5, 6, 7, 8, 9 ), New Int[]( 9, 8, 7, 6, 5, 4, 3, 2, 1, 0 ), New Int[]( 0, 0, 0, 0, 0, 0, 0, 0, 0, 0 ), New Int[]( 0, 0, 0, 0, 0, 0, 0, 0, 0, 0 ), New Int[]( 0, 0, 0, 0, 8, 8, 0, 0, 0, 0 ), New Int[]( 0, 0, 0, 0, 8, 8, 0, 0, 0, 0 ), New Int[]( 0, 0, 0, 8, 8, 8, 8, 0, 0, 0 ), New Int[]( 0, 0, 8, 0, 0, 0, 0, 8, 0, 0 ), New Int[]( 0, 8, 0, 0, 0, 0, 0, 0, 8, 0 ), New Int[]( 8, 0, 0, 0, 0, 0, 0, 0, 0, 8 ) ) Global strArr1D := New String[] ( "s1", "s2", "s3", "s4" ) Global strArr2D := New String[][] ( New String[]("a1", "a2"), New String[]("b1", "b2"), New String[]("c1", "c2") ) Function Main() Print intArr1D[ 2 ] ' 7 Print intArr2D[ 0 ][ 7 ] ' 7 Print intArr2D[ 1 ][ 1 ] ' 8 Print strArr1D[ 2 ] ' s3 Print strArr2D[ 2 ][ 1 ] ' c2 End

1 2 3 4 5 6 7 8 9 10 11 12 13 14 15 16 17 18 19 20 21 22 23 24 25 26 27 28 29 30 31 32 33 34 35 36

#Import "<std>" Using std..   Global intArr1D := New Int[] ( 9, 8, 7, 6 )   Global intArr2D := New Int[][] (     New Int[]( 0, 1, 2, 3, 4, 5, 6, 7, 8, 9 ),     New Int[]( 9, 8, 7, 6, 5, 4, 3, 2, 1, 0 ),     New Int[]( 0, 0, 0, 0, 0, 0, 0, 0, 0, 0 ),     New Int[]( 0, 0, 0, 0, 0, 0, 0, 0, 0, 0 ),     New Int[]( 0, 0, 0, 0, 8, 8, 0, 0, 0, 0 ),     New Int[]( 0, 0, 0, 0, 8, 8, 0, 0, 0, 0 ),     New Int[]( 0, 0, 0, 8, 8, 8, 8, 0, 0, 0 ),     New Int[]( 0, 0, 8, 0, 0, 0, 0, 8, 0, 0 ),     New Int[]( 0, 8, 0, 0, 0, 0, 0, 0, 8, 0 ),     New Int[]( 8, 0, 0, 0, 0, 0, 0, 0, 0, 8 ) )   Global strArr1D := New String[] ( "s1", "s2", "s3", "s4" )   Global strArr2D := New String[][] (     New String[]("a1", "a2"),     New String[]("b1", "b2"),     New String[]("c1", "c2") )   Function Main()   Print intArr1D[ 2 ]      ' 7       Print intArr2D[ 0 ][ 7 ] ' 7     Print intArr2D[ 1 ][ 1 ] ' 8       Print strArr1D[ 2 ]      ' s3       Print strArr2D[ 2 ][ 1 ] ' c2 End

 

Now we can use that principle and write a generic class that extends Map<K,V>, let’s call it MapEx<K,V>.

We then add a constructor (“New”) that takes an array of Value+Key pairs for initializing the Map.

 

That would look like this:

Monkey

#Import "<std>" Using std.. Global test:= New MapEx<String,String>( New MapExPair<String,String> []( New MapExPair<String,String>("test1","Hello 1"), New MapExPair<String,String>("test2","Hello 2") ) ) Function Main() Print test["test1"] Print test["test2"] Print test["test3"] Local newMap1 := MapEx<String,Int>.Create() Local newMap2 := MapEx<String,Int>.Create( New MapExPair<String,Int>[]( New MapExPair<String,Int>("value 1",12) ) ) Print newMap2["value 1"] End ' ' MapExPair is a pair of Key + Value ' Class MapExPair<K,V> Field key:K Field value:V Method New( _key:K, _value:V ) key = _key value = _value End End ' ' Extended Map class with Initializers ' Class MapEx<K,V> Extends Map<K,V> Method New() Super.New() End Method New( values:MapExPair<K,V>[] ) For Local value := Eachin values Self[value.key] = value.value Next End Function Create:MapEx<K,V>() Return New MapEx<K,V>() End Function Create:MapEx<K,V>( values:MapExPair<K,V>[] ) Return New MapEx<K,V>( values ) End End

1 2 3 4 5 6 7 8 9 10 11 12 13 14 15 16 17 18 19 20 21 22 23 24 25 26 27 28 29 30 31 32 33 34 35 36 37 38 39 40 41 42 43 44 45 46 47 48 49 50 51 52 53 54 55 56 57 58 59 60 61 62 63

#Import "<std>" Using std..   Global test:= New MapEx<String,String>( New MapExPair<String,String> [](   New MapExPair<String,String>("test1","Hello 1"),   New MapExPair<String,String>("test2","Hello 2") ) )   Function Main()     Print test["test1"] Print test["test2"] Print test["test3"]         Local newMap1 := MapEx<String,Int>.Create()       Local newMap2 := MapEx<String,Int>.Create(                         New MapExPair<String,Int>[](                            New MapExPair<String,Int>("value 1",12) ) )          Print newMap2["value 1"]   End     ' ' MapExPair is a pair of Key + Value ' Class MapExPair<K,V>     Field key:K     Field value:V     Method New( _key:K, _value:V )         key   = _key         value = _value     End End   ' ' Extended Map class with Initializers ' Class MapEx<K,V> Extends Map<K,V>       Method New()         Super.New()     End       Method New( values:MapExPair<K,V>[] )         For Local value := Eachin values             Self[value.key] = value.value         Next     End       Function Create:MapEx<K,V>()         Return New MapEx<K,V>()     End       Function Create:MapEx<K,V>( values:MapExPair<K,V>[] )         Return New MapEx<K,V>( values )     End   End

Okay, that works. But that constructs for initializing the Map are very big.

 

By using two ‘Alias’ we can shorten it:

Monkey

Alias MyMap:MapEx<String,String> Alias MyPair:MapExPair<String,String>

1 2	Alias MyMap:MapEx<String,String> Alias MyPair:MapExPair<String,String>

With those two Alias, we can now write a simpler global Map initialization:

Monkey

Global test:= New MyMap( New MyPair[] ( New MyPair("test1","Hello 1"), New MyPair("test2","Hello 2"), New MyPair("test3","Hello 3"), New MyPair("test4","Hello 4") ) )

1 2 3 4 5

Global test:= New MyMap( New MyPair[] (                              New MyPair("test1","Hello 1"),                              New MyPair("test2","Hello 2"),                              New MyPair("test3","Hello 3"),                              New MyPair("test4","Hello 4") ) )

Looks better, doesn’t it?

Here the final code:

Monkey

#Import "<std>" Using std.. Alias MyMap:MapEx<String,String> Alias MyPair:MapExPair<String,String> Global test:= New MyMap( New MyPair[] ( New MyPair("test1","Hello 1"), New MyPair("test2","Hello 2"), New MyPair("test3","Hello 3"), New MyPair("test4","Hello 4") ) ) Function Main() Print test["test1"] Print test["test2"] Print test["test3"] Print test["test4"] Local newMap1 := MyMap.Create() Local newMap2 := MyMap.Create( New MyPair[]( New MyPair("value 1","string 1") ) ) Print "-----" Print newMap2["value 1"] End ' ' MapExPair is a pair of Key + Value ' Class MapExPair<K,V> Field key:K Field value:V Method New( _key:K, _value:V ) key = _key value = _value End End ' ' Extended Map class with Initializers ' Class MapEx<K,V> Extends Map<K,V> Method New() Super.New() End Method New( values:MapExPair<K,V>[] ) For Local value := Eachin values Self[value.key] = value.value Next End Function Create:MapEx<K,V>() Return New MapEx<K,V>() End Function Create:MapEx<K,V>( values:MapExPair<K,V>[] ) Return New MapEx<K,V>( values ) End End

1 2 3 4 5 6 7 8 9 10 11 12 13 14 15 16 17 18 19 20 21 22 23 24 25 26 27 28 29 30 31 32 33 34 35 36 37 38 39 40 41 42 43 44 45 46 47 48 49 50 51 52 53 54 55 56 57 58 59 60 61 62 63 64 65 66 67 68 69

#Import "<std>" Using std..   Alias MyMap:MapEx<String,String> Alias MyPair:MapExPair<String,String>   Global test:= New MyMap( New MyPair[] (                              New MyPair("test1","Hello 1"),                              New MyPair("test2","Hello 2"),                              New MyPair("test3","Hello 3"),                              New MyPair("test4","Hello 4") ) )   Function Main()     Print test["test1"] Print test["test2"] Print test["test3"] Print test["test4"]         Local newMap1 := MyMap.Create()       Local newMap2 := MyMap.Create(                         New MyPair[](                            New MyPair("value 1","string 1") ) )          Print "-----"     Print newMap2["value 1"]   End     ' ' MapExPair is a pair of Key + Value ' Class MapExPair<K,V>     Field key:K     Field value:V     Method New( _key:K, _value:V )         key   = _key         value = _value     End End   ' ' Extended Map class with Initializers ' Class MapEx<K,V> Extends Map<K,V>       Method New()         Super.New()     End       Method New( values:MapExPair<K,V>[] )         For Local value := Eachin values             Self[value.key] = value.value         Next     End       Function Create:MapEx<K,V>()         Return New MapEx<K,V>()     End       Function Create:MapEx<K,V>( values:MapExPair<K,V>[] )         Return New MapEx<K,V>( values )     End   End

[Author]

Posts