Data-structure

func(v ...interface{}) map[string]interface{}

[[ $result := dict "field1" "This is a test string" ]]
$result = map[field1:This is a test string]

[[ $result := dict "field1" "This is a test string" "field2" "Test string 2" ]]
$result = map[field1:This is a test string field2:Test string 2]

[[ dict "field1" "This is a test string" "fieldinteger2" 999 ]]
$result = map[field1:This is a test string fieldinteger2:999]

func(list interface{}) interface{}

[[ $result := first (list "field1" "This is a test string" "field2" "Test string 2")  ]]
$result = field1

[[ $result := first (list "This is a test string" "field1" "field2" "Test string 2")  ]]
$result = This is a test string

func(haystack interface{}, needle interface{}) bool

[[ $result := has ( list "A" "B" "C" ) "B" ]]
$result = true

[[ $result := has ( list "A" "B" "C" ) "Z" ]]
$result = false

func(item interface{}) []interface{}

[[ $result := initial ( list "A" "B" "C" ) ]]
$result = [A B]

func(dicts ...map[string]interface{}) []string

[[ $result := keys ( dict "F2" "B" "F3" "C" ) ]]
$result = [F2 F3]

func(list interface{}) interface{}

[[ $result := last ( list "A" "B" "C" ) ]]
$result = C

func(v ...interface{}) []interface{}

[[ $result := list "This is a test string" "ing" ]]
$result = [This is a test string ing]

[[ $result := list 1 2 3 4 ]]
$result = [1 2 3 4]

func(d map[string]interface{}, key string, value interface{}) map[string]interface{}

[[ $result    := dict "F1" "A" ]]
[[ $result    := mapSet $map "F4" "D" ]]
$result = map[F1:A F4:D]

[[ $map    := mapSet $map "firstName" "Max" ]]
[[ $map    := mapSet $map "lastName" "Muster" ]]
$result = map[firstName:Max lastName:Muster]

func(d map[string]interface{}, key string) map[string]interface{}

[[ $result := mapUnset $result "fieldinteger2"  ]]
$result = map[]

complex example with dict, mapSet and mapUnset command
[[ $map := dict "F1" "A" ]]
[[ $map := mapSet $map "F2" "B" ]]
[[ $result := mapUnset $map "F2" ]]
$result = map[F1:A]

func(dst map[string]interface{}, srcs ...map[string]interface{}) interface{}

[[ $result := indent "This is a test string" 5 ]]
$result = "     This is a test string"

[[ $map1   := dict "firstName" "Max" ]]
[[ $map2   := dict "lastName" "Muster" ]]
[[ $result := merge $map1 $map2 ]]
$result = map[firstName:Max lastName:Muster]

complex example with dict, mapSet and mapUnset command
[[ $map3   := dict "2ndFristName" "Willhelm" ]]
[[ $result := merge $map1 $map2 $map3 ]]
$result = map[2ndFristName:Willhelm firstName:Max lastName:Muster]

func(dst map[string]interface{}, srcs ...map[string]interface{}) (interface{}, error)

[[ $map30   := dict "lastName" "Meier" ]]
[[ $map31   := dict "lastName" "Huber" ]]
[[ $result  := mergeOverwrite $map30 $map31 ]]
$result = map[lastName:Huber]

func(dict map[string]interface{}, keys ...string) map[string]interface{}

[[ $map := dict "F1" "A" "F2" "B" "F3" "C" ]]
[[ $result := omit $map "F1" "F3" ]]
$result = map[F2:B]

complex example with dict, mapSet and omit command
[[ $map := newMap  ]]
[[ $map := dict "F1" "A" "F3" "C" ]]
[[ $map  = mapSet $map "F4" "D" ]]
[[ $map  = mapSet $map "F5" "Z" ]]
[[ $map  = mapSet $map "F2" "B" ]]
[[ $result := omit $map "F4" "F1" "F3" ]]
$result = map[F2:B F5:Z]

func(dict map[string]interface{}, keys ...string) map[string]interface{}

[[ $map    := dict "F1" "A" "F2" "B" ]]
[[ $result := pick $map "F2" ]]
$result = map[F2:B]

func(key string, d ...map[string]interface{}) []interface{}

[[ $map    := dict "F1" "A" "F2" "B" ]]
[[ $result := pluck "F2" $map ]]
$result = [B]

complex example with dict and pluck command
[[ $map    := newMap  ]]
[[ $map    := dict "F1" "A" "F2" "B2" ]]
[[ $map1   := dict "F1" "A" "F2" "ValueB field F2 in $map1" ]]
[[ $result := pluck "F2" $map $map1]]
$result = [B2 ValueB field F2 in $map1]

example with not found
[[ $map    := newMap  ]]
[[ $map    := dict "F1" "A" "F2" "B2" ]]
[[ $map1   := dict "F1" "A" "F2" "ValueB field F2 in $map1" ]]
[[ $result := pluck "F9" $map $map1]]
$result = []

func(list interface{}, v interface{}) []interface{}

[[ $result := list "A" "B" "C" "D" ]]
[[ $result := prepend $list "BeforeA" ]]
$result = [BeforeA A B C D]

func(list interface{}, v interface{}) []interface{}

[[ $result := list "A" "B" "C" "D" ]]
[[ $result := push $result "AfterD" ]]
$result = [A B C D AfterD]

func(list interface{}) []interface{}

[[ $result := rest ( list 1 2 3 4 )  ]]
$result = "[2 3 4]"

[[ $list := list "This" "is" "a" "test" "string" ]]
[[ $result := rest $list ]]
$result = [is a test string]

func(v interface{}) []interface{}

[[ $list := list "This" "is" "a" "test" "string" ]]
[[ $result := reverse $list ]]
$result = [string test a is This]

[[ $result := reverse ( list 1 2 3 4 )  ]]
$result = "[4 3 2 1]"

func(list interface{}, indices ...interface{}) interface{}

[[ $result := slice ( list 1 2 3 4 5 ) 1 4 ]]
$result = [2 3 4]

[[ $list := list "This" "is" "a" "test" "string" ]]
[[ $result := slice $list 1 3 ]]
$result = [is a]

[[ $result := slice ( list 1 2 3 4 5 6 7 8 9 ) 7 ]]
$result = [8 9]

func(list interface{}) []interface{}

[[ $result := uniq ( list 1 1 2 2 )]]
$result = [1 2]

[[ $result := uniq ( list 0 0 1 1 2 2 3 3 4 4 5 5 6 6 7 7 8 8 9 9 ) ]]
$result = [0 1 2 3 4 5 6 7 8 9]

[[ $result := uniq ( list "This" "is" "a" "test" "string" "This" "test" ) ]]
$result = [This is a test string]

func(dict map[string]interface{}) []interface{}

[[ $result := values ( mapSet ( dict "F1" "A" ) "F4" "D" ) ]]
$result = [A D]

[[ $map    := dict "firstName" "Max" ]]
[[ $map    := mapSet $map "lastName" "Muster" ]]
[[ $result := values $map ]]
$result = [Max Muster]

func(list interface{}, omit ...interface{}) []interface{}

[[ $result := without ( list "This" "is" "a" "test" "string" ) "a" "string" ]]
$result = [This is test]

[[ $result := without ( list 1 2 3 4 ) 3 ]]
$result = [1 2 4]