zudov

-- | https://jeltsch.wordpress.com/2013/02/14/the-constraint-kind/
{-# LANGUAGE ConstraintKinds, TypeFamilies #-}

import           Prelude hiding (Functor(..))
import           Data.Set    (Set)
import qualified Data.Set as Set
import           GHC.Exts    (Constraint)

class Functor f where
  type Object f a :: Constraint

pyrtsa

export _ps1_timer

function _ps1_timer_start {
  # echo START
  _ps1_timer=${_ps1_timer:-`gdate +%s%N 2> /dev/null || date +%s%N`};
}

function _ps1_timer_stop {
  # echo STOP
  if [ -z "$_ps1_timer" ]; then

pyrtsa

-- Show loaded modules in window title and use a green "λ>" as prompt.
-- Subsequent lines of multi-line commands shall begin with " |".
:set prompt  "\SOH\ESC]0;GHCi: %s\BEL\ESC[32;1m\STXλ>\SOH\ESC[0m\STX "
:set prompt2                    "\SOH\ESC[32;1m\STX |\SOH\ESC[0m\STX "

-- Paste and evaluate text from the OS X clipboard. (The pasted text also
-- prints in yellow unless pasting quietly using :paste-quiet.)
:set -package process
:def paste \_ -> do { paste <- System.Process.readProcess "pbpaste" [] ""; let cmd = if '\n' `elem` paste then ":{\ntype Ö = ()\n" ++ paste ++ "\n:}" else paste in putStrLn ("\SOH\ESC[33m\STX" ++ paste ++ "\SOH\ESC[0m\STX") >> return (":cmd return " ++ show cmd) }
:def paste-quiet \_ -> do { paste <- System.Process.readProcess "pbpaste" [] ""; let cmd = if '\n' `elem` paste then ":{\ntype Ö = ()\n" ++ paste ++ "\n:}" else paste in return (":cmd return " ++ show cmd) }

alanzeino

LLDB Debugging Cheat Sheet

Commands

LLDB Commands

LLDB comes with a great set of commands for powerful debugging.

help

Your starting point for anything. Type help to get a list of all commands, plus any user installed ones. Type 'help for more information on a command. Type help to get help for a specific option in a command too.

cobbpg

{-# LANGUAGE Arrows #-}

import Control.Arrow
import Control.Category
import Prelude hiding (id, (.))

-- Only for testing
import Text.Printf

newtype SF a b = SF (Float -> a -> (SF a b, b))

pyrtsa

import Random

random(0 ..< 10)               // Int
random(1 ... 1000_000)         // Int
random(-1000_000 ... 1000_000) // Int
random(Int.min ... Int.max)    // Int

randomMax(UInt64.max)          // UInt64
random(0 ... UInt64.max)       // UInt64
random(1 ... UInt(10))         // UInt

natecook1000

// Curry Recipe

func curryRecipe(n: Int) -> String {
    let types = join(", ", map(1...n, { "T\($0)" }))
    let returnType = join(" -> ", map(1...n, { "T\($0)" }))
    let closures = join(" in ", map(1...n, { "{ t\($0)" }))
    let braces = join(" ", Array(count: n, repeatedValue: "}"))
    return "func curry<\(types), R>(f: (\(types)) -> R) -> \(returnType) -> R {\r" +
        "    return \(closures) in f(\(types.lowercaseString)) \(braces)\r}"
}

pyrtsa

// Hello, fellow Swift programmer!
//
// Here's a demonstration of a few ways of cleaning up the unwrapping of
// optionals in Swift.
//
// Swift is known to have both OO and functional background. Thus, there is
// probably some middle ground programming style that is *more* functional than
// Objective-C, and probably less so than Haskell. This playground tries to
// compare their differences in the pretty common scenario of dealing with
// errors or missing input.

pyrtsa

;; This is probably either a silly idea or a foolish implementation of an okay one.

(defn ret*
  [bindings & body]
  (if-let [[k v & more] (not-empty bindings)]
  	`(let [k# ~v]
  	   (if (reduced? k#)
  	   	 k#
  	   	 (let [~k k#]
  	   	   ~(apply ret* more body))))

pyrtsa

#include <chrono>

constexpr auto operator "" _days (unsigned long long n) { return std::chrono::hours(24 * n); }
constexpr auto operator "" _h    (unsigned long long n) { return std::chrono::hours(n); }
constexpr auto operator "" _min  (unsigned long long n) { return std::chrono::minutes(n); }
constexpr auto operator "" _s    (unsigned long long n) { return std::chrono::seconds(n); }
constexpr auto operator "" _ms   (unsigned long long n) { return std::chrono::milliseconds(n); }
constexpr auto operator "" _µs   (unsigned long long n) { return std::chrono::microseconds(n); }
constexpr auto operator "" _ns   (unsigned long long n) { return std::chrono::nanoseconds(n); }