tiny.accy.kernel.interpret

1pub const Unhandled = struct {2    indexed: Action = .lower,3    regions: Action = .lower,45    pub const Action = enum {6        lower,7        bind,8    };9};

1pub const Graph = struct {};

1pub const indexed = Unhandled{ .indexed = .bind };

1pub const lower = Unhandled{};

1pub const transparent = Unhandled{ .indexed = .bind, .regions = .bind };

1pub fn InterpretSpec(comptime Initial: type) type {2    if (comptime @hasDecl(Initial, "attach")) return Initial;3    return With(Initial);4}

1pub fn Layer(comptime Next: type, comptime Impl: type, comptime unhandled: policy.Unhandled) type {2    return dispatch.Layer(Next, Impl, unhandled);3}

1pub fn Result(comptime Spec: type) type {2    return State(Spec).Result;3}

1pub fn Stack(comptime Specs: type) type {2    _ = stackLength(Specs);3    return struct {4        specs: Specs,56        pub fn attach(self: @This(), next: anytype) StackAttach(0, Specs, @TypeOf(next)) {7            return attachFrom(0, self.specs, next);8        }9    };10}

1pub fn State(comptime Spec: type) type {2    return @TypeOf(@as(Spec, undefined).attach(@as(*program.Builder, undefined)));3}

1pub fn With(comptime Impl: type) type {2    return WithPolicy(Impl, policy.implUnhandled(Impl, policy.lower));3}

1pub fn WithPolicy(comptime Impl: type, comptime unhandled: policy.Unhandled) type {2    return struct {3        impl: Impl,45        pub fn attach(self: @This(), next: anytype) Layer(@TypeOf(next), Impl, unhandled) {6            return .{7                .next = next,8                .impl = self.impl,9            };10        }11    };12}

1pub fn asSpec(initial: anytype) InterpretSpec(@TypeOf(initial)) {2    if (comptime @hasDecl(@TypeOf(initial), "attach")) return initial;3    return with(initial);4}

1pub fn bind(impl: anytype) WithPolicy(@TypeOf(impl), policy.transparent) {2    return .{ .impl = impl };3}

1pub fn bindIndexed(impl: anytype) WithPolicy(@TypeOf(impl), policy.indexed) {2    return .{ .impl = impl };3}

1pub fn deinitIfPresent(value: anytype) void {2    const Value = @typeInfo(@TypeOf(value)).pointer.child;3    switch (@typeInfo(Value)) {4        .@"struct", .@"union", .@"enum", .@"opaque" => if (comptime @hasDecl(Value, "deinit")) value.deinit(),5        else => {},6    }7}

1pub fn graph() With(Graph) {2    return with(Graph{});3}

1pub fn layer(next: anytype, impl: anytype) Layer(@TypeOf(next), @TypeOf(impl), policy.implUnhandled(@TypeOf(impl), policy.lower)) {2    return .{3        .next = next,4        .impl = impl,5    };6}

1pub fn stack(specs: anytype) Stack(@TypeOf(specs)) {2    return .{ .specs = specs };3}

1pub fn with(impl: anytype) With(@TypeOf(impl)) {2    return .{ .impl = impl };3}

1const policy = @import("policy.zig");2const spec = @import("spec.zig");3pub const surface = @import("surface.zig");45pub const Unhandled = policy.Unhandled;67pub const lower_unhandled = policy.lower;8pub const indexed_unhandled = policy.indexed;9pub const transparent_unhandled = policy.transparent;10pub const Graph = spec.Graph;11pub const With = spec.With;12pub const WithPolicy = spec.WithPolicy;13pub const Stack = spec.Stack;14pub const State = spec.State;15pub const Result = spec.Result;16pub const Layer = spec.Layer;17pub const InterpretSpec = spec.InterpretSpec;18pub const graph = spec.graph;19pub const with = spec.with;20pub const bind = spec.bind;21pub const bindIndexed = spec.bindIndexed;22pub const stack = spec.stack;23pub const layer = spec.layer;24pub const asSpec = spec.asSpec;25pub const deinitIfPresent = spec.deinitIfPresent;26pub const excluded_methods = surface.excluded_methods;27pub const supports = surface.supports;

1pub const interpret = interpret_mod;