full_language.007

-- SPDX-License-Identifier: MPL-2.0
-- Copyright (c) 2026 Jonathan D.A. Jewell (hyperpolymath)
--
-- Example: Full 007 language showcase — exercises EVERY grammar feature.
-- Scenario: A distributed peer-review system for research papers.

@ref("verisimdb://peer-review/design-doc")

{- ============================================================
   IMPORTS — all three forms
   ============================================================ -}

import std.collections
import agents.review_pool as pool
from std.math import add, abs

{- ============================================================
   TYPE DECLARATIONS — alias, record, enum, generics
   ============================================================ -}

type PaperId = String
type Score = Int

type Paper = { id: PaperId, title: String, abstract_text: String }

type Verdict = Accept(score: Int) | MinorRevision(score: Int) | Reject(reason: String)

type ReviewPhase = Submission | UnderReview | Decision | Published

{- ============================================================
   LOCALES — all five constructors
   ============================================================ -}

locale here = Local
locale inference_gpu = GPU(device: 0)
locale plagiarism_cloud = Remote(url: "https://plagiarism.check.example.com")
locale eu_edge = Edge(region: "eu-central-1")
locale review_cluster = Cluster(nodes: ["rev1.local", "rev2.local", "rev3.local"])

{- ============================================================
   DATA BINDINGS — Harvard data layer (@total, pure arithmetic)
   ============================================================ -}

-- Top-level data binding: global config
@total data review_config = {
    min_reviewers: 2 + 1,
    max_rounds: 3,
    accept_threshold: 7,
    plagiarism_url: "https://plagiarism.check.example.com",
    weights: [1, 2, 3]
}

-- Data expressions: records, lists, field access, fn calls, additive
@total data scoring_table = {
    novelty_weight: add(2, 3),
    clarity_weight: 1 + 1,
    tags: ["ml", "nlp", "transformers"],
    nested: { inner_val: 42 + 8, flag: true }
}

{- ============================================================
   SESSION PROTOCOL — messages, branches, loops, rec
   ============================================================ -}

session protocol PeerReview {
    Author -> Editor : Submit(paper_id: String)
    Editor -> Reviewer : AssignReview(paper_id: String, deadline: Int)

    loop review_rounds {
        Reviewer -> Editor : SubmitReview(score: Int, comments: String)

        branch by Editor {
            | accept given { score: 8 } -> {
                Editor -> Author : Accept
            }
            | revise -> {
                Editor -> Author : RequestRevision(comments: String)
                Author -> Editor : Resubmit(paper_id: String)
                rec PeerReview
            }
            | reject -> {
                Editor -> Author : Reject
            }
        }
    }
}

{- ============================================================
   AGENTS — params, caps, implements, on locale, state,
            data blocks, control blocks, all handler events,
            branch/given/traced, trace clauses, linear let,
            spawn, send, send_final, match, if, loop, return,
            migrate, exchange, receive(), reversible/irreversible/reverse
   ============================================================ -}

agent Editor(caps: Cap[net, spawn, fs]) implements PeerReview.Editor on locale here {
    @total data config = {
        max_papers: 50,
        auto_assign: true
    }

    state paper_count: Int = 0

    control {
        -- Handler: receive — main dispatch
        on receive(submission: String) {
            -- Let binding
            let paper_id = parse_id(submission)

            -- Branch with traced and given
            branch traced "submission_triage" {
                | fast_track given {
                    priority: 10,
                    priority >= 8
                } -> {
                    -- Spawn a reviewer agent with capabilities
                    linear let reviewer = spawn Reviewer(
                        caps: [net],
                        behaviour: #a1b2c3d4e5f6
                    )
                    send paper_id to reviewer
                    trace {
                        action: "fast_tracked",
                        paper: paper_id,
                        confidence: 0.95
                    }
                }
                | standard given {
                    priority: 5,
                    priority > 2,
                    priority < 8
                } -> {
                    -- Migrate plagiarism check to cloud
                    let check_result = migrate(
                        submission,
                        from: here,
                        to: plagiarism_cloud
                    )

                    -- If/else control flow
                    if check_result == "clean" {
                        let reviewer = spawn Reviewer(caps: [net])
                        send(reviewer, paper_id)
                    } else {
                        send(self, "flagged:" ++ paper_id)
                    }

                    trace {
                        action: "standard_review",
                        plagiarism_check: "complete"
                    }
                }
                | desk_reject given {
                    priority: 1
                } -> {
                    -- Irreversible: rejection log cannot be undone
                    irreversible {
                        let rejection = log_rejection(paper_id)
                        send(rejection, audit_log)
                    }
                    trace {
                        action: "desk_rejected",
                        reason: "below threshold"
                    }
                }
            }
        }

        -- Handler: error — rollback with reverse
        on error(e: String) {
            reverse {
                let restored = restore_paper(e)
                send(restored, self)
            }
        }

        -- Handler: timeout — escalate stale reviews
        on timeout(deadline: String) {
            let escalation = build_escalation(deadline)
            send(escalation, supervisor_handle)
        }

        -- Handler: terminate — graceful shutdown
        on terminate(reason: String) {
            send_final(reason, audit_log)
        }

        -- Handler: child_crash — reviewer failure
        on child_crash(child_id: String) {
            let replacement = spawn Reviewer(caps: [net])
            send(replacement, child_id)
        }
    }
}

