philipnilsson

import Control.Monad (void)
import Control.Applicative
import Data.Foldable (for_)
import Data.Monoid
import Text.Printf

data Attributed m w a = Attributed (m a) w
  
instance Functor m => Functor (Attributed m w) where
  fmap f (Attributed m w) = Attributed (fmap f m) w

philipnilsson

import Text.Parsec
import Control.Applicative hiding ((<|>))
import qualified Data.Map as M
import Data.Either (partitionEithers)
import Data.List (intercalate)
import System.IO (hPutStrLn, stderr)

data Word = Splice String | Word String
          deriving (Ord, Eq, Show)

philipnilsson

import functools

def scanl(f,x,it):
  return functools.reduce(lambda xs, y:  xs + [f(xs[-1],y)], it, [x])

def scanl1(f, it):
  return scanl(f, it[0], it[1:])

def scanr1(f, it):
  return reversed(scanl1(f, list(reversed(it))))

philipnilsson

#include <stdio.h>

int main(void) {
  int n, e, i = 0;
  scanf("%d\n", &n);
  scanf("%d", &e);
  int sum = e, first = e, last = e, len = 1;
  int delta;
  while (++i < n) {
    scanf(" %d", &e);

philipnilsson

-- | Experimental and very simple quasi-quotation of ECMAScript in
-- Haskell. Doesn't support anti-quotation as of now.

{-# LANGUAGE ScopedTypeVariables #-}
{-# LANGUAGE TypeFamilies #-}
{-# LANGUAGE Rank2Types #-}
module Language.ECMAScript5.Syntax.QuasiQuote (js, jsexpr, jsstmt) where

import qualified Language.Haskell.TH as TH
import Language.Haskell.TH.Quote

philipnilsson

-- | Experimental and very simple quasi-quotation of ECMAScript in
-- Haskell. Doesn't support anti-quotation as of now.

{-# LANGUAGE ScopedTypeVariables #-}
{-# LANGUAGE TypeFamilies #-}
module Language.ECMAScript5.Syntax.QuasiQuote (js, jsexpr, jsstmt) where

import qualified Language.Haskell.TH as TH
import Language.Haskell.TH.Quote
import Text.Parsec hiding (parse)

philipnilsson

nonEmptySubsequences = foldr comb []
  where comb x xs = xs ++ fmap (x:) ([]:xs)
                    
findSum p = filter (p.sum) . nonEmptySubsequences
hasSum  p = not.null . findSum p


-- Trying it in the REPL