George Leontiev folone

Most active GitHub users (git.io/top)

The list would not be updated for now. Don't write comments.

The count of contributions (summary of Pull Requests, opened issues and commits) to public repos at GitHub.com from Wed, 21 Sep 2022 till Thu, 21 Sep 2023.

Because of GitHub search limitations, only 1000 first users according to amount of followers are included. If you are not in the list you don't have enough followers. See raw data and source code. Algorithm in pseudocode:

githubUsers

	scala> import scalaz._, Scalaz._, effect._
	import scalaz._
	import Scalaz._
	import effect._

	scala> val listIoEither = List(EitherT[IO, Int, String](IO(Right("r"))))
	listIoEither: List[scalaz.EitherT[scalaz.effect.IO,Int,String]] = List(scalaz.EitherTFunctions$$anon$20@49ab1824)

	scala> val ioEitherList = listIoEither.sequenceU
	ioEitherList: scalaz.EitherT[scalaz.effect.IO,Int,List[java.lang.String]] = scalaz.EitherTFunctions$$anon$20@5d38a346

	{-# LANGUAGE StandaloneDeriving, FlexibleContexts, UndecidableInstances #-}
	-- Laungh ghci with -fobject-code to make the Fix/Tree trick work (thanks edwardk).

	-- courtesy of hpc on #haskell
	import Unsafe.Coerce
	import Control.Monad.ST

	toInteger :: Int -> Integer
	isJust :: Maybe a -> Bool
	null :: [a] -> Bool

	module Nicomachus where

	open import Function
	open import Relation.Binary.PropositionalEquality
	import Relation.Binary.EqReasoning as EqReasoning

	open import Data.Nat
	open import Data.Nat.Properties

	-- http://en.wikipedia.org/wiki/Nicomachus%27s_theorem

	{-# LANGUAGE GADTs #-}
	{-# LANGUAGE RankNTypes #-}
	{-# LANGUAGE StandaloneDeriving #-}
	module RedBlackTree where

	data Zero
	data Succ n
	type One = Succ Zero

	data Black

	Latency Comparison Numbers (~2012)
	----------------------------------
	L1 cache reference 0.5 ns
	Branch mispredict 5 ns
	L2 cache reference 7 ns 14x L1 cache
	Mutex lock/unlock 25 ns
	Main memory reference 100 ns 20x L2 cache, 200x L1 cache
	Compress 1K bytes with Zippy 3,000 ns 3 us
	Send 1K bytes over 1 Gbps network 10,000 ns 10 us
	Read 4K randomly from SSD* 150,000 ns 150 us ~1GB/sec SSD

	#!/bin/bash

	echo "Direct dependencies"
	sbt 'show all-dependencies' \| \
	gawk 'match($0, /List\((.*)\)/, a) {print a[1]}' \| \
	tr -d ' ' \| tr ',' '\n' \| sort -t ':' \| \
	tr ':' '\t' \| expand -t 30

	echo -e "\nAll dependencies, including transitive dependencies"
	sbt 'show managed-classpath' \| tr -d ' ' \| tr ',' '\n' \| \

	object SKI_Applicative {
	/*
	First, let's talk about the SK combinator calculus and how it contributes to solving your problem.

	The SK combinator calculus is made of two functions (aka combinators): S and K. It is sometimes called the SKI combinator calculus, however, the I combinator can be derived from S and K. The key observation of SK is that it is a turing-complete system and therefore, anything that can be expressed as SK is also turing-complete. Here is a demonstration that Scala's type system is turing-complete (and therefore, undecidable) for example[1].

	The K combinator is the most trivial of the two. It is sometimes called "const" (as in Haskell). There is also some discussion about its evaluation strategy in Scala and how to best express it[2]. The K function might be paraphrased as, "takes a value and returns a (constant) unary function that always returns that value."
	*/
	def k[A, B]: A => B => A =
	a => _ => a

	import scalaz.WriterT
	import scalaz.NonEmptyList
	import scalaz.syntax.id._

	import scalaz.std.option._
	import scalaz.syntax.std.option._

	type OptionLogger[A] = WriterT[Option, NonEmptyList[String], A]

	val two: OptionLogger[Int] = WriterT.put(2.some)("The number two".wrapNel)

	-- See http://blog.ezyang.com/2012/08/applicative-functors/
	module Main
	where

	import Prelude hiding ((**))
	import Control.Monad

	bind :: Monad m => m a -> (a -> m b) -> m b
	bind = (>>=)