jlavelle

module Jsonb where

import qualified Orville.PostgreSQL as O
import qualified Orville.PostgreSQL.Internal.Expr as Expr
import qualified Orville.PostgreSQL.Internal.PgTextFormatValue as PgTextFormatValue
import qualified Orville.PostgreSQL.Internal.RawSql as RawSql
import qualified Orville.PostgreSQL.Internal.SqlValue as SqlValue
import qualified Database.PostgreSQL.LibPQ as LibPQ
import Data.ByteString (ByteString)

jlavelle

const width = 800
const height = 800
const rows = 20
const cols = 20
const rowSize = height / rows
const colSize = width / cols
const vWidth = 200
const vHeight = 200

function setup() {

jlavelle

{-# OPTIONS_GHC -fno-warn-missing-methods #-}
{-# LANGUAGE OverloadedLists #-}
{-# LANGUAGE TypeFamilies    #-}
{-# LANGUAGE RankNTypes      #-}

module Main where

import Data.Monoid (Ap(..), Sum(..))
import Data.Foldable (traverse_)
import Control.Applicative (ZipList(..))

jlavelle

module Choose where

import Prelude

import Data.Symbol (class IsSymbol, SProxy, reflectSymbol)
import Data.Variant (Variant)
import Data.Variant.Internal (VariantRep(..))
import Prim.Row (class Cons)
import Record.Unsafe (unsafeGet)
import Unsafe.Coerce (unsafeCoerce)

jlavelle

const Generic = (() => {
  const unit = Symbol('unit')
  const sum = Symbol('sum')
  const prod = Symbol('prod')
  const val = Symbol('val')
  const con = Symbol('con')
  const dat = Symbol('dat')
  const recur = Symbol('recur') // pass as 2nd arg of val to indicate recursion/nesting
  const Unit = { meta: unit }
  const Sum = a => b => ({ value: { left: a, right: b }, meta: sum })

jlavelle

// Simple functor derivation
const conName = Symbol("Constructor Name")
const polyVar = Symbol("Polymorpic Variable")
const nestSelf = Symbol("Nest Self")
const isLazy = Symbol("Lazy Eval")
const unit = Symbol("Unit")
const poly = name => ({ t: polyVar, name })
const self = name => ({ t: nestSelf, name })
const lazy = v => ({ [isLazy]: true, ...v })
const force = r => r()

jlavelle

{-# LANGUAGE OverloadedStrings #-}

module Main where

import           Control.Monad             ((>=>))
import qualified Data.ByteString.Lazy      as BS
import           Data.Maybe                (catMaybes)
import           Data.Monoid               ((<>))
import qualified Data.Text                 as T
import           Network.HTTP.Types        (methodGet, methodPost, status200,

jlavelle

Keybase proof

I hereby claim:

• I am jlavelle on github.
• I am jlavelle (https://keybase.io/jlavelle) on keybase.
• I have a public key ASCUdDn9Ek3Mc8IWVCx-xyYqBfhkX36nczxQtXlz11IFPgo

To claim this, I am signing this object:

jlavelle

import os
from flask import Flask
from flask_sqlalchemy import SQLAlchemy
from sqlalchemy import MetaData, Table

app = Flask()
db = SQLAlchemy()
db.init_app(app)

SQLALCHEMY_DATABASE_URI = os.environ.get('DATABASE_1_URI')