{{task}} A template for data is an arbitrarily nested tree of integer indices.

Data payloads are given as a separate mapping, array or other simpler, flat, association of indices to individual items of data, and are strings.

The idea is to create a data structure with the templates' nesting, and the payload corresponding to each index appearing at the position of each index.

Answers using simple string replacement or regexp are to be avoided. The idea is to use the native, or usual implementation of lists/tuples etc of the language and to hierarchically traverse the template to generate the output.

;Task Detail: Given the following input template t and list of payloads p: # Square brackets are used here to denote nesting but may be changed for other,

clear, visual representations of nested data appropriate to ones programming

language.

t = [ [[1, 2], [3, 4, 1], 5]]

p = 'Payload#0' ... 'Payload#6'

The correct output should have the following structure, (although spacing and 
linefeeds may differ, the nesting and order should follow):
<lang>[[['Payload#1', 'Payload#2'],
  ['Payload#3', 'Payload#4', 'Payload#1'],
  'Payload#5']]

1. Generate the output for the above template, t.

;Optional Extended tasks: 2. Show which payloads remain unused.

3. Give some indication/handling of indices without a payload.

''Show output on this page.''

Bracmat

The uninstantiated template and the instantiated template are JSON structures. The payloads are listed in a Bracmat list. The get function is instructed to read input from memory and to parse it as JSON. The output of this call is a Bracmat structure (not shown) that is assigned to template. The instantiate function recursively traverses the template's tree structure. If the current node is a number, then that number is used as the key into the payloads list. The corresponding payload is then returned. If the current node is not a number, then it is assumed that the current node is a binary (sub)tree. The left hand side (called a) and the right hand side (called b) are instantiated and their combination is returned. Finally the instantiated tree is transformed back to JSON format and output.

