ityonemo

const E = enum(u12) { 
    Int = 0xFFF,
    String = 0xFFE,
    Pointer = 0xFFD,
}

const P = packed union(?e){
    const this = @This();

    Int: packed struct {

ityonemo

{
	"Inspect": {
		"prefix": "ins",
		"body": "|> IO.inspect(label: \"$RELATIVE_FILEPATH:#{__ENV__.line}\")",
		"description": "Adds a pipeline with a labelled `IO.inspect`",
	}
}

ityonemo

defmodule T do

  @foo [%{foo: "bar"}]

  def t(@foo) do
    :ok
  end
end

# DISASSEMBLED RESULT:

ityonemo

defmodule(:"7tbgPucj") do
  def(fun0(arg0, arg1, arg2)) do
    expr0 = fun1(arg0, arg1, arg0, true, arg2, arg0, arg2)
    expr1 = fun3(expr0, arg1, arg2, 0.3876953125, expr0, arg2)
    expr2 = [arg1, expr1, -0.8984375]
    expr3 = [arg0, arg2, false, expr0, <<185, 89>>, -980.70703125, arg0, expr0, arg2]
    expr4 = [arg2, expr1, expr0, arg1, false, -9, :ulI]
    expr5 = :j
  end

ityonemo

defprotocol Convertible do
  def convert(a, target_struct)
end

defmodule ConversionBoilerplate do
  defmacro __using__() do
    quote do
      def convert(a, to: struct_module) do
        # maybe do some asserts here
        module = Module.concat(__MODULE__, struct_module)

ityonemo

defprotocol Proto do
  def generic_getter(value)
end

defmodule A do
  defstruct [:a]
  def generic_getter(v), do: v.a
  
  defimpl Proto do
    defdelegate generic_getter(value), do: A

ityonemo

const std = @import("std");

fn childOf(comptime T: type) type {
  return switch (@typeInfo(T)) {
     .Vector => |vector| vector.child,
     .Array => |array| array.child,
     .Pointer => |pointer| {
        switch (pointer.size) {
           .Slice => {},
           .One => {

ityonemo

// for testing purposes only, a mock of the c stdlib that provides calloc and malloc backed by the
// testing allocator.  Stores last length in a global: Definitely not threadsafe.
var test_allocator_total_length: usize = undefined;

const MockedLibC = struct {
    pub fn calloc(count: usize, size: usize) ?[*]u8 {
        test_allocator_total_length = count * size;
        var slice = std.testing.allocator.alloc(u8, test_allocator_total_length) catch return null;
        const result_pointer = @ptrCast([*]u8, slice.ptr);
        @memset(result_pointer, 0, test_allocator_total_length);

ityonemo

defmodule MyEts do
  use GenServer
  def start_link(_), do: GenServer.start_link(__MODULE__, nil, name: __MODULE__)

  @spec init(any) :: :ignore | {:ok, nil, :hibernate}
  def init(_) do
    :ets.new(__MODULE__, [:set, :public, :named_table])

    {:ok, nil, :hibernate}
  catch

ityonemo

const get_memory = () => chiaroscuro.memory;

var chiaroscuro = {
    imports: {
        env: {
            // exported functions
            abort(msg, file, line, column) {
                console.error("abort(" + msg + ")@" + file + " " + line + ":" + column);
            },
            jsConsoleLogInt(int) {