Data commit

Task/Nested-templated-data/00-META.yaml

@@ -0,0 +1,2 @@
+---
+from: http://rosettacode.org/wiki/Nested_templated_data

Task/Nested-templated-data/00-TASK.txt

@@ -0,0 +1,37 @@
+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.<br>
+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 <code>t</code>  and list of payloads <code>p</code>:
+<syntaxhighlight lang="text"># 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'</syntaxhighlight>
+
+The correct output should have the following structure, (although spacing and 
+linefeeds may differ, the nesting and order should follow):
+<syntaxhighlight lang="text">[[['Payload#1', 'Payload#2'],
+  ['Payload#3', 'Payload#4', 'Payload#1'],
+  'Payload#5']]</syntaxhighlight>
+
+1. Generate the output for the above template, <code>t</code>.<br>
+
+;Optional Extended tasks:
+2. Show which payloads remain unused.<br>
+3. Give some indication/handling of indices without a payload.<br>
+
+''Show output on this page.''
+

Task/Nested-templated-data/AutoHotkey/nested-templated-data-1.ahk

@@ -0,0 +1,45 @@
+;-----------------------------------------------------------
+Nested_templated_data(template, Payload){
+	UsedP := [], UnusedP := [], UnusedI := []
+	result := template.Clone()
+	x := ArrMap(template, Payload, result, UsedP, UnusedI, [])
+	for i, v in Payload
+		if !UsedP[v]
+			UnusedP.Push(v)
+	return [x.1, x.2, UnusedP]
+}
+;-----------------------------------------------------------
+ArrMap(Template, Payload, result, UsedP, UnusedI, pth){
+	for i, index in Template	{
+		if IsObject(index)
+			pth.Push(i),	Arrmap(index, Payload, result, UsedP, UnusedI, pth)
+		else{
+			pth.Push(i),	ArrSetPath(result, pth, Payload[index])
+			if Payload[index]
+				UsedP[Payload[index]] := 1
+			else
+				UnusedI.Push(index)
+		}
+		pth.Pop()
+	}
+	return [result, UnusedI, UsedP]
+}
+;-----------------------------------------------------------
+ArrSetPath(Arr, pth, newVal){
+	temp := []
+	for k, v in pth{
+		temp.push(v)
+		if !IsObject(Arr[temp*])
+			Arr[temp*] := []
+	}
+	return Arr[temp*] := newVal
+}
+;-----------------------------------------------------------
+objcopy(obj){
+	nobj := obj.Clone()
+	for k, v in nobj
+		if IsObject(v)
+			nobj[k] := objcopy(v)
+	return nobj
+}
+;-----------------------------------------------------------

Task/Nested-templated-data/AutoHotkey/nested-templated-data-2.ahk

@@ -0,0 +1,7 @@
+T := [[[1,2] , [3,4,1] , 5]]
+; Autohotkey uses 1-based objects/arrays
+P := ["Payload#1", "Payload#2", "Payload#3", "Payload#4", "Payload#5", "Payload#6", "Payload#7"]
+Results := Nested_templated_data(objcopy(t), P)
+output := Results.1
+Undefined_indices := Results[2]
+Unused_Payloads := Results[3]

Task/Nested-templated-data/Bracmat/nested-templated-data.bracmat

@@ -0,0 +1,25 @@
+(   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)))
+);

Task/Nested-templated-data/C++/nested-templated-data.cpp

