Agnishom

#include <iostream>
#include <string>
#include <pcre.h>
#include <chrono>

using namespace std;

int main() {
    string pattern;
    string input;

Agnishom

use std::collections::VecDeque;
use std::cell::RefCell;
use std::rc::Rc;
use std::cell::Ref;

pub mod vllsimple;
use vllsimple::*;

struct part_man{
    // pools

Agnishom

use std::collections::VecDeque;

// compute the inverse relation given a function
fn inverse_fn(n: usize, f: &Vec<usize>) -> Vec<Vec<usize>> {
    let mut inverse_f = vec![vec![]; n];
    for i in 0..n {
        inverse_f[f[i]].push(i);
    }
    inverse_f
}

Agnishom

#include <stdio.h>

#include "heater.c"

uint8_t temperature;

int main(){
    for (int i = 0; i < 200; i++){
        temperature = i;
        step();

Agnishom

module Board where

import Data.Map (Map, (!))
import qualified Data.Map as Map
import Data.List (intercalate)

data Player = X | O
    deriving (Eq, Ord, Show)

newtype Board = Board (Map (Int, Int) (Maybe Player))

Agnishom

/** The functional list type defined by IntList := EmptyIntList + ConsIntList(int, IntList) */
abstract class IntList {

  /** Visitor hook */
  abstract public Object visit(IntListVisitor iv);
  
  /** Adds i to the front of this. */
  public ConsIntList cons(int i) { return new ConsIntList(i, this); }
  /** Returns the unique empty list. */
  public static EmptyIntList empty() { return EmptyIntList.ONLY; }

Agnishom

{-# LANGUAGE OverloadedStrings #-}
{-# OPTIONS_GHC -Wall #-}

module Regex.Glushkov where

import Control.Monad.State
import Data.Aeson.Encode.Pretty (encodePretty)
import qualified Data.Text as T
import qualified Data.ByteString.Lazy as BSL

Agnishom

use std::marker::PhantomData;

pub trait Sink<A> {
    fn init(&mut self);
    fn next(&mut self, item: A);
    fn end(&mut self);
}

pub trait Query<A,B>: {
    fn init(&mut self, sink: &mut dyn Sink<B>);

Agnishom

import data.fintype

structure dfa (alphabet : Type) [fintype alphabet] :=
 (qq : Type) {is_finite : fintype qq} {has_decidable_eq : decidable_eq qq}
 (δ : qq → alphabet → qq)
 (init : qq)
 (fin : qq → bool)

def language (alphabet : Type) [fintype alphabet] := list alphabet → bool

Agnishom

Keybase proof

I hereby claim:

• I am agnishom on github.
• I am agnishom (https://keybase.io/agnishom) on keybase.
• I have a public key ASBEfGCEQw4cY-VOkwSiHBWosC_4pM60jwJi5AufQzgF2wo

To claim this, I am signing this object: