NathanHowell

Keybase proof

I hereby claim:

• I am nathanhowell on github.
• I am nathanhowell (https://keybase.io/nathanhowell) on keybase.
• I have a public key ASC5cgtZMOLRHjV1qLg1TtuAv8xI1wjwmwqhvv9eUn7ybAo

To claim this, I am signing this object:

NathanHowell

FROM alpine:3.6 AS base
RUN apk add --no-cache python3 ca-certificates tzdata tini \
 && apk upgrade --no-cache

FROM base AS build
RUN apk add --no-cache \
      python3-dev \
      cython \
      build-base

NathanHowell

import tensorflow as tf
from scipy.special import logit


def centering_inference(c):
    """
    :param c: the number of target classes
    :return: a uniformly distributed class bias variable
    """
    return tf.Variable(

NathanHowell

{-# OPTIONS_GHC -fno-warn-orphans #-}
{-# LANGUAGE BangPatterns #-}
{-# LANGUAGE DeriveFunctor #-}
{-# LANGUAGE DeriveFoldable #-}
{-# LANGUAGE DeriveTraversable #-}
{-# LANGUAGE FlexibleContexts #-}
{-# LANGUAGE GeneralizedNewtypeDeriving #-}
{-# LANGUAGE NamedFieldPuns #-}
{-# LANGUAGE OverloadedStrings #-}
{-# LANGUAGE StandaloneDeriving #-}

NathanHowell

resolver: ghc-8.0.0.20160111
setup-info:
  ghc:
    linux64:
      8.0.0.20160111:
        url: "http://downloads.haskell.org/~ghc/8.0.1-rc1/ghc-8.0.0.20160111-x86_64-deb7-linux.tar.xz"
        content-length: 111404852
        sha1: 30d39c6ca6994dcafe25595e053035ad23198b52
    macosx:
      8.0.0.20160111:

NathanHowell

instance (a ~ Proxy "Sum types are not supported by LLVM") => GGetElementIndex a (x :+: y) where
  type GGetElementPtrType a (x :+: y) = Void
  ggetElementIndex _ _ = error "Sum types are not supported by LLVM"
  
type family StructElement (a :: [*]) (n :: Nat) :: * where
  StructElement (x ': xs) 0 = x
  StructElement (x ': xs) n = StructElement xs (n - 1)
  StructElement '[] n = Proxy "Attempting to index past end of structure"

NathanHowell

module Data.Fin

%default total
%access public export

||| Numbers strictly less than some bound.  The name comes from "finite sets".
|||
||| It's probably not a good idea to use `Fin` for arithmetic, and they will be
||| exceedingly inefficient at run time.
||| @ n the upper bound

NathanHowell

[1 of 1] Compiling Repro            ( repro.hs, interpreted )

repro.hs:24:13:
    Cannot instantiate unification variable ‛b0’
    with a type involving foralls:
      (forall r. (a1 -> IO r) -> IO r) -> DecodeAST a1
      Perhaps you want ImpredicativeTypes
    In the expression:
        GHC.Prim.coerce
          (anyContToM ::

NathanHowell

{-# LANGUAGE DefaultSignatures #-}
{-# LANGUAGE RankNTypes #-}
{-# LANGUAGE ScopedTypeVariables #-}

import Data.Typeable

convert :: (Typeable t, Typeable b) => (forall a . Typeable a => a -> r) -> [t] -> b -> r
convert f (x:xs) b = convert f xs (x, b)
convert f    []  b = f b

NathanHowell

.cabal-sandbox/
dist/
cabal.config
cabal.sandbox.config

.*.swp