mbillingr

use std::collections::HashMap;
use std::rc::Rc;

fn main() {
    let x = &Tensor::new(vec![
        vec![0.0, 0.0],
        vec![1.0, 0.0],
        vec![2.0, 0.0],
        vec![0.0, 1.0],
        vec![1.0, 1.0],

mbillingr

use std::collections::HashMap;
use std::rc::Rc;

macro_rules! ident_list {
    () => {
        vec![]
    };
    ($a:ident) => {
        vec![stringify!(a)]
    };

mbillingr

data Value = Null
           | Var Nat
           | Pair Value Value
           | Num Int

data Substitution = Nil
                  | (::) (Nat, Value) Substitution

State : Type

mbillingr

import Text.Lexer.Core
import Text.Lexer
import Text.Parser.Core
import Text.Parser


data ExpressionToken = Number Integer
                     | Operator String
                     | OParen

mbillingr

import itertools


class Entity:
    def __init__(self):
        entities.append(self)

class Lane(Entity):
    def __init__(self):
        super().__init__()

mbillingr

use std::collections::HashMap;
use std::hash::Hash;

pub type Result<T> = std::result::Result<T, Span>;

pub struct Scanner<'i, T: Clone> {
    classifier_table: DefaultTable<char, usize>,
    transition_table: Table<usize, Vec<usize>>,
    accepting_states: Table<usize, T>,
    input: &'i str,

mbillingr

-- evaluation using environments

mutual
    data Lc = Ident String
            | Lambda String Lc
            | Call Lc Lc
            | Closure Env String Lc

    data Env = Empty | Entry String Lc Env

mbillingr

from abc import ABC, abstractmethod
from dataclasses import dataclass
from typing import Literal, Any

BYTEORDER: Literal["little", "big"] = "big"


class Type(ABC):
    @abstractmethod
    def load(self, offset, memory):

mbillingr

import numpy as np
import matplotlib.pyplot as plt
from matplotlib.image import imread
try:
    import seaborn
except ImportError:
    pass


class FieldModel:

mbillingr

module Bin

import Data.Nat

data Bit = O | I

Eq Bit where
    (O == O) = True
    (I == I) = True
    (_ == _) = False