paavohuhtala

[StructLayout(LayoutKind.Sequential)]
public struct BitArray512<TEnum> : IEquatable<BitArray512<TEnum>>
{
    private ulong _a0;
    private ulong _a1;
    private ulong _a2;
    private ulong _a3;
    private ulong _a4;
    private ulong _a5;
    private ulong _a6;

paavohuhtala

Keybase proof

I hereby claim:

• I am paavohuhtala on github.
• I am paavohtl (https://keybase.io/paavohtl) on keybase.
• I have a public key ASAMdOYX6Q8PxOvmdwLuknUkDDWjr3paAkTAxx3z7KChqgo

To claim this, I am signing this object:

paavohuhtala

let time = 0;

function getSine(freq, time) {
  const period = 2;
  const phase = freq * (time % period);
  return phase - Math.floor(phase);
	//return Math.sin(2 * Math.PI * freq * time) > 0.5 ? 1 : 0.0;
}

function loop(numFrames, outL, outR, sampleRate) {

paavohuhtala

declare module "partial.lenses" {

  // This is a fairly simple, heterogenous type-level linked list.
  // We use this to represent lense types in an easy-to-use way.
  type ConsNil = { "__NIL__": never };
  type Cons<A, B> = { head: A, tail: B | ConsNil }
  // Just a bit of syntax sugar.
  type ConsLast<A> = Cons<A, ConsNil>

  // TupleToCons converts a tuple type into a linked list.

paavohuhtala

open System
open System.Collections.Generic

let samples = 100000

let rand = Random()

let lenTo1 () =
  Seq.unfold (fun sum -> if sum > 1.0 then None else Some ((), sum + rand.NextDouble ())) 0.0
  |> Seq.length

paavohuhtala

macro_rules! field_size {
  (1) => (bool);
  (2) => (u8);
  (3) => (u8);
  (4) => (u8);
  (5) => (u8);
  (6) => (u8);
  (7) => (u8);
  (8) => (u8);
}

paavohuhtala

namespace FsBots

open System
open Hopac

type ChatMessage<'id, 'msg, 'user> = {
  chatId: 'id
  content: string
  conversation: Conversation<'id, 'msg, 'user>
  internalMessage: 'msg

paavohuhtala

open System

open Telegram.Bot
open Telegram.Bot.Types
open Telegram.Bot.Types.Enums

open Hopac

let token = "nope"

paavohuhtala

using System;
using System.Linq;
using System.Collections.Generic;

namespace ClassesForTheMasses
{
    public interface Zero<A> { A Zero(); }
    public interface One<A> { A One(); }
    public interface Add<A> { A Add(A x, A y); }

paavohuhtala

use std;
use std::io::{Read, Seek, SeekFrom};
use byteorder::{ReadBytesExt, LittleEndian};

trait ReadableStruct {
  fn read_from<R: Read + Seek>(reader: &mut R) -> Result<Self, std::io::Error> where Self : std::marker::Sized;
}

#[derive(Debug)]