wunki

(fn [request]
    (try (handler request)
          (catch Exception e
            (let [data (ex-data e)]
              (case (:type data)
                :coercion-error (do (warn e) (invalid-request (:data data)))
                (do (error e) internal-server-error))))))

wunki

(defnk $GET
  {:responses {200 schemas/SomeSchema}
  [[:request 
    [:query-params limit :- s/Int] 
    :as req]
   [:resources flow :- FlowResource]]
  (...)

wunki

SELECT * FROM users ORDER BY :order ASC 

wunki

(defnk $GET
  "Get the Authenticated user"
  {:responses {200 s/Any}
   :auth-level #{:user}}
  [[:resources user]]
  {:status 200
   :body {:foo "bar"}})

wunki

module Main where

import System.Environment (getArgs)
import qualified Data.ByteString.Lazy as L
import Data.Word

addBytes :: [Word8] -> Word8
addBytes [] = 0
addBytes (x:xs) = x + addBytes xs

wunki

module Main where

import System.Environment (getArgs)
import qualified Data.ByteString.Lazy as L
import Data.Word

{-
- Test to see how fast we can process an 1GB binary file.
- From the blog post: http://jvns.ca/blog/2014/05/12/computers-are-fast/
-

wunki

-- name: fetch-students-for-user
-- Returns all the students for this user

SELECT *
FROM users
WHERE id IN 
  (SELECT user_id FROM students WHERE flow_id IN 
    (SELECT id FROM flows WHERE owner_id = :user_id))

wunki

use std::os;

fn unique_chars(s: &str) -> bool {
    let v: Vec<char> = s.chars().collect();
    let mut y = v.clone();

    y.dedup();
    v.len() == y.len()
}

wunki

#[crate_id="cherr"]

use std::os;
use std::io::fs;

fn main() {
    // get the filename
    let args = os::args();
    let filename: &str = args.get(1).as_slice();

wunki

extern crate crypto = "rust-crypto";

use std::os;

struct Keys {
    AccessKey: String,
    SecretKey: String,
}

pub fn env_keys() -> Option<Keys> {