edofic

module Main where

import Control.Monad (guard)
import Data.List (tails, sort, group)
import qualified Data.Discrimination as D  -- package `discrimination`
import qualified Data.IntSet as IS  -- package `containers`

example :: [Int]
example = [-7,1,2,3,5,5,7,17]

edofic

import pytest


@pytest.fixture()
def user(request):
  user = 'mock user'
  if hasattr(request, 'param'):
    user += ': {}'.format(request.param)
  return user

edofic

port module Main exposing (..)

-- effect types
type Prompt u
    = Read (String -> u)
    | Write String u


type Api u
    = Get Int (String -> u)

edofic

{-# LANGUAGE RecursiveDo #-}

import Control.Monad
import Control.Monad.Free
import Control.Monad.Writer
import Data.Functor.Identity

data Instruction = End
                 | Inc Int Int
                 | DeB Int Int Int

edofic

Keybase proof

I hereby claim:

• I am edofic on github.
• I am edofic (https://keybase.io/edofic) on keybase.
• I have a public key whose fingerprint is DBAE 9F54 A9E7 31DE 557E E95F 7B7F 9EFB 7B09 5BF9

To claim this, I am signing this object:

edofic

scala> val f = (_: Int) + 1
f: Int => Int = <function1>

scala> val g = (_: Int).toString
g: Int => String = <function1>

scala> case class Compose[a,b,c](f: a => b, g: b => c) extends Function[a,c]  {
     | def apply(a: a): c = g(f(a))
     | }
defined class Compose

edofic

{ stdenv, fetchurl

# Linked dynamic libraries
, glib, gstreamer, libuuid, mesa, pulseaudioFull, qt55, sqlite, xorg
}:

stdenv.mkDerivation {
  name = "zoom";
  version = "1.1.44485.0317";

edofic

function run(exp) {
  var magic = "MAGIC!";
  return eval(exp);
}

run("1") //1
run("'foo'") //"foo"
run("magic") //"MAGIC!"

edofic

module Main where

import Control.Concurrent.MVar

data Reader (m :: * -> *) (a :: *) = Reader { ask :: m a }

data State m s = State { get :: m s
                       , put :: s -> m ()
                       }

edofic

import sys

class Hack(object):
  bar = 2
  @property
  def foo(self):
    return 1

sys.modules['hack'] = Hack()