cuelang.org/go@v0.10.1/cue/testdata/eval/comprehensions.txtar

-- in.cue --
import "strings"

a: {x: 10, y: 100, z: 50}
b: {
	for k, v in a if v <= 50 {
		"\(k)": v
	}
	x: int
	if x > 3 {
		k: 20
	}
	k: int
	if k > 0 {
		l: 40
	}
}

c: {
	for k, v in a let y = v + 10 if y > 50 {
		"\(k)": y
	}
}

A: X: run: "dfoo"

if true {
	A: X: {
		run:   string
		files: "\(strings.Join([ run], "\n"))"
	}
}

matchOrder: {
  a1: {
    out: [string]: Val: 1
    out: in.a

    in: a: {
      if true {
        b: {}
      }
    }
  }
  a2: {
    out: [string]: Val: 1

    in: a: {
      if true {
        b: {}
      }
    }

    out: in.a
  }
  a3: {

    in: a: {
      if true {
        b: {}
      }
    }

    out: [string]: Val: 1
    out: in.a
  }
  a4: {
    out: in.a
    out: [string]: Val: 1

    in: a: {
      if true {
        b: {}
      }
    }
  }
  a5: {
    out: in.a

    in: a: {
      if true {
        b: {}
      }
    }

    out: [string]: Val: 1
  }
  a6: {
    in: a: {
      if true {
        b: {}
      }
    }

    out: in.a
    out: [string]: Val: 1
  }
}

-- out/eval/stats --
Leaks:  4
Freed:  64
Reused: 57
Allocs: 11
Retain: 19

Unifications: 68
Conjuncts:    96
Disjuncts:    81
-- out/eval --
(struct){
  a: (struct){
    x: (int){ 10 }
    y: (int){ 100 }
    z: (int){ 50 }
  }
  b: (struct){
    x: (int){ 10 }
    k: (int){ 20 }
    l: (int){ 40 }
    z: (int){ 50 }
  }
  c: (struct){
    y: (int){ 110 }
    z: (int){ 60 }
  }
  A: (struct){
    X: (struct){
      run: (string){ "dfoo" }
      files: (string){ "dfoo" }
    }
  }
  matchOrder: (struct){
    a1: (struct){
      out: (struct){
        b: (struct){
          Val: (int){ 1 }
        }
      }
      in: (struct){
        a: (struct){
          b: (struct){
          }
        }
      }
    }
    a2: (struct){
      out: (struct){
        b: (struct){
          Val: (int){ 1 }
        }
      }
      in: (struct){
        a: (struct){
          b: (struct){
          }
        }
      }
    }
    a3: (struct){
      in: (struct){
        a: (struct){
          b: (struct){
          }
        }
      }
      out: (struct){
        b: (struct){
          Val: (int){ 1 }
        }
      }
    }
    a4: (struct){
      out: (struct){
        b: (struct){
          Val: (int){ 1 }
        }
      }
      in: (struct){
        a: (struct){
          b: (struct){
          }
        }
      }
    }
    a5: (struct){
      out: (struct){
        b: (struct){
          Val: (int){ 1 }
        }
      }
      in: (struct){
        a: (struct){
          b: (struct){
          }
        }
      }
    }
    a6: (struct){
      in: (struct){
        a: (struct){
          b: (struct){
          }
        }
      }
      out: (struct){
        b: (struct){
          Val: (int){ 1 }
        }
      }
    }
  }
}
-- out/compile --
--- in.cue
{
  a: {
    x: 10
    y: 100
    z: 50
  }
  b: {
    for k, v in 〈1;a〉 if (〈0;v〉 <= 50) {
      "\(〈1;k〉)": 〈1;v〉
    }
    x: int
    if (〈0;x〉 > 3) {
      k: 20
    }
    k: int
    if (〈0;k〉 > 0) {
      l: 40
    }
  }
  c: {
    for k, v in 〈1;a〉 let y = (〈0;v〉 + 10) if (〈0;y〉 > 50) {
      "\(〈2;k〉)": 〈1;y〉
    }
  }
  A: {
    X: {
      run: "dfoo"
    }
  }
  if true {
    A: {
      X: {
        run: string
        files: "\(〈import;strings〉.Join([
          〈1;run〉,
        ], "\n"))"
      }
    }
  }
  matchOrder: {
    a1: {
      out: {
        [string]: {
          Val: 1
        }
      }
      out: 〈0;in〉.a
      in: {
        a: {
          if true {
            b: {}
          }
        }
      }
    }
    a2: {
      out: {
        [string]: {
          Val: 1
        }
      }
      in: {
        a: {
          if true {
            b: {}
          }
        }
      }
      out: 〈0;in〉.a
    }
    a3: {
      in: {
        a: {
          if true {
            b: {}
          }
        }
      }
      out: {
        [string]: {
          Val: 1
        }
      }
      out: 〈0;in〉.a
    }
    a4: {
      out: 〈0;in〉.a
      out: {
        [string]: {
          Val: 1
        }
      }
      in: {
        a: {
          if true {
            b: {}
          }
        }
      }
    }
    a5: {
      out: 〈0;in〉.a
      in: {
        a: {
          if true {
            b: {}
          }
        }
      }
      out: {
        [string]: {
          Val: 1
        }
      }
    }
    a6: {
      in: {
        a: {
          if true {
            b: {}
          }
        }
      }
      out: 〈0;in〉.a
      out: {
        [string]: {
          Val: 1
        }
      }
    }
  }
}