@@ -0,0 +1,87 @@
+#include <iostream>
+#include <set>
+#include <tuple>
+#include <vector>
+
+using namespace std;
+
+// print a single payload
+template<typename P>
+void PrintPayloads(const P &payloads, int index, bool isLast)
+{
+    if(index < 0 || index >= (int)size(payloads)) cout << "null";
+    else cout << "'" << payloads[index] << "'";
+    if (!isLast) cout << ", ";  // add a comma between elements
+}
+
+// print a tuple of playloads
+template<typename P, typename... Ts>
+void PrintPayloads(const P &payloads, tuple<Ts...> const& nestedTuple, bool isLast = true)
+{
+    std::apply  // recursively call PrintPayloads on each element of the tuple
+    (
+        [&payloads, isLast](Ts const&... tupleArgs)
+        {
+            size_t n{0};
+            cout << "[";
+            (PrintPayloads(payloads, tupleArgs, (++n == sizeof...(Ts)) ), ...);
+            cout << "]";
+            cout << (isLast ? "\n" : ",\n");
+        }, nestedTuple
+    );
+}
+
+// find the unique index of a single index (helper for the function below)
+void FindUniqueIndexes(set<int> &indexes, int index)
+{
+    indexes.insert(index);
+}
+
+// find the unique indexes in the tuples
+template<typename... Ts>
+void FindUniqueIndexes(set<int> &indexes, std::tuple<Ts...> const& nestedTuple)
+{
+    std::apply
+    (
+        [&indexes](Ts const&... tupleArgs)
+        {
+            (FindUniqueIndexes(indexes, tupleArgs),...);
+        }, nestedTuple
+    );
+}
+
+// print the payloads that were not used
+template<typename P>
+void PrintUnusedPayloads(const set<int> &usedIndexes, const P &payloads)
+{
+    for(size_t i = 0; i < size(payloads); i++)
+    {
+        if(usedIndexes.find(i) == usedIndexes.end() ) cout << payloads[i] << "\n";
+    }
+}
+
+int main()
+{
+    // define the playloads, they can be in most containers
+    vector payloads {"Payload#0", "Payload#1", "Payload#2", "Payload#3", "Payload#4", "Payload#5", "Payload#6"};
+    const char *shortPayloads[] {"Payload#0", "Payload#1", "Payload#2", "Payload#3"}; // as a C array
+
+    // define the indexes as a nested tuple
+    auto tpl = make_tuple(make_tuple(
+        make_tuple(1, 2),
+        make_tuple(3, 4, 1),
+        5));
+
+    cout << "Mapping indexes to payloads:\n";
+    PrintPayloads(payloads, tpl);
+
+    cout << "\nFinding unused payloads:\n";
+    set<int> usedIndexes;
+    FindUniqueIndexes(usedIndexes, tpl);
+    PrintUnusedPayloads(usedIndexes, payloads);
+
+    cout << "\nMapping to some out of range payloads:\n";
+    PrintPayloads(shortPayloads, tpl);
+
+    return 0;
+}

Task/Nested-templated-data/Crystal/nested-templated-data.crystal

@@ -0,0 +1,18 @@
+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}"

Task/Nested-templated-data/Factor/nested-templated-data.factor

@@ -0,0 +1,18 @@
+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@

Task/Nested-templated-data/Go/nested-templated-data-1.go

@@ -0,0 +1 @@
+{{index .P n}}

Task/Nested-templated-data/Go/nested-templated-data-2.go

@@ -0,0 +1,36 @@
+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)
+}

Task/Nested-templated-data/Haskell/nested-templated-data-1.hs

@@ -0,0 +1,7 @@
+{-# language DeriveTraversable #-}
+
+data Template a = Val a | List [Template a]
+  deriving ( Show
+           , Functor
+           , Foldable
+           , Traversable )

Task/Nested-templated-data/Haskell/nested-templated-data-2.hs

@@ -0,0 +1,2 @@
+subst :: (Functor t, Eq i) => [(i,a)] -> t i -> t (Maybe a)
+subst d = fmap (`lookup` d)

Task/Nested-templated-data/Haskell/nested-templated-data-3.hs

@@ -0,0 +1,2 @@
+indexed :: [a] -> [(Int, a)]
+indexed = zip [0..]

Task/Nested-templated-data/Haskell/nested-templated-data-4.hs

@@ -0,0 +1,7 @@
+t :: Template Int
+t = List [ List [Val 1, Val 2]
+         , List [Val 3, Val 4, Val 10]
+         , Val 5]
+
+payloads :: [(Int, String)]
+payloads = [(i, "payload#"++show i) | i <- [0..6]]

Task/Nested-templated-data/Haskell/nested-templated-data-5.hs

@@ -0,0 +1,7 @@
+unusedIndices :: (Foldable t, Eq i) => [(i,a)] -> t i -> [i]
+unusedIndices d = foldMap unused
+  where unused i = maybe (pure i) (pure []) $ lookup i d
+
+unusedData :: (Foldable t, Eq i) => [(i, a)] -> t i -> [(i,a)]
+unusedData = foldr delete
+  where delete i = filter ((i /= ) . fst)

Task/Nested-templated-data/Jq/nested-templated-data-1.jq

@@ -0,0 +1,22 @@
+#!/bin/bash
+function template {
+  cat<<EOF
+  [
+    [[1, 2],
+     [3, 4, 1],
+      5 ]]
+EOF
+}
+
+function payload {
+  for i in $(seq 0 6) ; do
+    echo Payload#$i
+  done
+}
+
+# Task 1: Template instantiation
+payload | jq -Rn --argfile t <(template) '
+  ([inputs] | with_entries(.key |= tostring)) as $dict
+  | $t
+  | walk(if type == "number" then $dict[tostring] else . end)
+'

Task/Nested-templated-data/Jq/nested-templated-data-2.jq

@@ -0,0 +1,4 @@
+payload | jq -Rn --argfile t <(template) '
+  ([inputs] | with_entries(.key |= tostring)) as $dict
+  | $dict[(($dict|keys_unsorted) - ([ $t | .. | numbers ] | unique | map(tostring) ))[]]
+'

Task/Nested-templated-data/Jq/nested-templated-data-3.jq

@@ -0,0 +1,7 @@
+payload | jq -Rrn --argfile t <(template) '
+  ([inputs] | with_entries(.key |= tostring)) as $dict
+  | $t
+  | walk(if type == "number" then $dict[tostring] else . end),
+    "\nUnused payload",
+    $dict[(($dict|keys_unsorted) - ([ $t | .. | numbers ] | unique | map(tostring) ))[]]
+'

Task/Nested-templated-data/Jq/nested-templated-data-4.jq

@@ -0,0 +1,18 @@
+[
+  [
+    [
+      "Payload#1",
+      "Payload#2"
+    ],
+    [
+      "Payload#3",
+      "Payload#4",
+      "Payload#1"
+    ],
+    "Payload#5"
+  ]
+]
+
+Unused payload
+Payload#0
+Payload#6

Task/Nested-templated-data/Julia/nested-templated-data.julia

@@ -0,0 +1,26 @@
+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)

