larsmans

/*
 * Nonogram/paint-by-numbers solver in SWI-Prolog. Uses CLP(FD),
 * in particular the automaton/3 (finite-state/RE) constraint.
 * Copyright 2011, 2014 Lars Buitinck
 * Copyright 2014 Markus Triska
 * Do with this code as you like, but don't remove the copyright notice.
 */

:- use_module(library(clpfd)).

daveray

(ns match.pojo
  (:use [match.core :only [IMatchLookup val-at* match]]))

(set! *warn-on-reflection* true)

(defmacro pojo-match
  "Generate an implementation of match.core/IMatchLookup for the given Java class.
  Keys are mapped like this:
  
    isVisible -> :visible?

wycats

<!--
  I'm sure there's a better syntax for naming subtemplates
-->

<h3>This is a list</h3>
<ul>
  {{#each items}}
  {{@cell}}
  <li>
     {{..}}

bmmoore

{-# OPTIONS --universe-polymorphism #-}
module match where
open import Data.List hiding (or)
open import Category.Monad
open import Category.Functor
open import Function
open import Data.Maybe
open import Data.Bool
open import Data.Nat
open import Relation.Binary.PropositionalEquality

swannodette

(usefd)

(define (powerset a)
  (if (null? a) (list '())
      (let ((p (powerset (cdr a))))
        (append (map (lambda (x) (cons (car a) x)) p) p))))

(define (remove-duplicates l)
  (do ((a '() (if (member (car l) a) a (cons (car l) a)))
       (l l (cdr l)))

pervognsen

-- Solution to http://beust.com/weblog/2011/10/30/a-new-coding-challenge/

import Data.List(isInfixOf)

partitions n 1             = [[n]]
partitions n k | n > 0     = [m:ms | m <- [1..n `div` 2], ms <- partitions (n-m) (k-1)]
partitions n k | otherwise = []

weighings []     = [0]
weighings (w:ws) = [m + n | m <- weighings ws, n <- [-w, 0, w]]

swannodette

let
   val Id = fn x => x
in
    Id
end 


(*
Warning: type vars not generalized because of
   value restriction are instantiated to dummy types (X1,X2,...)

jonifreeman

Miles Sabin implemented a nice selection sort example in Scala's type system. See:

http://www.chuusai.com/2012/01/27/type-level-sorting-in-shapeless/

To get a better understanding how that works I ported the algorithm to Prolog.

selectleast([H|T], TM, [H|TRem]):-
    selectleast(T, TM, TRem), TM < H.

selectleast([H|T], H, T).

fogus

;;; Written when pondering
;;; http://stackoverflow.com/questions/9086926/create-a-proxy-for-an-specific-instance-of-an-object-in-clojure

(defmacro delegating-proxy [o class-and-ifaces ctor-args & impls]
  (let [oname (gensym)]
    (letfn [(delegating-impls [^java.lang.reflect.Method ms]
              (let [mname (symbol (.getName ^java.lang.reflect.Method (first ms)))
                    arity-groups (partition-by #(count (.getParameterTypes ^java.lang.reflect.Method %)) ms)
                    max-arity (max-key #(count (.getParameterTypes ^java.lang.reflect.Method %)) ms)]
                `(~mname

swannodette

(defun pretty-lambdas ()
  "Show glyph for lower-case Greek lambda (λ) wherever 'lambda' appears."
  (font-lock-add-keywords
    nil
    `(("(\\(lambda\\>\\)"
       (0
         (progn
           (compose-region
             (match-beginning 1)
             (match-end 1)