View Source Kinda.Wrapper.Policy behaviour (kinda v0.11.0)

Consumer-facing policy contract for wrapper generation.

Kinda.Wrapper.Extract and Kinda.Wrapper.Generate stay generic. Downstream projects provide the policy that decides:

  • which extracted functions are generation-blocked
  • which extracted functions require a future callback-bridge layer
  • which public variants are emitted
  • how Elixir arities and Zig NIF entries are derived
  • how raw C param/return facts and record fields project into public types

The older unsupported_* callbacks remain as compatibility aliases, but they are no longer the preferred public vocabulary for new policy code.

Summary

Types

function_name()
generation_blocker_reason()
params()
unsupported_reason()
variant()

Callbacks

callback_bridge(function_name)
callback_bridge?(function_name)
callback_bridge_entries()
dirty(variant)
doc(variant, t)
elixir_params(variant, params)
generation_blocked?(function_name)
generation_blocker_entries()
generation_blocker_reason(function_name)
public_name(variant)
typespec_field(t, t)
typespec_params(variant, t)
typespec_record(t)
typespec_return(variant, t)
unsupported?(function_name)
unsupported_entries()
unsupported_reason(function_name)
variants(function_name)
zig_entry(variant)

Types

function_name()

@type function_name() :: atom()

generation_blocker_reason()

@type generation_blocker_reason() :: atom()

params()

@type params() :: [atom()]

unsupported_reason()

@type unsupported_reason() :: atom()

variant()

@type variant() :: term()

Callbacks

callback_bridge(function_name)

@callback callback_bridge(function_name()) :: Kinda.Wrapper.CallbackBridge.t() | nil

callback_bridge?(function_name)

@callback callback_bridge?(function_name()) :: boolean()

callback_bridge_entries()

@callback callback_bridge_entries() :: %{
  optional(function_name()) => Kinda.Wrapper.CallbackBridge.t()
}

dirty(variant)

@callback dirty(variant()) :: Kinda.CodeGen.NIFDecl.dirty()

doc(variant, t)

@callback doc(variant(), Kinda.Wrapper.Function.t()) :: String.t() | nil

elixir_params(variant, params)

@callback elixir_params(variant(), params()) :: params()

generation_blocked?(function_name)

@callback generation_blocked?(function_name()) :: boolean()

generation_blocker_entries()

@callback generation_blocker_entries() :: %{
  optional(function_name()) => generation_blocker_reason()
}

generation_blocker_reason(function_name)

@callback generation_blocker_reason(function_name()) :: generation_blocker_reason() | nil

public_name(variant)

@callback public_name(variant()) :: atom()

typespec_field(t, t)

(optional) 
@callback typespec_field(Kinda.Wrapper.CRecord.t(), Kinda.Wrapper.CField.t()) ::
  Kinda.CodeGen.TypeSpecRef.t()

typespec_params(variant, t)

(optional) 
@callback typespec_params(variant(), Kinda.Wrapper.Function.t()) :: [
  Kinda.CodeGen.TypeSpecRef.t()
]

typespec_record(t)

(optional) 
@callback typespec_record(Kinda.Wrapper.CRecord.t()) :: Kinda.CodeGen.TypeSpecRef.t()

typespec_return(variant, t)

(optional) 
@callback typespec_return(variant(), Kinda.Wrapper.Function.t()) ::
  Kinda.CodeGen.TypeSpecRef.t()

unsupported?(function_name)

(optional) 
@callback unsupported?(function_name()) :: boolean()

unsupported_entries()

(optional) 
@callback unsupported_entries() :: %{optional(function_name()) => unsupported_reason()}

unsupported_reason(function_name)

(optional) 
@callback unsupported_reason(function_name()) :: unsupported_reason() | nil

variants(function_name)

@callback variants(function_name()) :: [variant()]

zig_entry(variant)

@callback zig_entry(variant()) :: String.t()