agrafix

(defconst hs-imports-imports-start-regexp
  (rx (group (and bol "import "))))


(defconst hs-imports-language-start-regexp
  (rx (group (and bol "{-# LANGUAGE "))))

(defun hs-imports--search-beg-point (start what &optional end)
  "Search the first import line until reach the END point."
  (save-excursion

agrafix

{-# LANGUAGE KindSignatures #-}
{-# LANGUAGE DataKinds #-}
{-# LANGUAGE GADTs #-}
{-# LANGUAGE TypeFamilies #-}
module Api
    ( Endpoint(..)
    , Proxy(..)
    , MaybeToList
    , (<//>), var, Path(..), renderRoute
    , Generic, ToJSON, FromJSON, NFData, Typeable

agrafix

/**
 * C++ implementation of FFT
 *
 * Source: http://paulbourke.net/miscellaneous/dft/
 */

#pragma once

/*
   This computes an in-place complex-to-complex FFT

agrafix

#pragma once

#include <cmath>
#include <vector>
#include <assert.h>

inline double gauss(double sigma, double x) {
    double expVal = -1 * (pow(x, 2) / pow(2 * sigma, 2));
    double divider = sqrt(2 * M_PI * pow(sigma, 2));
    return (1 / divider) * exp(expVal);

agrafix

#!/usr/bin/env python2.7

# This script is a hack until the elm-package install bug is fixed in docker containers
import urllib2
import argparse
import tempfile
import os
import zipfile
import shutil
import json

agrafix

module Main where

import StartApp
import String
import Html                                   
import Html.Events as Html
import Html.Attributes as Html
import Html.Shorthand exposing (..) 
import Bootstrap.Html exposing (..)
import Html exposing (blockquote)

agrafix

var samples =
    [ '    do var <- readTVar'
    , 'do foo'
    , 'main =   do let x = do { foo }'
    , 'main = do let x = do foo'
    , 'main = foo $ do '
    ];

for (var i in samples) {
    var line = samples[i];

agrafix

import Data.Time

instance Arbitrary UTCTime where
    arbitrary =
        do randomDay <- choose (1, 29) :: Gen Int
           randomMonth <- choose (1, 12) :: Gen Int
           randomYear <- choose (2001, 2002) :: Gen Integer
           randomTime <- choose (0, 86401) :: Gen Int
           return $ UTCTime (fromGregorian randomYear randomMonth randomDay) (fromIntegral randomTime)

agrafix

{-# LANGUAGE GeneralizedNewtypeDeriving #-}
{-# LANGUAGE RankNTypes #-}
module AtomicState
    ( getState, modifyState, forkThread, execAtomicStateT, AtomicStateT
    , readState, runReadOnly, AtomicReadT
    )
where

import Control.Monad.Reader
import Control.Concurrent

agrafix

Keybase proof

I hereby claim:

• I am agrafix on github.
• I am ath (https://keybase.io/ath) on keybase.
• I have a public key whose fingerprint is C8DC 581B 8739 05E7 F877 3A99 CA50 B525 5FA1 6367

To claim this, I am signing this object: