rylev

module Main where
import System.Environment
import Text.ParserCombinators.Parsec
import Control.Monad
import Data.Char

main :: IO ()
main = do putStrLn "What would you like to calculate:"
          input <- getLine
          putStrLn $ readExpr input

rylev

def TasksController
  def index
    Task.where(index_params)
  end
  def create
    Task.create!(create_params)
  end
  
  private
  

rylev

defmodule RGB do
  import Enum, only: [map: 2, join: 1, filter: 2, chunk: 2, count: 1]

  def encode(rgb) when is_list rgb do
    hex = rgb |>
      map(&(integer_to_list &1, 16)) |>
      map(fn [x] -> [x, x]; x  -> x end) |>
      map(&String.from_char_list!/1) |>
      join
    "#" <> hex

rylev

import Database.Redis
import Control.Monad.IO.Class
import Data.ByteString.Char8
 
main :: IO ()
main = do
        conn <- connect defaultConnectInfo
        runRedis conn $ do
          set (pack "hello") (pack "hello")
          hello <- get $ pack "hello"

rylev

### Keybase proof

I hereby claim:

  * I am rylev on github.
  * I am ryanlevick (https://keybase.io/ryanlevick) on keybase.
  * I have a public key whose fingerprint is F379 58BE 0E1A ECE1 D1DB  A8E5 243E 54BE D142 3716

To claim this, I am signing this object:

rylev

enum Maybe<T> {
    case Just(T)
    case None
    
    func maybe(def: T, fn: (T) -> (T)) -> T {
        switch self {
            case let Just(x): return fn(x)
            case None: return def
        }
    }

rylev

if (resp.isSuccess)
  Future{ NoContent }
else passthrough(resp)

if (resp.isSuccess) {
  Future{ NoContent }
} else {
  passthrough(resp)
}

rylev

=erl_crash_dump:0.2
Fri Sep 26 14:40:25 2014
Slogan: init terminating in do_boot ()
System version: Erlang R16B01 (erts-5.10.2) [source] [64-bit] [smp:4:4] [async-threads:10] [hipe] [kernel-poll:false] [dtrace]
Compiled: Tue Sep  3 19:23:51 2013
Taints: 
Atoms: 4761
=memory
total: 10782344
processes: 3969496

rylev

/* Map */
class Future[A] {
  map[B](someMapFunction: A => B): Future[B]
}

// Mapping lets you convert any Future of some type A to a Future of some type B
// For instance you can go from Future[String] to Future[Int]

val myFutureString : Future[String] = Future("some String")

rylev

use std::io::File; use std::io::FileMode::Open;
use std::io::FileAccess::{Write,ReadWrite};
use std::io::IoResult;
use std::fmt::{Show,Formatter,Error};

const MAX_DATA: uint = 512;
const MAX_ROWS: uint = 100;


struct Field {