quantifiers

I've been trying to work out how to implement Church-encoded data types in Scala. It seems that it requires rank-n types since you would need a first-class const function of type forAll a. a -> (forAll b. b -> b) . However, I was able to encode pairs thusly: import scalaz._ trait Compose[F[_],G[_]] { type Apply = F[G[A]] } trait Closure[F[_],G[_]] { def apply[B](f: F[B]): G[B] } def pair[A,B](a: A, b: B) = new Closure[Compose[({type f[x] = A => x})#f, ({type f[x] = B => x})#f]#Apply, Id] { def apply[C](f: A => B => C) = f(a)(b) } For lists, I was able to encode cons : def cons[A](x: A) = {

Consider the following SMT-LIB code: (set-option :auto_config false) (set-option :smt.mbqi false) ; (set-option :smt.case_split 3) (set-option :smt.qi.profile true) (declare-const x Int) (declare-fun trigF (Int Int Int) Bool) (declare-fun trigF$ (Int Int Int) Bool) (declare-fun trigG (Int) Bool) (declare-fun trigG$ (Int) Bool) ; Essentially noise (declare-const y Int) (assert (! (not (= x y)) :named foo )) ; Essentially noise (assert (forall ((x Int) (y Int) (z Int)) (! (= (trigF$ x y z) (trigF x y z)) :pattern ((trigF x y z)) :qid |limited-F| ))) ; Essentially noise (assert (forall ((x Int))

The Haskell Wiki does a good job of explaining how to use existential types, but I don't quite grok the theory behind them. Consider this example of an existential type: data S = forall a. Show a => S a -- (1) to define a type wrapper for things that we can convert to a String . The wiki mentions that what we really want to define is a type like data S = S (exists a. Show a => a) -- (2) i.e. a true "existential" type - loosely I think of this as saying "the data constructor S takes any type for which a Show instance exists and wraps it". In fact, you could probably write a GADT as follows:

The regex is constructed on the fly, but I've output it to firebug: (.{1,38})(+|$\n?) the error is invalid quantifier +|$\n?) I'm not sure where to start. The actual code is: var re = top.RegExp; var regex = new re("(.{1," + len + "})(+|$\\n?)", "gm"); UPDATE: Per Bennor McCarthy's instructions, I changed the code to this: var regex = new re("(.{1," + len + "})(\+|\$\\n?)", "gm"); Firebug still tells me this: invalid quantifier +|$\n?) [Break on this error] var regex = new re("(.{1," + len + "})(\+|\$\\n?)", "gm"); ANOTHER UPDATE Looks Like I had to double slash it and this solved the problem!

At the outset, let me explain that this question is neither about how to capture groups, nor about how to use quantifiers, two features of regex I am perfectly familiar with. It is more of an advanced question for regex lovers who may be familiar with unusual syntax in exotic engines. Capturing Quantifiers Does anyone know if a regex flavor allows you to capture quantifiers? By this, I mean that the number of characters matched by quantifiers such as + and * would be counted, and that this number could be used again in another quantifier. For instance, suppose you wanted to make sure you have