agent Reviewer(caps: Cap[net]) implements PeerReview.Reviewer on locale review_cluster {
    @total data weights = {
        novelty: 3,
        clarity: 2,
        rigor: 5,
        total: 3 + 2 + 5
    }

    state current_paper: String = "none"

    control {
        on receive(paper_id: String) {
            -- Migrate heavy analysis to GPU
            let analysis = migrate(paper_id, from: Local, to: inference_gpu)

            -- Receive expression (bare channel receive)
            let incoming = receive()

            -- Loop for iterative scoring
            loop scoring {
                let partial = compute_partial(analysis)

                -- Match on verdict
                match classify_verdict(partial) {
                    | Accept(s) -> {
                        send(editor_handle, s)
                        return
                    }
                    | MinorRevision(s) -> {
                        -- Exchange: swap old score for new
                        let swapped = exchange(partial, analysis)
                        send(self, swapped)
                    }
                    | Reject(r) -> {
                        send(editor_handle, r)
                        return
                    }
                    | _ -> {
                        send(self, "unknown")
                    }
                }
            }
        }

        on error(e: String) {
            reverse {
                let rollback = reset_review(e)
                send(self, rollback)
            }
        }
    }
}

-- Agent with @impure control block
agent AuditLogger {
    @impure control {
        on receive(entry: String) {
            -- Reversible audit entry
            reversible {
                let logged = write_log(entry)
                send(logged, archive)
            }
        }
    }
}

{- ============================================================
   SUPERVISOR — strategy, max_restarts, children, handler
   ============================================================ -}

supervisor ReviewSupervisor {
    strategy: one_for_one
    max_restarts: 5 per 30 s

    children: [
        agent Editor(caps: [net, spawn, fs]),
        agent Reviewer(caps: [net]),
        agent AuditLogger()
    ]

    -- Supervisor-level handler for unrecoverable failures
    on child_crash(id: String) {
        send(emergency_channel, id)
    }
}

{- ============================================================
   BEHAVIOURS — reusable handler sets, including hash reference
   ============================================================ -}

behaviour DefaultReviewHandler = {
    on receive(msg: String) -> msg
    on error(e: String) -> e
    on timeout(d: String) -> d
}

{- ============================================================
   FUNCTIONS — all purity annotations (@total, @pure, @impure)
   ============================================================ -}

@total fn weighted_sum(a: Int, b: Int) -> Int {
    return a + b
}

@pure fn normalize_score(raw: Int, max_val: Int) -> Float {
    let ratio = raw / max_val
    return ratio * 100
}

@impure fn log_decision(paper_id: String, verdict: String) -> String {
    let entry = paper_id ++ ":" ++ verdict
    return entry
}

-- Function with no purity annotation and no return type
fn helper(x: Int) {
    let y = x + 1
}

{- ============================================================
   CHOREOGRAPHY — comm, parallel, branch, loop, decision, goto
   ============================================================ -}

choreography review_workflow(
    editor: Agent<Editor>,
    reviewer: Agent<Reviewer>,
    author: Agent<Author>
) {
    -- Communication: author submits to editor
    author -> editor : submit("paper-42")

    -- Editor assigns to reviewer
    editor -> reviewer : assign

    -- Parallel review (multiple reviewers)
    parallel for r in reviewers {
        r -> editor : review_complete
    }

    -- Loop for revision rounds
    loop revision {
        reviewer -> editor : feedback

        -- Branch with traced and given inside choreography
        branch traced "editorial_decision" {
            | accept given { avg_score: 9 } -> {
                editor -> author : notify_accept
            }
            | revise given { avg_score: 5 } -> {
                editor -> author : request_revision
                author -> editor : resubmit
                goto revision
            }
            | reject -> {
                editor -> author : notify_reject
            }
        }
    }

    -- Decision point: editor decides outcome
    editor decides outcome ?
}

-- Minimal choreography demonstrating bare loop and parallel
choreography notification_fanout(sender: Agent<Editor>, receiver: Agent<Reviewer>) {
    sender -> receiver : ping

    parallel {
        sender -> receiver : update_a
        sender -> receiver : update_b
    }

    loop {
        receiver -> sender : ack
    }
}