rexim

data FingerTree a = Empty
                  | Single a
                  | Deep (Digit a) (FingerTree (Node a)) (Digit a)
                    deriving Show

data Digit a = One a | Two a a | Three a a a | Four a a a a deriving Show
data Node a  = Node2 a a | Node3 a a a deriving Show

digitToList :: Digit a -> [a]
digitToList (One y1)           = [y1]

rob-brown

defmodule ZipList do
  defstruct previous: [], current: nil, remaining: []

  def from_list(list, index \\ 0)
  def from_list([], _), do: {:error, :empty_list}
  def from_list(list, index) when length(list) < index, do: {:error, :index_out_of_bounds}
  def from_list(list, index) when is_list(list) do
    previous = list |> Enum.take(index) |> Enum.reverse
    [current | remaining] = Enum.drop list, index
    ziplist = %__MODULE__{previous: previous, current: current, remaining: remaining}

alekseykulikov

Recently CSS has got a lot of negativity. But I would like to defend it and show, that with good naming convention CSS works pretty well.

My 3 developers team has just developed React.js application with 7668 lines of CSS (and just 2 !important). During one year of development we had 0 issues with CSS. No refactoring typos, no style leaks, no performance problems, possibly, it is the most stable part of our application.

Here are main principles we use to write CSS for modern (IE11+) browsers:

• SUIT CSS naming conventions + SUIT CSS design principles;
• PostCSS + CSSNext. Future CSS syntax like variables, nesting, and autoprefixer are good enough;
• Flexbox is awesome. No need for grid framework;
• Normalize.css, base styles and variables are solid foundation for all components;

bitwalker

defmodule Config do
  @moduledoc """
  This module handles fetching values from the config with some additional niceties
  """

  @doc """
  Fetches a value from the config, or from the environment if {:system, "VAR"}
  is provided.

  An optional default value can be provided if desired.

henrik

defmodule RegexCase do
  defmacro regex_case(string, do: lines) do
    new_lines = Enum.map lines, fn ({:->, context, [[regex], result]}) ->
      condition = quote do: String.match?(unquote(string), unquote(regex))
      {:->, context, [[condition], result]}
    end

    # Base case if nothing matches; "cond" complains otherwise.
    base_case = quote do: (true -> nil)
    new_lines = new_lines ++ base_case

quchen

13:15 <xQuasar>      | HASKELL IS FOR FUCKIN FAGGOTS. YOU'RE ALL A BUNCH OF 
                     | FUCKIN PUSSIES
13:15 <xQuasar>      | JAVASCRIPT FOR LIFE FAGS
13:16 <luite>        | hello
13:16 <ChongLi>      | somebody has a mental illness!
13:16 <merijn>       | Wow...I suddenly see the error of my ways and feel 
                     | compelled to write Node.js!
13:16 <genisage>     | hi
13:16 <luite>        | you might be pleased to learn that you can compile 
                     | haskell to javascript now

Ferus

# This file is a transcription of RFC 1459 section 6 into YAML, so that
# programs written in any language may utilize it. It describes the
# various numeric replies an IRC server may send, their canonical name,
# number and a short description, if available.
#
# Copywrong (c) 2012 slowpoke (Proxy) < proxypoke at lavabit dot com >
# This file is licensed under the terms of the WTFPL v2.
#
#
#            DO WHAT THE FUCK YOU WANT TO PUBLIC LICENSE