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) {

ityonemo

import torch
import torch.nn as nn

class ResNetBlock(nn.Module):
    def __init__(self, input_channel_count, internal_channel_count, downsampler = None, stride=1, layers = 'all'):
        # input_channel_count:  An image tensor is a h*w*k tensor where k is represents
        #    how many channels, naively, groups of features discovered by the ml model.
        #    the shape of the input tensor is h*w*input_channel.
        # internal_channel_count:  like above, but the shape of the output tensor is
        #    h*w*internal_channel_count.  In a typical convnet strategy, you will want the

ityonemo

A half-hour to learn Zig

This is inspired by https://fasterthanli.me/blog/2020/a-half-hour-to-learn-rust/

Basics

the command zig run my_code.zig will compile and immediately run your Zig program. Each of these cells contains a zig program that you can try to run (some of them contain compile-time errors that you can comment out to play with)

ityonemo

const std = @import("std");

pub fn Algebra(comptime fields: []const type) type {
    return struct{
        pub fn @"<+>"(a: anytype, b: anytype) FieldFor(@TypeOf(a), @TypeOf(b)).Type {
            const F: type = FieldFor(@TypeOf(a), @TypeOf(b));
            return F.@"<+>"(a, b);
        }

        pub fn FieldFor(comptime AType: type, comptime BType: type) type {

ityonemo

const std = @import("std");
const print = std.debug.print;

var yielded = false;

fn yield() void {
  yielded = true;
  suspend;
}

ityonemo

defmodule Lisp do

  @type ast :: [String.t | number | ast]
  @type token :: :lp | :rp | number | String.t

  @letters Enum.concat(?a..?z, ?A..?Z)
  @numbers ?0..?9
  @operators [?+]

  @doc """