{
  "vercy": "1.0-draft",
  "publication": {
    "status": "research-draft",
    "adjudicationStatus": "unreviewed",
    "publishableCanonical": false,
    "generatedAt": "2026-09-14T03:40:18Z",
    "providers": [
      "Claude"
    ],
    "breadth": "written by Claude from model knowledge without web access - no source was read, every claim is a lead to verify",
    "pass": 2,
    "wave": 4,
    "engine": "claude",
    "enrichment": {
      "pass": 3,
      "engine": "claude",
      "producedAt": "2026-10-06T12:00:00Z",
      "ingestedAt": "2026-10-06T07:48:48+00:00",
      "fields": [
        "agent_conduct",
        "ethics",
        "owners"
      ]
    },
    "gate": {
      "passed": true,
      "version": "1.0",
      "at": "2026-10-06T19:51:54+00:00",
      "evidence": [
        "completeness 1.00",
        "sense: Wikidata description",
        "2 live sources",
        "review by codex: pass"
      ]
    }
  },
  "metaModel": {
    "id": "THING-Q1474542",
    "registryId": "vr.tr.higher-order-function",
    "name": "higher-order function",
    "version": "0.2.0-wave.4",
    "entryKind": "thing",
    "family": "Thing Registry",
    "domain": [
      "XCT.QLT"
    ],
    "status": "research-draft"
  },
  "canonicalUrl": "https://ver.cy/models/thing/q1474542/",
  "model": {
    "registry_id": "vr.tr.higher-order-function",
    "name": "higher-order function",
    "purpose": "Let an agent explain the higher-order function, relay its idea, examples and uses from computer-science sources, describe the examples its aliases name, and distinguish it from a first-order function and from a plain value.",
    "definition": "In programming and mathematics, a higher-order function is a function that takes one or more functions as arguments, returns a function as its result, or both; the registry aliases name examples such as map, parser combinators and fixed-point combinators. Higher-order functions are a core idea of functional programming, letting behaviour be passed around and composed, and they contrast with ordinary functions that only take and return plain values.",
    "what_it_is_for": "Taking or returning functions to compose behaviour.",
    "affordances": [
      "explain the idea",
      "relay examples and uses",
      "describe named examples",
      "distinguish it from first-order functions"
    ],
    "distinguishing_features": [
      "Operates on functions",
      "Core to functional programming",
      "Enables composition",
      "Contrasts with first-order"
    ],
    "appearance": "Not a visible object; a function in code or mathematics that operates on other functions.",
    "visual_identification": [
      "A function that takes or returns functions",
      "map, parser combinator, fixed-point combinator",
      "A first-order function takes and returns only plain values"
    ],
    "physical_properties": [
      {
        "quantity": "takes or returns",
        "typical_range": "functions",
        "unit": "note",
        "note": ""
      },
      {
        "quantity": "field",
        "typical_range": "functional programming and mathematics",
        "unit": "note",
        "note": ""
      },
      {
        "quantity": "registry parent",
        "typical_range": "function",
        "unit": "note",
        "note": ""
      }
    ],
    "families_and_kinds": [
      "map and filter",
      "combinators",
      "function-returning functions"
    ],
    "related_models": [
      {
        "relation": "is a kind of",
        "target": "function",
        "why": "in registry terms"
      },
      {
        "relation": "is contrasted with",
        "target": "first-order function",
        "why": ""
      },
      {
        "relation": "is used in",
        "target": "functional programming",
        "why": ""
      },
      {
        "relation": "is related to",
        "target": "function composition",
        "why": ""
      }
    ],
    "identifiers": [],
    "standards_and_regulation": [
      "Programming language semantics"
    ],
    "failure_modes_and_hazards": [
      "Confusing with first-order functions",
      "Confusing the function with its result",
      "Overstating performance cost"
    ],
    "in_scope": [],
    "out_of_scope": [],
    "characteristics": [],
    "agent_conduct": {
      "may": [
        "Write and explain higher-order functions such as map, filter and fold.",
        "Refactor code with them where it improves clarity."
      ],
      "must_not": [
        "Pass untrusted functions or callbacks into privileged code.",
        "Confuse higher-order with first-order functions.",
        "Introduce code that silently swallows errors through callbacks.",
        "Present clever abstractions that obscure safety-critical logic."
      ],
      "requires_human": [
        "Changing shared production code."
      ]
    },
    "ethics": {
      "considerations": [
        "Obscure code makes faults harder to find.",
        "Clear teaching helps learners."
      ],
      "affected_parties": [
        "Developers",
        "Users of the software",
        "Learners"
      ]
    },
    "owners": {
      "steward": "Nobody: a concept held in common.",
      "master_systems": []
    }
  },
  "sources": [
    {
      "id": "wikidata",
      "title": "Wikidata item Q1474542: higher-order function",
      "url": "https://www.wikidata.org/wiki/Q1474542",
      "url_status": "live",
      "what_it_supports": "identity and sense of the item",
      "checked_by": "wikidata-api"
    },
    {
      "id": "wikipedia-en",
      "title": "Wikipedia: Higher-order function",
      "url": "https://en.wikipedia.org/wiki/Higher-order_function",
      "url_status": "live",
      "what_it_supports": "general description of the item",
      "checked_by": "wikidata-api sitelink"
    }
  ],
  "structure": {
    "bundles": [
      {
        "id": "understand",
        "name": "Understand",
        "description": "What it is.",
        "rationale": "Definition.",
        "layers": [
          {
            "id": "definition",
            "name": "Definition",
            "description": "Definition.",
            "findings": [
              {
                "id": "definition-finding",
                "name": "Definition",
                "description": "Definition.",
                "questions": [
                  {
                    "text": "What is a higher-order function, and how does it differ from a first-order function?",
                    "kind": "definition"
                  },
                  {
                    "text": "Is the question about programming or mathematics?",
                    "kind": "boundary"
                  }
                ]
              }
            ]
          },
          {
            "id": "examples",
            "name": "Examples",
            "description": "Examples.",
            "findings": [
              {
                "id": "examples-finding",
                "name": "Examples",
                "description": "Examples.",
                "questions": [
                  {
                    "text": "What are map, parser combinators and fixed-point combinators?",
                    "kind": "definition"
                  },
                  {
                    "text": "Which entry fits the specific example?",
                    "kind": "action"
                  }
                ]
              }
            ]
          }
        ]
      },
      {
        "id": "idea",
        "name": "Idea",
        "description": "Idea.",
        "rationale": "Sources.",
        "layers": [
          {
            "id": "arguments",
            "name": "Arguments",
            "description": "Functions as arguments.",
            "findings": [
              {
                "id": "arguments-finding",
                "name": "Arguments",
                "description": "Arguments.",
                "questions": [
                  {
                    "text": "How does a higher-order function take functions as arguments?",
                    "kind": "provenance"
                  },
                  {
                    "text": "Which references are standard?",
                    "kind": "provenance"
                  }
                ]
              }
            ]
          },
          {
            "id": "returns",
            "name": "Returns",
            "description": "Returning functions.",
            "findings": [
              {
                "id": "returns-finding",
                "name": "Returns",
                "description": "Returns.",
                "questions": [
                  {
                    "text": "How does a higher-order function return a function?",
                    "kind": "provenance"
                  },
                  {
                    "text": "Which sources are cited?",
                    "kind": "provenance"
                  }
                ]
              }
            ]
          }
        ]
      },
      {
        "id": "uses",
        "name": "Uses",
        "description": "Uses.",
        "rationale": "Sources.",
        "layers": [
          {
            "id": "composition",
            "name": "Composition",
            "description": "Composition.",
            "findings": [
              {
                "id": "composition-finding",
                "name": "Composition",
                "description": "Composition.",
                "questions": [
                  {
                    "text": "How do higher-order functions enable composition and reuse?",
                    "kind": "provenance"
                  },
                  {
                    "text": "Which sources are cited?",
                    "kind": "provenance"
                  }
                ]
              }
            ]
          },
          {
            "id": "patterns",
            "name": "Patterns",
            "description": "Patterns.",
            "findings": [
              {
                "id": "patterns-finding",
                "name": "Patterns",
                "description": "Patterns.",
                "questions": [
                  {
                    "text": "What common patterns use higher-order functions?",
                    "kind": "provenance"
                  },
                  {
                    "text": "Which entry fits the pattern?",
                    "kind": "action"
                  }
                ]
              }
            ]
          }
        ]
      },
      {
        "id": "context",
        "name": "Context",
        "description": "Context.",
        "rationale": "Context.",
        "layers": [
          {
            "id": "functional",
            "name": "Functional",
            "description": "Functional programming.",
            "findings": [
              {
                "id": "functional-finding",
                "name": "Functional",
                "description": "Functional.",
                "questions": [
                  {
                    "text": "Why are higher-order functions central to functional programming?",
                    "kind": "provenance"
                  },
                  {
                    "text": "Which sources are cited?",
                    "kind": "provenance"
                  }
                ]
              }
            ]
          },
          {
            "id": "math",
            "name": "Math",
            "description": "Mathematics.",
            "findings": [
              {
                "id": "math-finding",
                "name": "Math",
                "description": "Math.",
                "questions": [
                  {
                    "text": "How does the mathematical notion of a functional relate?",
                    "kind": "provenance"
                  },
                  {
                    "text": "Is the sense correctly identified?",
                    "kind": "boundary"
                  }
                ]
              }
            ]
          }
        ]
      }
    ]
  },
  "openQuestions": [
    "Should specific combinators be separate entries?",
    "How should the idea be shown simply?",
    "How should the math sense relate to the code sense?"
  ],
  "statistics": {
    "bundles": 4,
    "layers": 8,
    "findings": 8,
    "questions": 16
  }
}