Task/Nested-templated-data/M2000-Interpreter/nested-templated-data.m2000

@@ -0,0 +1,147 @@
+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$

Task/Nested-templated-data/Mathematica/nested-templated-data.math

@@ -0,0 +1,3 @@
+t = ToExpression[StringReplace["[[[1,2],[3,4,1],5]]", {"[" -> "{", "]" -> "}"}]];
+p = "Payload#" <> ToString[#] & /@ Range[6];
+Map[p[[#]] &, t, {-1}]

Task/Nested-templated-data/Nim/nested-templated-data.nim

@@ -0,0 +1,28 @@
+import macros,sugar,strformat
+#macro to take a nested tuple and return a type
+#e.g. (int,(int,int))=>(string,(string,string))
+proc intstr(n: NimNode): NimNode =
+  if n.kind == nnkSym:
+    return ident("string")
+  result = nnkPar.newNimNode()
+  for i in 1..<n.len:
+    result.add(intstr(n[i]))
+
+macro tuptype(t: typed): untyped = intstr(t.getType)
+
+
+proc replace(t: tuple | int, p: openArray[string]): auto =
+  when t is int: (if t in 0..<p.len: p[t] else: "nil")
+  else:
+    var res: tuptype(t)
+    for k, v in t.fieldpairs:
+      #k will be 'Field0', so we convert to an integer index
+      res[k[^1].int - '0'.int] = replace(v, p)
+    return res
+when isMainModule:
+  let p = collect(for i in 0..5: &"payload{i}")
+
+  let tplt1 = ((1,2),(3,4,1),5)
+  let tplt2 = ((1,2),(3,4,1),6)
+  echo replace(tplt1, p)
+  echo replace(tplt2, p)

Task/Nested-templated-data/Perl/nested-templated-data-1.pl

@@ -0,0 +1,16 @@
+sub fulfill {
+    my   @payloads;
+    push @payloads, 'Payload#' . $_ for 0..5;
+    my      @result;
+    push    @result, ref $_ eq 'ARRAY' ? [@payloads[@$_]] : @payloads[$_] for @{@_[0]};
+    return [@result];
+}
+
+sub formatted {
+    my $result;
+    $result .= ref $_ eq 'ARRAY' ? '[ "'. join('", "', @$_) . '" ], ' : qq{"$_"} for @{@_[0]};
+    return '[ ' . $result . " ]\n";
+}
+
+print formatted fulfill( [[1,2], [ 3,4,1], 5] );
+print formatted fulfill( [[1,2], [10,4,1], 5] );

Task/Nested-templated-data/Perl/nested-templated-data-2.pl

@@ -0,0 +1,22 @@
+#!/usr/bin/perl
+
+use strict; # https://rosettacode.org/wiki/Nested_templated_data
+use warnings;
+use Data::Dump 'dd';
+
+my $t = [
+    [[1, 2],
+     [3, 4, 1],
+     5]];
+
+my $p = [ map "Payload#$_", 0 .. 6 ];
+dd { 'template' => $t, 'payload' => $p };
+
+my $output = filltemplate( $t, $p );
+dd { 'output' => $output };
+
+sub filltemplate
+  {
+  my ($t, $p) = @_;
+  return ref $t eq 'ARRAY' ? [ map filltemplate($_, $p), @$t ] : $p->[$t];
+  }

Task/Nested-templated-data/Phix/nested-templated-data.phix

@@ -0,0 +1,36 @@
+(phixonline)-->
+ <span style="color: #008080;">constant</span> <span style="color: #000000;">template</span> <span style="color: #0000FF;">=</span> <span style="color: #0000FF;">{</span> <span style="color: #0000FF;">{</span> <span style="color: #0000FF;">{</span> <span style="color: #000000;">1</span><span style="color: #0000FF;">,</span> <span style="color: #000000;">2</span> <span style="color: #0000FF;">},</span> <span style="color: #0000FF;">{</span> <span style="color: #000000;">3</span><span style="color: #0000FF;">,</span> <span style="color: #000000;">4</span><span style="color: #0000FF;">,</span> <span style="color: #000000;">1</span><span style="color: #0000FF;">,</span> <span style="color: #0000FF;">},</span> <span style="color: #000000;">5</span> <span style="color: #0000FF;">}</span> <span style="color: #0000FF;">},</span>
+          <span style="color: #000000;">template2</span> <span style="color: #0000FF;">=</span>  <span style="color: #0000FF;">{</span> <span style="color: #0000FF;">{</span> <span style="color: #0000FF;">{</span> <span style="color: #000000;">1</span><span style="color: #0000FF;">,</span> <span style="color: #000000;">2</span> <span style="color: #0000FF;">},</span> <span style="color: #0000FF;">{</span> <span style="color: #000000;">10</span><span style="color: #0000FF;">,</span> <span style="color: #000000;">4</span><span style="color: #0000FF;">,</span> <span style="color: #000000;">1</span> <span style="color: #0000FF;">},</span> <span style="color: #000000;">5</span> <span style="color: #0000FF;">}</span> <span style="color: #0000FF;">},</span>
+          <span style="color: #000000;">payload</span> <span style="color: #0000FF;">=</span> <span style="color: #0000FF;">{</span><span style="color: #008000;">"Payload#0"</span><span style="color: #0000FF;">,</span> <span style="color: #008000;">"Payload#1"</span><span style="color: #0000FF;">,</span> <span style="color: #008000;">"Payload#2"</span><span style="color: #0000FF;">,</span> <span style="color: #008000;">"Payload#3"</span><span style="color: #0000FF;">,</span> <span style="color: #008000;">"Payload#4"</span><span style="color: #0000FF;">,</span> <span style="color: #008000;">"Payload#5"</span><span style="color: #0000FF;">,</span> <span style="color: #008000;">"Payload#6"</span><span style="color: #0000FF;">}</span>
+ <span style="color: #004080;">sequence</span> <span style="color: #000000;">unused</span> <span style="color: #0000FF;">=</span> <span style="color: #7060A8;">repeat</span><span style="color: #0000FF;">(</span><span style="color: #004600;">true</span><span style="color: #0000FF;">,</span><span style="color: #7060A8;">length</span><span style="color: #0000FF;">(</span><span style="color: #000000;">payload</span><span style="color: #0000FF;">)),</span>
+          <span style="color: #000000;">missing</span> <span style="color: #0000FF;">=</span> <span style="color: #0000FF;">{}</span>
+
+ <span style="color: #008080;">function</span> <span style="color: #000000;">fill</span><span style="color: #0000FF;">(</span><span style="color: #004080;">object</span> <span style="color: #000000;">t</span><span style="color: #0000FF;">,</span> <span style="color: #004080;">sequence</span> <span style="color: #000000;">p</span><span style="color: #0000FF;">)</span>
+     <span style="color: #008080;">if</span> <span style="color: #004080;">integer</span><span style="color: #0000FF;">(</span><span style="color: #000000;">t</span><span style="color: #0000FF;">)</span> <span style="color: #008080;">then</span>
+         <span style="color: #008080;">if</span> <span style="color: #000000;">t</span><span style="color: #0000FF;">>=</span><span style="color: #7060A8;">length</span><span style="color: #0000FF;">(</span><span style="color: #000000;">p</span><span style="color: #0000FF;">)</span> <span style="color: #008080;">then</span>
+             <span style="color: #008080;">if</span> <span style="color: #008080;">not</span> <span style="color: #7060A8;">find</span><span style="color: #0000FF;">(</span><span style="color: #000000;">t</span><span style="color: #0000FF;">,</span><span style="color: #000000;">missing</span><span style="color: #0000FF;">)</span> <span style="color: #008080;">then</span> <span style="color: #000000;">missing</span> <span style="color: #0000FF;">&=</span> <span style="color: #000000;">t</span> <span style="color: #008080;">end</span> <span style="color: #008080;">if</span>
+             <span style="color: #008080;">return</span> <span style="color: #7060A8;">sprintf</span><span style="color: #0000FF;">(</span><span style="color: #008000;">"*** index error (%d&gt;%d) ***"</span><span style="color: #0000FF;">,{</span><span style="color: #000000;">t</span><span style="color: #0000FF;">,</span><span style="color: #7060A8;">length</span><span style="color: #0000FF;">(</span><span style="color: #000000;">p</span><span style="color: #0000FF;">)-</span><span style="color: #000000;">1</span><span style="color: #0000FF;">})</span>
+         <span style="color: #008080;">end</span> <span style="color: #008080;">if</span>
+         <span style="color: #000000;">unused</span><span style="color: #0000FF;">[</span><span style="color: #000000;">t</span><span style="color: #0000FF;">+</span><span style="color: #000000;">1</span><span style="color: #0000FF;">]</span> <span style="color: #0000FF;">=</span> <span style="color: #004600;">false</span>
+         <span style="color: #008080;">return</span> <span style="color: #000000;">p</span><span style="color: #0000FF;">[</span><span style="color: #000000;">t</span><span style="color: #0000FF;">+</span><span style="color: #000000;">1</span><span style="color: #0000FF;">]</span>
+     <span style="color: #008080;">end</span> <span style="color: #008080;">if</span>
+     <span style="color: #008080;">for</span> <span style="color: #000000;">i</span><span style="color: #0000FF;">=</span><span style="color: #000000;">1</span> <span style="color: #008080;">to</span> <span style="color: #7060A8;">length</span><span style="color: #0000FF;">(</span><span style="color: #000000;">t</span><span style="color: #0000FF;">)</span> <span style="color: #008080;">do</span>
+         <span style="color: #000000;">t</span><span style="color: #0000FF;">[</span><span style="color: #000000;">i</span><span style="color: #0000FF;">]</span> <span style="color: #0000FF;">=</span> <span style="color: #000000;">fill</span><span style="color: #0000FF;">(</span><span style="color: #000000;">t</span><span style="color: #0000FF;">[</span><span style="color: #000000;">i</span><span style="color: #0000FF;">],</span><span style="color: #000000;">p</span><span style="color: #0000FF;">)</span>
+     <span style="color: #008080;">end</span> <span style="color: #008080;">for</span>
+     <span style="color: #008080;">return</span> <span style="color: #000000;">t</span>
+ <span style="color: #008080;">end</span> <span style="color: #008080;">function</span>
+
+ <span style="color: #7060A8;">ppOpt</span><span style="color: #0000FF;">({</span><span style="color: #004600;">pp_Nest</span><span style="color: #0000FF;">,</span><span style="color: #000000;">2</span><span style="color: #0000FF;">})</span>
+ <span style="color: #7060A8;">pp</span><span style="color: #0000FF;">(</span><span style="color: #000000;">fill</span><span style="color: #0000FF;">(</span><span style="color: #000000;">template</span><span style="color: #0000FF;">,</span><span style="color: #000000;">payload</span><span style="color: #0000FF;">))</span>
+ <span style="color: #7060A8;">pp</span><span style="color: #0000FF;">(</span><span style="color: #000000;">fill</span><span style="color: #0000FF;">(</span><span style="color: #000000;">template2</span><span style="color: #0000FF;">,</span><span style="color: #000000;">payload</span><span style="color: #0000FF;">))</span>
+
+ <span style="color: #004080;">sequence</span> <span style="color: #000000;">idx</span> <span style="color: #0000FF;">=</span> <span style="color: #0000FF;">{}</span>
+ <span style="color: #008080;">for</span> <span style="color: #000000;">i</span><span style="color: #0000FF;">=</span><span style="color: #000000;">1</span> <span style="color: #008080;">to</span> <span style="color: #7060A8;">length</span><span style="color: #0000FF;">(</span><span style="color: #000000;">unused</span><span style="color: #0000FF;">)</span> <span style="color: #008080;">do</span>
+     <span style="color: #008080;">if</span> <span style="color: #000000;">unused</span><span style="color: #0000FF;">[</span><span style="color: #000000;">i</span><span style="color: #0000FF;">]</span> <span style="color: #008080;">then</span> <span style="color: #000000;">idx</span> <span style="color: #0000FF;">&=</span> <span style="color: #000000;">i</span><span style="color: #0000FF;">-</span><span style="color: #000000;">1</span> <span style="color: #008080;">end</span> <span style="color: #008080;">if</span>
+ <span style="color: #008080;">end</span> <span style="color: #008080;">for</span>
+ <span style="color: #7060A8;">printf</span><span style="color: #0000FF;">(</span><span style="color: #000000;">1</span><span style="color: #0000FF;">,</span><span style="color: #008000;">"\nThe unused payloads have indices of :%s\n"</span><span style="color: #0000FF;">,</span> <span style="color: #0000FF;">{</span><span style="color: #7060A8;">sprint</span><span style="color: #0000FF;">(</span><span style="color: #000000;">idx</span><span style="color: #0000FF;">)})</span>
+
+ <span style="color: #008080;">if</span> <span style="color: #7060A8;">length</span><span style="color: #0000FF;">(</span><span style="color: #000000;">missing</span><span style="color: #0000FF;">)</span> <span style="color: #008080;">then</span>
+     <span style="color: #7060A8;">printf</span><span style="color: #0000FF;">(</span><span style="color: #000000;">1</span><span style="color: #0000FF;">,</span><span style="color: #008000;">"Missing payloads: %s\n"</span><span style="color: #0000FF;">,</span> <span style="color: #0000FF;">{</span><span style="color: #7060A8;">sprint</span><span style="color: #0000FF;">(</span><span style="color: #000000;">missing</span><span style="color: #0000FF;">)})</span>
+ <span style="color: #008080;">end</span> <span style="color: #008080;">if</span>
+<!--

Task/Nested-templated-data/Python/nested-templated-data.py

@@ -0,0 +1,49 @@
+from pprint import pprint as pp
+
+class Template():
+    def __init__(self, structure):
+        self.structure = structure
+        self.used_payloads, self.missed_payloads = [], []
+
+    def inject_payload(self, id2data):
+
+        def _inject_payload(substruct, i2d, used, missed):
+            used.extend(i2d[x] for x in substruct if type(x) is not tuple and x in i2d)
+            missed.extend(f'??#{x}'
+                          for x in substruct if type(x) is not tuple and x not in i2d)
+            return tuple(_inject_payload(x, i2d, used, missed)
+                           if type(x) is tuple
+                           else i2d.get(x, f'??#{x}')
+                         for x in substruct)
+
+        ans = _inject_payload(self.structure, id2data,
+                              self.used_payloads, self.missed_payloads)
+        self.unused_payloads = sorted(set(id2data.values())
+                                      - set(self.used_payloads))
+        self.missed_payloads = sorted(set(self.missed_payloads))
+        return ans
+
+if __name__ == '__main__':
+    index2data = {p: f'Payload#{p}' for p in range(7)}
+    print("##PAYLOADS:\n  ", end='')
+    print('\n  '.join(list(index2data.values())))
+    for structure in [
+     (((1, 2),
+       (3, 4, 1),
+       5),),
+
+     (((1, 2),
+       (10, 4, 1),
+       5),)]:
+        print("\n\n# TEMPLATE:")
+        pp(structure, width=13)
+        print("\n TEMPLATE WITH PAYLOADS:")
+        t = Template(structure)
+        out = t.inject_payload(index2data)
+        pp(out)
+        print("\n UNUSED PAYLOADS:\n  ", end='')
+        unused = t.unused_payloads
+        print('\n  '.join(unused) if unused else '-')
+        print(" MISSING PAYLOADS:\n  ", end='')
+        missed = t.missed_payloads
+        print('\n  '.join(missed) if missed else '-')

Task/Nested-templated-data/R/nested-templated-data.r

@@ -0,0 +1,24 @@
+fill_template <- function(x, template, prefix = "Payload#") {
+  for (i in seq_along(template)) {
+    temp_slice <- template[[i]]
+    if (is.list(temp_slice)) {
+      template[[i]] <- fill_template(x, temp_slice, prefix)
+    } else {
+      temp_slice <- paste0(prefix, temp_slice)
+      template[[i]] <- x[match(temp_slice, x)]
+    }
+  }
+  return(template)
+}
+
+library("jsonlite") # for printing the template and result
+template <- list(list(c(1, 2), c(3, 4), 5))
+payload  <- paste0("Payload#", 0:6)
+result   <- fill_template(payload, template)
+
+cat(sprintf(
+  "Template\t%s\nPayload\t%s\nResult\t%s",
+  toJSON(template, auto_unbox = TRUE),
+  toJSON(payload, auto_unbox = TRUE),
+  toJSON(result, auto_unbox = TRUE)
+))

Task/Nested-templated-data/REXX/nested-templated-data-1.rexx

@@ -0,0 +1,106 @@
+/* REXX */
+tok.=''
+Do i=0 To 6
+  tok.i="'Payload#"i"'"
+  End
+t1='[[[1,2],[3,4,1],5]]'
+t2='[[[1,6],[3,4,7,0],5]]'
+Call transform t1
+Call transform t2
+Exit
+
+transform:
+Parse Arg t 1 tt
+/* http://rosettacode.org/wiki/Nested_templated_data */
+/*
+[[['Payload#1', 'Payload#2'],
+  ['Payload#3', 'Payload#4', 'Payload#1'],
+  'Payload#5']]
+*/
+lvl=0
+n.=0
+o=''
+w=''
+used.=0
+Do While t<>''
+  Parse Var t c +1 1 c3 +3 1 c2 +2
+  u=' '
+  v=' '
+  Select
+    When c3='],[' Then Do
+      o=o'  '
+      w=w'  '
+      t=substr(t,3)
+      End
+    When c2='],' Then Do
+      o=o' '
+      w=w' '
+      t=substr(t,2)
+      lvl=lvl-1
+      End
+    When c='[' Then
+      lvl=lvl+1
+    When c=']' Then
+      lvl=lvl-1
+    When c=',' Then
+      Nop
+    Otherwise Do
+      u=lvl
+      v=c
+      End
+    End
+  t=substr(t,2)
+  o=o||u
+  w=w||v
+  End
+Say 'Template' tt
+Do i=1 By 1 While w<>''
+  If i=1 Then Do
+    w=substr(w,4)
+    p=pos('  ',w)
+    Call o '[[['cont(left(w,p-1))'],'
+    w=substr(w,p)
+    End
+  Else Do
+    If left(w,3)='' Then Do
+      w=substr(w,4)
+      p=pos('  ',w)
+      Call o '  ['cont(left(w,p-1))'],'
+      w=substr(w,p)
+      End
+    Else Do
+      w=substr(w,3)
+      p=pos('  ',w)
+      Call o '  'cont(left(w,p-1))']]'
+      w=substr(w,p)
+      End
+    End
+  End
+Do i=0 To 6
+  If used.i=0 Then Say 'Payload' i 'not used'
+  End
+Call o ' '
+Return
+
+o: Say arg(1)
+   Return
+
+cont: Procedure Expose tok. used.
+  Parse Arg list
+  res=''
+  Do while list>''
+    Parse Var list i list
+    res= res tok(i)','
+    End
+  res=strip(res)
+  res=strip(res,'T',',')
+  Return res
+
+tok: Procedure Expose tok. used.
+Parse Arg i
+If tok.i<>'' Then Do
+  used.i=1
+  Return tok.i
+  End
+Else
+  Return "'Payload#" i "not defined'"

Task/Nested-templated-data/REXX/nested-templated-data-2.rexx

@@ -0,0 +1,100 @@
+/* REXX */
+tok.=''
+Do i=0 To 6
+  tok.i="'Payload#"i"'"
+  End
+t1='[[[1,2],[ 3,4,1],5]]'
+t2='1[[[1,6]],[[3,4[7] 0],5]3]9 [8] 9'
+Call transform t1
+Call transform t2
+Exit
+
+transform:
+Parse Arg t 1 tt
+t=space(t,0)
+lvl=0
+t.=0
+used.=0
+undefined=''
+Do While t<>''
+  Parse Var t c +1 t
+  Select
+    When c='[' Then
+      lvl=lvl+1
+    When c=']' Then
+      lvl=lvl-1
+    When c=',' Then
+      Nop
+    Otherwise Do
+      t=c||t
+      p1=pos(']',t)
+      p2=pos('[',t)
+      Select
+        When p2=0 Then p=p1
+        When p1=0 Then p=p2
+        Otherwise p=min(p1,p2)
+        End
+      If p=0 Then Do
+        Call mem lvl': >'t'<'
+        t=''
+        End
+      Else Do
+        Call mem lvl': >'left(t,p-1)'<'
+        t=substr(t,p)
+        End
+      End
+    End
+  End
+Call show
+Return
+
+mem:
+z=t.0+1
+t.z=arg(1)
+t.0=z
+Return
+
+show:
+Say tt
+Say 'lvl Element'
+Do i=1 To t.0
+  Parse Var t.i lvl ':' '>' cont '<'
+  ol=right(lvl,3) copies(' ',lvl*3)cont(cont)
+  Say ol
+  End
+Do i=0 To 6
+  If used.i=0 Then Say 'Payload' i 'not used'
+  End
+Do While undefined>''
+  Parse Var undefined i undefined
+  Say 'Payload' i 'is not defined'
+  End
+Call o ' '
+Return
+
+cont: Procedure Expose tok. used. undefined
+  Parse Arg list
+  list=translate(list,' ',',')
+  res=''
+  Do while list>''
+    Parse Var list i list
+    res= res tok(i)','
+    End
+  res=strip(res)
+  res=strip(res,'T',',')
+  Return res
+
+tok: Procedure Expose tok. used. undefined
+Parse Arg i
+If tok.i<>'' Then Do
+  used.i=1
+  Return tok.i
+  End
+Else Do
+  If wordpos(i,undefined)=0 Then
+    undefined=undefined i
+  Return "'Payload#"i "not defined'"
+  End
+
+o: Say arg(1)
+   Return

Task/Nested-templated-data/Racket/nested-templated-data.rkt

@@ -0,0 +1,33 @@
+#lang racket
+
+(define current-not-found-handler
+  (make-parameter (λ (idx max) (raise-range-error 'substitute-template "integer?" "" idx 0 max))))
+
+(define ((substitute-template template) payloads)
+  (define match-function
+    (match-lambda
+      [(? nonnegative-integer? idx) #:when (< idx (length payloads)) (list-ref payloads idx)]
+      [(? nonnegative-integer? idx) ((current-not-found-handler) idx (sub1 (length payloads)))]
+      [(list (app match-function substitutions) ...) substitutions]))
+  (match-function template))
+
+(module+ test
+  (require rackunit)
+
+  (define substitute-in-t (substitute-template '(((1 2)
+                                                  (3 4 1)
+                                                  5))))
+
+  (define p '(Payload#0 Payload#1 Payload#2 Payload#3 Payload#4 Payload#5 Payload#6))
+
+  (check-equal? (substitute-in-t p)
+                '(((Payload#1 Payload#2)
+                   (Payload#3 Payload#4 Payload#1)
+                   Payload#5)))
+
+  (define out-of-bounds-generating-template-substitution (substitute-template '(7)))
+
+  (check-exn exn:fail:contract? (λ () (out-of-bounds-generating-template-substitution p)))
+
+  (parameterize ((current-not-found-handler (λ (idx max) (format "?~a" idx))))
+    (check-equal? (out-of-bounds-generating-template-substitution p) '("?7"))))

Task/Nested-templated-data/Raku/nested-templated-data.raku

@@ -0,0 +1,14 @@
+say join "\n  ", '##PAYLOADS:', |my @payloads = 'Payload#' X~ ^7;
+
+for [
+     (((1, 2),
+       (3, 4, 1),
+       5),),
+
+     (((1, 2),
+       (10, 4, 1),
+       5),)
+    ] {
+    say "\n      Template: ", $_.raku;
+    say "Data structure: { @payloads[|$_].raku }";
+}

Task/Nested-templated-data/VBA/nested-templated-data.vba

@@ -0,0 +1,29 @@
+Public Sub test()
+    Dim t(2) As Variant
+    t(0) = [{1,2}]
+    t(1) = [{3,4,1}]
+    t(2) = 5
+    p = [{"Payload#0","Payload#1","Payload#2","Payload#3","Payload#4","Payload#5","Payload#6"}]
+    Dim q(6) As Boolean
+    For i = LBound(t) To UBound(t)
+        If IsArray(t(i)) Then
+            For j = LBound(t(i)) To UBound(t(i))
+                q(t(i)(j)) = True
+                t(i)(j) = p(t(i)(j) + 1)
+            Next j
+        Else
+            q(t(i)) = True
+            t(i) = p(t(i) + 1)
+        End If
+    Next i
+    For i = LBound(t) To UBound(t)
+        If IsArray(t(i)) Then
+            Debug.Print Join(t(i), ", ")
+        Else
+            Debug.Print t(i)
+        End If
+    Next i
+    For i = LBound(q) To UBound(q)
+        If Not q(i) Then Debug.Print p(i + 1); " is not used"
+    Next i
+End Sub

Task/Nested-templated-data/Wren/nested-templated-data.wren

@@ -0,0 +1,23 @@
+import "/set" for Set
+import "/sort" for Sort
+
+var withPayload // recursive function
+withPayload = Fn.new { |template, payload, used|
+    return template.map { |item|
+        if (item is List) {
+            return withPayload.call(item, payload, used)
+        } else {
+            used.add(item)
+            return "'%(payload[item])'"
+        }
+    }.toList
+}
+
+var p = ["Payload#0", "Payload#1", "Payload#2", "Payload#3", "Payload#4", "Payload#5", "Payload#6"]
+var t = [[[1, 2], [3, 4, 1], 5]]
+var used = []
+System.print(withPayload.call(t, p, used))
+System.print()
+var unused  = Set.new(0..6).except(Set.new(used)).toList
+Sort.insertion(unused)
+System.print("The unused payloads have indices of %(unused).")

Task/Nested-templated-data/Zkl/nested-templated-data-1.zkl

@@ -0,0 +1,4 @@
+var payloads=[1..6].pump(List,"Payload#".append);
+
+fcn get(n){ try{ payloads[n - 1] }catch{ Void } }
+fcn sub(list){ list.pump(List, fcn(n){ if(n.isType(List)) sub(n) else get(n) }) }

Task/Nested-templated-data/Zkl/nested-templated-data-2.zkl

@@ -0,0 +1,9 @@
+foreach p in (T(
+     T(T(T(1, 2),
+         T(3, 4, 1),
+         5),),
+   T(T(T(1, 2),
+       T(10,4, 1),
+         5),))){
+   println("      Template: %s\nData structure: %s".fmt(p,sub(p)));
+}