function-call.jul

myFunction = (a b) => log(a b)

# 1. Argumente direkt übergeben
myFunction(1 2)

# 2. Argumente mit Parameternamen übergeben
myFunction(
	a = 1
	b = 2
)

# 2.1 Die Reihenfolge der Argumente ist egal (anders als bei 1.)
myFunction(
	b = 2
	a = 1
)

# 3. Argumente in einer List mit spread-Operator
myList = (1 2)
myFunction(...myList)

# 4. Argumente in einem Dictionary mit spread-Operator
myDictionary = (
	a = 1
	b = 2
)
myFunction(...myDictionary)

# 4.1 Die Reihenfolge der Argumente ist egal (anders als bei 3.)
myDictionary1 = (
	b = 2
	a = 1
)
myFunction(...myDictionary1)

# Bei 1. und 2. ist die Übergabe von nicht definierten Parametern nicht erlaubt.
# Bei 3. und 4. ist die Übergabe von nicht definierten Parametern erlaubt.

# Type Parametered Function
MyType = (
	a: 1
	b: 2
)
myFunction1 = (a: MyType) => log(§hi§)
myFunction1((a = 1 b = 2))
# äquivalent
typeFunction = MyType => log(§hi§)
typeFunction((a = 1 b = 2))

# TODO mit Parameternamen nicht erlaubt?
typeFunction(a = (a = 1 b = 2))

# Rest Parameter
restFunction = (...restParameter) => log(restParameter)

restFunction(1 2)
# äquivalent
restFunction(...(1 2))
# nicht äquivalent
restFunction((1 2))

# TODO mit Parameternamen nicht erlaubt?
restFunction(
	a = 1
	b = 2
)

# Rest Parameter getypt
# TODO rest type nur List oder auch Dictionary? bei rest Dictionary Parameternamen spreaden?
# bei rest type Tuple/DictionaryLiteral: feste Anzahl Argumente erzwingen?
restFunction2 = (...restParameter: MyType) => log(§hi§)
# äquivalent?
myFunction4 = (a: 1 b: 2) => log(§hi§)

# alias
aliasFn = (a1: Boolean = a b1 = b) => log(b1)
higherOrderFn = (fn: (a: Boolean b: Text) :> ()) => ()
higherOrderFn(aliasFn)

# nicht äquivalent
fn1 = (a: Boolean b: Text) => ()
fn2 = (b: Text a: Boolean) => ()