refi64

import option ;
import package ;
import regex ;

local embed = [ option.get embed : 0 ] ;

local xprops = ;

if embed in 1 true yes {
    xprops = "<link>static" ;

refi64

/*
   This is a simple benchmark of the C++ string implode algorithms as stated at
   http://stackoverflow.com/questions/5689003/
   how-to-implode-a-vector-of-strings-into-a-string-the-elegant-way.
   This uses Celero.

   Results on my machine, compiling with Clang SVN and -O3:

   [==========]
   [  CELERO  ]

refi64

#!/bin/sh

if [ -z "$1" ] || [ -z "$2" ]; then
    echo "usage: $0 <file> <line>"
    exit 1
fi

line=`expr $2 - \( $2 / 256 \* 256 \) + \( $(wc -l < $1) / 256 \* 256 \)`

echo "$line:  `sed ${line}q\;d $1 | sed 's/^[ \t]*//;s/[ \t]*$//'`"

refi64

fun add_to(totals: list[float])(values: list[float]) =>
    if values.len != 1.size then let n = totals.len in match n with
    | 0uz => values
    | $(values.len) => (add of (float^2)).map $ totals.zip2 values
    // this ugliness is because of a bug in Felix that generates invalid C++ code
    // see https://github.com/felix-lang/felix/issues/71
    | _ => #(fun () = { raise "Inconsistent-length rows"; return #list[float]; })
    endmatch else totals;

fun add_line_to(totals: list[float])(line: string) =>

refi64

import Control.Applicative
import System.Environment
import Data.List.Split
import Data.List

-- the ":: [Float]" prevents the type inferencer from going haywire
addTo [] v = v :: [Float]
addTo t v
  | length t == length v = zipWith (+) t v
  | otherwise            = error "Inconsistent-length rows"

refi64

def fuzzyfinder(p, l):
        return map(lambda t: t[0], sorted(filter(lambda t: all(map(lambda x: x != -1, t[1])), map(lambda s: (s,map(s.find, p)), l)), key=lambda t: t[1]))

refi64

w:0:"/dev/stdin"
`0:("    ",)'{y:"'",y,"', ";:[80<(#y)+#*|x;x,,y;:[#x;(-1_ x),,(*|x),y;,y]]}/(,()),{:[(*|x)~(#*|x)#y;(-1_ x),(,y),(-1#x);x,,y]}/(,()),?w@<w

refi64

import re

def myfunc(s):
    m = re.match(r'^(.+?)\1+$', s)
    return len(s)/len(m.groups()[0])

print(myfunc('abccbaabccba'))
print(myfunc('abcabcabcabc'))

refi64

howl.bindings.push
  editor:
    ctrl_q: (editor) ->
      if howl.app.editor.buffer.mode.name == "elm"
        howl.command.run 'elm-doc'
      else
        howl.command.run 'show-doc-at-cursor'

refi64

/*
  Major differences from CSS3:

  - Only selectors are `.class`, `element`, `*` (as well as multi selectors, e.g. `.a, .b`).
  - Only a few properties are supported.
  - Styles only define basic looks (so no box model or similar).
  - Things like 'initial' and 'inherit' don't exist.
  - Styles in <style> tags MUST before the elements with those classes.
*/