(   get$("[
    [[1, 2],
     [3, 4, 1],
     5]]",MEM,JSN)
  : ?template
&     (0.payload#0)
      (1.payload#1)
      (2.payload#2)
      (3.payload#3)
      (4.payload#4)
      (5.payload#5)
      (6.payload#6)
  : ?payloads
& ( instantiate
  =   tmplt plds pld a b
    .   !arg:(?tmplt.?plds)
      & (   !tmplt:#
          & !plds:? (!tmplt.?pld) ?
          & !pld
        |   !tmplt:%?a_%?b
          & (instantiate$(!a.!plds))_(instantiate$(!b.!plds))
        )
  )
& out$(jsn$(instantiate$(!template.!payloads)))
);

{{out}}

[[[payload#1,payload#2],[payload#3,payload#4,payload#1],payload#5]]

Crystal

def with_payload(template, payload, used = nil)
    template.map do |item|
      if item.is_a? Enumerable
        with_payload(item, payload, used)
      else
        used << item
        payload[item]
      end
    end
end

p = {"Payload#0", "Payload#1", "Payload#2", "Payload#3", "Payload#4", "Payload#5", "Payload#6"}
t = { { {1, 2}, {3, 4, 1}, 5}}
used = Set(Int32).new
puts with_payload(t, p, used)

unused = Set(Int32).new((0..6).to_a) - used
puts "Unused indices: #{unused}"

{{out}}

{{{"Payload#1", "Payload#2"}, {"Payload#3", "Payload#4", "Payload#1"}, "Payload#5"}}
Unused indices: Set{0, 6}

Factor

Words for traversing nested sequences can be found in the sequences.deep vocabulary. Factor's prettyprinter attempts to print structures on a single line (64 characters by default, though this can be changed) if they will fit. Otherwise, the prettyprinter will break them up into multiple lines, preferring to show one member per line if possible. f, Factor's false/nil value, is used to indicate a missing payload.

USING: formatting kernel literals math sequences sequences.deep ;
IN: rosetta-code.nested-template-data

CONSTANT: payloads $[ 7 <iota> [ "Payload#%d" sprintf ] map ]

: insert-payloads ( template -- data-structure )
    [ dup fixnum? [ payloads ?nth ] when ] deep-map ;
    
{ { { 1 2 }
    { 3 4 1 }
    5 } }
    
{ { { 1 2 }
    { 10 4 1 }
    5 } }
    
[ dup insert-payloads "Template: %u\nData Structure: %u\n"
printf ] bi@

{{out}}

Template: { { { 1 2 } { 3 4 1 } 5 } }
Data Structure: {
    {
        { "Payload#1" "Payload#2" }
        { "Payload#3" "Payload#4" "Payload#1" }
        "Payload#5"
    }
}
Template: { { { 1 2 } { 10 4 1 } 5 } }
Data Structure: {
    {
        { "Payload#1" "Payload#2" }
        { f "Payload#4" "Payload#1" }
        "Payload#5"
    }
}

Go

Go's standard library includes a "text/template" package which can be used for this task.

The integer indices are represented by the keys of a map whose corresponding value is the appropriate payload string. Templates have their own mini-language and, for a map P with key n, the expression:

{{index .P n}}

will be replaced by the corresponding payload.

If an integer index either doesn't exist in the map or maps to an empty payload, then the above expression will simply be replaced by an empty string when the template is executed.

package main

import (
    "fmt"
    "os"
    "sort"
    "strings"
    "text/template"
)

func main() {
    const t = `[[[{{index .P 1}}, {{index .P 2}}],
  [{{index .P 3}}, {{index .P 4}}, {{index .P 1}}], 
  {{index .P 5}}]]
`
    type S struct {
        P map[int]string
    }

    var s S
    s.P = map[int]string{
        0: "'Payload#0'", 1: "'Payload#1'", 2: "'Payload#2'", 3: "'Payload#3'",
        4: "'Payload#4'", 5: "'Payload#5'", 6: "'Payload#6'",
    }
    tmpl := template.Must(template.New("").Parse(t))
    tmpl.Execute(os.Stdout, s)

    var unused []int
    for k, _ := range s.P {
        if !strings.Contains(t, fmt.Sprintf("{{index .P %d}}", k)) {
            unused = append(unused, k)
        }
    }
    sort.Ints(unused)
    fmt.Println("\nThe unused payloads have indices of :", unused)
}

{{out}}

[[['Payload#1', 'Payload#2'],
  ['Payload#3', 'Payload#4', 'Payload#1'], 
  'Payload#5']]

The unused payloads have indices of : [0 6]

Julia

The array structure needs to be specified as Any type of data, to allow later assignment of strings to the paces in the array where there are integers.

t = ([Any[Any[1, 2],
          Any[3, 4, 1],
          5]])

p = ["Payload#$x" for x in 0:6]

for (i, e) in enumerate(t)
    if e isa Number
        t[i] = p[e + 1]
    else
        for (j, f) in enumerate(e)
            if f isa Number
                e[j] = p[f + 1]
            else
                for (k, g) in enumerate(f)
                    if g isa Number
                        f[k] = p[g + 1]
                    end
                end
            end
        end
    end
end


show(t)

{{output}}

Array{Any,1}[[Any["Payload#1", "Payload#2"], Any["Payload#3", "Payload#4", "Payload#1"], "Payload#5"]]

M2000 Interpreter

Font "Courier New"
cls
Module Checkit {
      t=(((1,2), (3,4,1),5),)    ' use (1,) for one item tuple
      Tuple$ = lambda$ (a, feed$=" ") -> {
            \\ we can pass a tuple of two arguments or two arguments
            k=each(a)
            lim=len(a)-1
            res$="("
            link a to a() ' to use type$()
            while k {
                  if type$(a(k^))="mArray" then
                        res$+=Lambda$(array(a, k^),feed$+" ")
                        if k^<lim then
                              res$+={,
                              }+feed$
                        end if
                  else      
                        res$+= trim$(str$(array(k)))
                        if k^<lim then res$+=", "
                  end if
            }
            =res$+")"
      }
      TotalPayload = lambda (a)->{
            k=each(a)
            link a to a()
            res=0
            while k {
                  if type$(a(k^))="mArray" then
                        res+=Lambda(a(k^))
                  else
                        res++
                  end if
            }
            =res
      }
      Payload = lambda (a,payloads as list)->{
           misspayloads=List
           used=list
           inner=lambda misspayloads, p=1, payloads, used (a)-> {
                  k=each(a)
                  res=(,)
                  link a to a()
                  while k {
                        if type$(a(k^))="mArray" then
                             Append res, (Lambda(a(k^)),)
                        else
                              curpayload$="Payload#"+trim$(str$(array(k)))

                              if not exist(payloads, curpayload$) Then
                                    if not exist(used, curpayload$) Then
                                          Append res, ("missing#pos"+trim$(str$(p)),)
                                          append misspayloads, p:=curpayload$
                                    else                               
                                          Append res, (curpayload$,)
                                    End if
                                    p++
                              else
                                    Append res, (curpayload$,)
                                    if exist(payloads, curpayload$) then 
                                          delete payloads, curpayload$
                                          if not exist(used, curpayload$) then append used, curpayload$
                                    end if
                                    p++
                              end if
                        end if
                  }
                  =res
            }
            =inner(a), payloads, misspayloads
      }
      Expand$ =lambda$ (a as array, unused as list, misspayloads as list)-> {
            Read ? space$
            inner$= lambda$ (a, feed$=" ")->{
                  k=each(a)
                  lim=len(a)-1
                  res$="["
                  link a to a() ' to use type$()
                  while k {
                        if type$(a(k^))="mArray" then
                              res$+=Lambda$(array(a, k^),feed$+" ")
                              if k^<lim then
                                    res$+={,
                                    }+feed$
                              end if
                        else      
                              res$+= "'"+array$(k)+"'"
                              if k^<lim then res$+=", "
                        end if
                  }
                  =res$+"]"      
            }
            document unused$="Unused Payloads"+{
            }
            if len(unused)>0 then
                  un=each(unused)
                  while un {
                        unused$="  "+eval$(un)+{
                        }
                  }
            else
                  unused$="  -"
            end if
            if len(misspayloads)>0 then
                  un=each(misspayloads)
                  lim=len(misspayloads)-1
                  document missing$="Missing in position: "+{
                  }
                  while un {
                        missing$="  "+eval$(un)+"-pos"+eval$(un,un^)+{
                        }
                  }
                  =inner$(a, space$)+{
                  }+unused$+missing$
            Else
                  =inner$(a, space$)+{
                  } + unused$
            End if
      }
      flush
      Data t, (((1,10), (3,4,16),5),)
      While not empty {
            Read t
            Document result$="Payloads:"+{
            }
            p=list
            for i=0 to 6 {
                  Append p, "Payload#"+trim$(str$(i))
                  result$="  "+eval$(p, i)+{
                  }
            }
            result$="Template:"+{
            }
            result$="  "+Tuple$(t, "   ")+{
            }
            result$="Template with Payloads:"+{
            }
            m=Payload(t, p)
            result$="  "+Expand$(!m, "   ")
            
            clipboard result$
      }
      
}
Checkit
Report clipboard$

{{out}}

Payloads:
  Payload#0
  Payload#1
  Payload#2
  Payload#3
  Payload#4
  Payload#5
  Payload#6
Template:
  (((1, 2),
    (3, 4, 1),
    5))
Template with Payloads:
  [[['Payload#1', 'Payload#2'],
    ['Payload#3', 'Payload#4', 'Payload#1'],
    'Payload#5']]
Unused Payloads
  Payload#0
  Payload#6
Payloads:
  Payload#0
  Payload#1
  Payload#2
  Payload#3
  Payload#4
  Payload#5
  Payload#6
Template:
  (((1, 10),
    (3, 4, 16),
    5))
Template with Payloads:
  [[['Payload#1', 'missing#pos2'],
    ['Payload#3', 'Payload#4', 'missing#pos5'],
    'Payload#5']]
Unused Payloads
  Payload#0
  Payload#6
  Payload#2
Missing in position: 
  Payload#10-pos2
  Payload#16-pos5