(vote) varargs / params feature

[nerobotParticipant]

Is it useful for you to have params feature in Monkey2?

Shortly: it’s an easy way to pass various number of parameters (with the same type).

Internally our params is an usaul array.

Monkey

' example 1 Function PrintSum( title:String,numbers:Int[] Params ) Local sum:=0 For Local n:=Eachin numbers sum+=n Next Print title+" : "+sum End PrintSum( "total: ",3,7,0,12 ) ' example 2 Function ArrayOf<T>:T[]( items:T[] Params ) Return items ' maybe not so 'directly' way End Local arr:=ArrayOf<String>( "one","two" )

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

' example 1 Function PrintSum( title:String,numbers:Int[] Params )   Local sum:=0   For Local n:=Eachin numbers     sum+=n   Next   Print title+" : "+sum End PrintSum( "total: ",3,7,0,12 )   ' example 2 Function ArrayOf<T>:T[]( items:T[] Params )   Return items ' maybe not so 'directly' way End Local arr:=ArrayOf<String>( "one","two" )

More info: https://msdn.microsoft.com/en-us/en-en/library/w5zay9db(v=vs.110).aspx

[coconParticipant]

From what I guess (based on similar threads) Mark wants to avoid syntactic sugar additions (unless they are mostly essential) in order to keep the parser thin and lightweight, perhaps I might be mistaken.

If the feature won’t make to the parser API hacks can be used for sure. This concept is based on factory patterns – to encapsulate the logic of creating stuff.

In the example below, the motivation is to pack variables into an array and return the array. The function overloading works like a dream here because it makes  things very simple – a similar approach was used in the Tuples example I made earlier.

In this case if you dislike the API naming, perhaps other more meaningful names can be found, perhaps even extending the std Array class to form a smooth integration.

Monkey

#Import "<std>" Using std.. Class Params Abstract Function Create<T>:T[](item1:T) Return New T[] (item1) End Function Create<T>:T[](item1:T, item2:T) Return New T[] (item1, item2) End Function Create<T>:T[](item1:T, item2:T, item3:T) Return New T[] (item1, item2, item3) End Function Create<T>:T[](item1:T, item2:T, item3:T, item4:T) Return New T[] (item1, item2, item3, item4) End Function Create<T>:T[](item1:T, item2:T, item3:T, item4:T, item5:T) Return New T[] (item1, item2, item3, item4, item5) End End Function RunCommand(tokens:String[]) Local command := "" For Local t := Eachin tokens command += t + " " Next Print(command) End Function Main() ' the default way ' RunCommand(New String[] ("Start", "Level")) ' RunCommand(New String[] ("Create", "Player", "RandomPosition")) ' RunCommand(New String[] ("Create", "Enemy", "LotsOfThem", "100", "Robots")) ' RunCommand(New String[] ("Timer", "Start")) ' RunCommand(New String[] ("Begin", "Countdown", "GameLogic", "3")) ' with params RunCommand(Params.Create("Start", "Level")) RunCommand(Params.Create("Create", "Player", "RandomPosition")) RunCommand(Params.Create("Create", "Enemy", "LotsOfThem", "100", "Robots")) RunCommand(Params.Create("Timer", "Start")) RunCommand(Params.Create("Begin", "Countdown", "GameLogic", "3")) 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

