ramirez7

module PoolDeadlock where

import           Control.Concurrent       (threadDelay)
import           Control.Concurrent.Async (replicateConcurrently_)
import           Data.Pool

run :: Int -- ^ Pool size
    -> Int -- ^ f sleep
    -> Int -- ^ Concurrency degree
    -> IO ()

ramirez7

module AsyncPool where

import           Control.Concurrent          (threadDelay)
import           Control.Concurrent.Async    (async)
import           Control.Concurrent.MVar     (newMVar, withMVar)
import           Control.Concurrent.STM      (atomically)
import           Control.Concurrent.STM.TVar (newTVarIO, readTVar, writeTVar)
import           Control.Monad               (replicateM_, when)
import           Data.Pool

ramirez7

λ: import Dhall.Repl
λ: defaultRepl
>>> List/head Integer [1, 2, 3]
Optional Integer

[1] : Optional Integer
>>> List/head Integer ([] : List Integer)
Optional Integer

[] : Optional Integer

ramirez7

λ: :kind! Dh.Normalizer Int Bool
Dh.Normalizer Int Bool :: *
= Dh.Normalizer Int Bool
λ: type family Id a where Id a = a
λ: :kind! Id (Dh.Normalizer Int Bool)
Id (Dh.Normalizer Int Bool) :: *
= Dh.Expr Int Bool -> Maybe (Dh.Expr Int Bool)

ramirez7

λ: :seti -XTypeApplications
λ: :seti -XDataKinds
λ: import Dalek.Repl
λ: import Dalek.Exts.Time.Core
λ: import Dalek.Exts.Time.Parser
λ: import Dalek.Exts.Time.TypeCheck
λ: import Dalek.Typer
λ: import Dalek.TypeCheck
λ: import Dalek.Core
λ: repl @(Open '[DhTime]) parser normalizer (toTyper $ sendTyper typer)

ramirez7

;; I put this in my .emacs
(require 'haskell-commands)

(defun my-auto-format ()
  (interactive)
  ;; see https://github.com/haskell/haskell-mode/blob/dd0ea640fa449d021399a17db65e4d50d3f0f2a9/haskell-commands.el#L811
  (haskell-mode-buffer-apply-command "brittany"))
;; The args to call-process-region within haskell-mode-buffer-apply-command are hard-coded to nil,
;; so it looks like there's no way to use --indent=2

ramirez7

{ pkgs, lib, config, ... }:
{
  networking = {
    firewall.allowedTCPPorts = [
      3000  # grafana
      9090  # prometheus
      9093  # alertmanager
    ];
    useDHCP = true;
  };

ramirez7

λ: import System.Metrics.Prometheus.Metric.Histogram as H
λ: h <- H.new []
λ: s1 <- H.sample h
λ: :print s1
s1 = HistogramSample (_t4::Buckets) 0.0 0
λ: H.observe 2.2 h
λ: H.observe 2.222 h
λ: H.observe 1232.222 h
λ: s2 <- H.sample h

ramirez7

// routes1.go
func Routes1(mux *http.ServeMux) {
	mux.Handle("/route1/a", handler1A)
	mux.Handle("/route1/b", handler1B)
	mux.Handle("/route1/c", handler1C)
}

// routes2.go
func Routes2(mux *http.ServeMux) {
	mux.Handle("/route2/x", handler2X)

ramirez7

{-# LANGUAGE AllowAmbiguousTypes   #-}
{-# LANGUAGE ConstraintKinds       #-}
{-# LANGUAGE DataKinds             #-}
{-# LANGUAGE FlexibleInstances     #-}
{-# LANGUAGE GADTs                 #-}
{-# LANGUAGE KindSignatures        #-}
{-# LANGUAGE MultiParamTypeClasses #-}
{-# LANGUAGE RankNTypes            #-}
{-# LANGUAGE ScopedTypeVariables   #-}
{-# LANGUAGE TypeApplications      #-}