#Import "<std>" Using std..   Class Params Abstract Function Create<T>:T[](item1:T) Return New T[] (item1) End   Function Create<T>:T[](item1:T, item2:T) Return New T[] (item1, item2) End   Function Create<T>:T[](item1:T, item2:T, item3:T) Return New T[] (item1, item2, item3) End   Function Create<T>:T[](item1:T, item2:T, item3:T, item4:T) Return New T[] (item1, item2, item3, item4) End   Function Create<T>:T[](item1:T, item2:T, item3:T, item4:T, item5:T) Return New T[] (item1, item2, item3, item4, item5) End End   Function RunCommand(tokens:String[]) Local command := "" For Local t := Eachin tokens command += t + " " Next Print(command) End   Function Main() ' the default way ' RunCommand(New String[] ("Start", "Level")) ' RunCommand(New String[] ("Create", "Player", "RandomPosition")) ' RunCommand(New String[] ("Create", "Enemy", "LotsOfThem", "100", "Robots")) ' RunCommand(New String[] ("Timer", "Start")) ' RunCommand(New String[] ("Begin", "Countdown", "GameLogic", "3"))   ' with params RunCommand(Params.Create("Start", "Level")) RunCommand(Params.Create("Create", "Player", "RandomPosition")) RunCommand(Params.Create("Create", "Enemy", "LotsOfThem", "100", "Robots")) RunCommand(Params.Create("Timer", "Start")) RunCommand(Params.Create("Begin", "Countdown", "GameLogic", "3")) End

[nerobotParticipant]

Idea is to hide Params.Create under the hood to simplify code.

From what I guess (based on similar threads) Mark wants to avoid syntactic sugar additions (unless they are mostly essential)

I created thit topic to ask if anybody like it and have usecases, looking at this Mark can decide to implement that or not.

[coconParticipant]

I would like it also as well.

[scurtyParticipant]

Seems to me like a basic form of an initializer list as seen in C++.
Hmm, I feel like we should fuse this concept with the tuples so the type could vary from param to param.
Definitely useful in game programming for sure when initializing component based entities.

[nerobotParticipant]

@scurty

Hmm, I feel like we should fuse this concept with the tuples so the type could vary from param to param.

Can you explain that concept?

For components you can declare function with base type Component and pass any derived types.

[scurtyParticipant]

Well as it’s stated you can only pass a shared data type with “Params” but if you could pass a string and an int within the same line(like passing a tuple) you could state attributes for a character controller-like component that takes arguments like initializing the new RPG character or something similar.

Name:String
Description
Age:Int
JumpHeight:Double
AttackValue:Double

You could do:

Monkey

Class RPGCharacterController Extends Component Field myParams:Params[] Method New<Params[]> (newParams:params[]) Self.myParams = newParams End Method End Class Function Main() Local myCharacter:= New RPGCharacterController( ("name", 18, "description", 3.0, 5.0) ) End Main

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

Class RPGCharacterController Extends Component          Field myParams:Params[]          Method New<Params[]> (newParams:params[])          Self.myParams = newParams     End Method   End Class   Function Main()       Local myCharacter:= New RPGCharacterController( ("name", 18, "description", 3.0, 5.0) )   End Main

[nerobotParticipant]

You said about different things.

We discuss here special keyword Params (or Varargs), which is used as an addition to array type.

It has the only purpose – allow to pass varying params count, but all of them with the same type.

Would work with typles as well because they are an usual type (if will be added ):

Monkey

Function ArrayOf<T>:T[]( items:T[] Params ) Return items End ' with tuple Local arr:=ArrayOf<(Int,String)>( (1,"one"),(2,"two") )

1 2 3 4 5

Function ArrayOf<T>:T[]( items:T[] Params )   Return items End ' with tuple Local arr:=ArrayOf<(Int,String)>( (1,"one"),(2,"two") )

[nerobotParticipant]

Usecase: c#-like string.Format() where {0},{1},… will be replaced with args[i] in order you pass params.

Monkey

' c#-like string.Format Method Format:String( str:String,args:String[] Params) For Local i:=0 Until args.Length str=str.Replace( "{"+i+"}",args[i] ) Next Return str End ' usage Local template:="{0} is the best {1} for {3}!" Print Format( template,"Ted2Go","IDE","Monkey2" ) Print Format( template,"Monkey2","tool","gemedev" )

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

' c#-like string.Format Method Format:String( str:String,args:String[] Params)     For Local i:=0 Until args.Length         str=str.Replace( "{"+i+"}",args[i] )     Next     Return str End   ' usage Local template:="{0} is the best {1} for {3}!" Print Format( template,"Ted2Go","IDE","Monkey2" ) Print Format( template,"Monkey2","tool","gemedev" )

[Author]

Posts