Pasqualino 'Titto' Assini wrote:
I am trying to write an interpreter for a little functional language but I am
finding very problematic to dynamically create a typed representations of the
language terms.
The problem is to write a function that converts between Exp and Term
t as in:
The earlier message showed how to implement a typechecker from untyped
AST to wrapped typed terms. The complete code can be found at
http://okmij.org/ftp//Haskell/staged/TypecheckedDSL.hs
The typechecker has the type
typecheck :: Gamma - Exp - Either String TypedTerm
where
apfelmus showed the implementation of the state monad as free term
algebra, using GADT. Here's an implementation that does not use GADT
http://okmij.org/ftp/Haskell/types.html#state-algebra
All the smarts are in the observation function. This style is _very_
well explained by Ralf Hinze
Yang wrote:
Furthermore, is there any way to embed this information [about async
execptions] in the type system, so that Haskellers don't produce
async-exception-unaware code? (Effectively, introducing checked
interrupts?)
Yes, it is possible to make the information about exceptions and
Philipp N. wrote:
i'm trying to wrap functions (a - b - ... - z) of any arity to functions
of type ([String] - y), where list of strings replaces the typed arguments.
the problem is, that you cannot distinguish type (x-y) from z, so these
instances are overlapping.
to which apfelmus replied
Alfonso Acosta wrote:
mapSY :: (Typeable a, Typeable b) = (a - b) - Signal a - Signal b
mapSY f (Signal primSig) = Signal (PrimSignal (MapSY (toDyn f) primSig))
The following process would be really useful but its compilation
obviously fails:
mapSnd :: Signal (a, a) - Signal a
mapSnd =
Adrian Neumann wrote:
I figured I'd need something like this
data GF = GF Integer Integer
so that each element of the finite field would remember p. However I
can't think of a way to use the typesystem to ensure that p is always
the same.
You might like:
Vectro: Haskell library
Alfonso Acosta wrote:
dynApp allows to apply a Dynamic function to a Dynamic argument:
dynApp :: Dynamic - Dynamic - Dynamic
I don't seem to find a way (without modifying Data.Dynamic itself) to
code this function
This is not very difficult if we have a well-delineated (and still
infinite)
Stephen Tetley wrote:
The finally tagless style is an implementation of the TypeCase pattern
(Bruno C. d. S. Oliveira and Jeremy Gibbons):
http://www.comlab.ox.ac.uk/jeremy.gibbons/publications/typecase.pdf
The finally tagless style is slightly more general.
The TypeCase paper emphasizes
Paul Brauner wrote:
is there a way in some haskell extension to explicit (system F's) big
lambdas and (term Type) applications in order to help type inference?
Actually, yes: newtype constructor introductions may act as a big
lambda, with constructor elimination acting as type applications:
We show that type families let us write Leibniz equality witnesses of
the injectivity of type constructors. We may use Leibniz equality not
only for introduction but also for elimination.
The paper on ``Typing Dynamic Typing'' (Baars and Swierstra, ICFP
2002) demonstrated the first
Maciej Piechotka wrote:
class (Monad m, Monad (IO' m)) = MonadIO m where
type IO' m :: * - *
liftIO :: IO a - IO' m a
liftM :: m a - IO' m a
The signature for liftIO betrays a problem. Since liftIO is a member
of a type class, when liftIO is used in code, the type checker has to
Oscar Finnsson wrote:
I got the GADT
data DataBox where
DataBox :: (Show d, Eq d, Data d) = d - DataBox
and I'm trying to get this to compile
instance Data DataBox where
gfoldl k z (DataBox d) = z DataBox `k` d
gunfold k z c = k (z DataBox) -- not OK
As has been pointed out,
It is quite straightforward to extend the SYB generic programming
framework to existential data types, including existential data types
with type class constraints. After all, an existential is essentially
a variant data type with the infinite, in general, number of variants.
The only,
Under what license are you releasing DataEx.hs? I'm wondering if I may
use it in my package (under BSD3 license) until something like it is
included in SYB.
DataEx.hs as other such code of mine has been written in the hope it
might be useful, or at least instructive. I usually place such code
Ryan Newton wrote:
What I would next *like* to do is something like the following:
import qualified Data.IntMap as DI
instance FitInWord t = GMapKey t where
data GMap t v = GMapInt (DI.IntMap v) deriving Show
The problem is that there's already a more general instance of
Simon Peyton-Jones wrote:
Until now, no one has know how to combine fundeps and local constraints.
For example
class C a b | a-b where
op :: a - b
instance C Int Bool where
op n = n0
data T a where
T1 :: T a
T2 :: T Int
-- Does this typecheck?
f :: C a b
Ertugrul Soeylemez wrote:
Essentially UndecidableInstances turns the type system into a
Turing-complete programming language. One direct consequence is that
type checking may not terminate
Actually, the type checking (specifically, instance resolution) always
terminates, due to the recursion
Leon Grynszpan wrote:
What I want, instead, is to run a whole bunch of
computations that may throw errors. If there are any errors, I want to
collect them all into one big master error. If not, I want a list of
results. Here's an example of usage:
couldThrowError :: (Error e, MonadError e
Ryan Ingram wrote:
But it doesn't generalize; you need to create a witness of inequality
for every pair of types you care about.
One can do better, avoiding the quadratic explosion. One merely needs
to establish a map from a type to a suitable, comparable
representation -- for example, to a
Jose' Romildo Malaquias wrote:
I am writing here to ask suggestions on how to annotate an ast with
types (or any other information that would be relevant in a compiler
phase) in Haskell.
There is also a general way of annotating AST post factum, described in
Jose Pedro Magalhaes wrote:
From what I understand, you are using a list of integers to encode a path to
a subterm. This is a practical and lightweight implementation, but less
type-safe: it is easy to encode annotations that do not correspond to any
value. Also, it cannot guarantee, with
Lennart Augustsson wrote:
Try to make Set an instance of Functor and you'll see why it isn't.
It's very annoying.
And yet the very simple, and old solution works.
http://okmij.org/ftp/Haskell/types.html#restricted-datatypes
We just properly generalize Functor, so that all old
Serguey Zefirov wrote:
Is it possible to delete an element from heterogenous list using type
families alone?
I can do it using multiparameter type classes:
class Del a list result
instance Del a (a,list) list
instance Del a list list' = Del a (a',list) list'
instance Del a () ()
I'm
Jeff Harper defined typeclasses
class Reciprocate a b | a - b where
recip :: a - b
class Multiply a b c | a b - c where
(*) :: a - b - c
and encountered the problem with
-- Here I define a default (/) operator that uses the
-- Reciprocate and Multiply class to perform division.
Recently Vo Minh Thu wondered if Haskell (or, I generalize, functional
programming) can be of much use for computer graphics programming.
I'd like to point out a project that experimentally shown that
functional programming is of great help for processing of large raster
images (24-bit PPM
I'm afraid the _meta_ programming aspect of the image processing
project may be overlooked.
Joel Reymont wrote:
I think the issue wasn't using functional programming for large image
processing, it was using Haskell. OCaml is notoriously fast and
strict. Haskell/GHC is... lazy.
Well, in
. The idea is similar to the one described in
http://pobox.com/~oleg/ftp/Haskell/types.html#is-function-type
The complete code follows. Now testx typechecks.
{-# OPTIONS -fglasgow-exts #-}
{-# OPTIONS -fallow-undecidable-instances #-}
{-# OPTIONS -fallow-overlapping-instances #-}
module
Most systems of (first-order) logic differentiate between function
letters (aka, symbols) and predicate letters (symbols). The former are
used to build terms; the latter build atomic formulas (which can later
be combined in more complex formulas using negation, conjunction,
disjunction, and
Sorry for a late reply, I'm out of town.
As I understand it, the problem is as follows: we'd like to construct
different realizations of XML documents from data of different
types. We wish to write
p (p foo)
and specify the desired type of the XML document, like
(p (p foo)) ::
be handled. Again, without
introducing any runtime overhead:
http://pobox.com/~oleg/ftp/Haskell/KMP-deptype.hs
The approach is formalizable; the recent PLPV talk by Chung-chieh Shan
presented the types systems and the proof techniques. Some of the
proofs have been formalized in Twelf:
http
, please see any code described in
http://pobox.com/~oleg/ftp/Haskell/typecast.html
Appendix D of the full HList paper (or, HList technical report, I
should say) gives the reasons for TypeCast.
Briefly, TypeCast lets us replace a (ground) type T with a type
variable t subject
This message is intended as a long answer to Michael Shulman's
question (Re: variadic functions and typeCast) and Jason Dagit's
question (Re: Duplicate Instance problem). Incidentally, the short
answer to Jason Dagit's question is `constraints are disregarded
during instance selection'. The
I previously wrote:
The typechecker commits to the instance
and adds to the current constraints
TypeCast x Int, Ord Bool, Eq Bool
The latter two are obviously satisfied and so discharged. The former
leads to the substitution {x-Int}.
I should have been more precise and said:
It seems that irrefutable pattern match with existentials is safe. The
fact that irrefutable pattern match with GADT is unsafe has been
demonstrated back in September 2004.
Let us consider the following regular existential data type
data TFoo where
Foo :: Show a = a - TFoo
Bar :: Int -
I have come to realize that irrefutable pattern matching of
existentials may indeed be problematic. Let us consider the following
existential data type
data FE = forall a. Typeable a = Foo a
| forall a. Typeable a = Bar a
The following tests type and run (the latter raising the
I wanted to try using OOHaskell as a library, but I've run into some
problems I don't understand.
I downloaded the copy from:
http://homepages.cwi.nl/~ralf/OOHaskell/
both HList and OOHaskell are now available via DARCS
http://darcs.haskell.org/HList/
I am using a heterogenous list as in [1] all elements of which are of
a given class C.
Since foo maps all class members to Int, hMapOut should be a
straight-forward way to produce homogenous Int lists from heterogenous
CLists:
test :: (CList l) = l - [Int]
test = hMapOut foo
Well, `foo'
Matthias Fischmann wrote:
instance (Monad m, HSequence m HNil HNil) = HSequence m HNil HNil
where hSequence _ = return HNil
how can i use the goal of the declaration as one of the conditions
without causing some sort of black hole in the type inference
algorithm?
Very easily: the
. This example shows that
Haskell truly has more kinds than it is commonly acknowledged.
For more details on constrained lists (list of odd numerals, even
numerals, etc), please see the following implementation of Tim
Sheard's `Half' example
http://pobox.com/~oleg/ftp/Haskell/Half.hs
data Succ a = S
I too miss the old way of handling local type variables. Previously,
local type annotations worked a lot like an additional constraint,
with type variables denoting some type. The same type variable denoted
the same type. Here's how it works in OCaml, for example:
# let pair x y = (x,y);;
val
Tim Smith wrote:
Has anyone found out how to lift bracket into another monad?
Yes, please see the thread `Re: Control.Exceptions and MonadIO'
staring at
http://www.haskell.org/pipermail/haskell-cafe/2006-April/015444.html
There is also a Haskell' ticket:
The problem seems equivalent to the following:
http://pobox.com/~oleg/ftp/Haskell/typecast.html#local-fd
That is, the inferred type is too general to chose the appropriate
instance. The solution is also the same: either add type annotations
to restrict the inferred type (and so make
Greg Buchholz has posed an interesting problem of writing a
typechecker. Given untyped terms of the form
data Expr = ELit Int
| EInc Expr
| EIsZ Expr
we are to compute typed terms:
data Term a where
Lit :: Int - Term Int
Inc :: Term Int -
Donald Bruce Stewart wrote:
So all this talk of locating head [] and fromJust failures got me
thinking:
Couldn't we just use rewrite rules to rewrite *transparently*
all uses of fromJust to safeFromJust, tagging the call site
with a location?
I'm sorry for shifting the topic:
are statically assured of no head [] error!
test2 = head $ 1 !: 2 !: 3 !: []
This would look better had `[1,2,3]' been a rebindable syntax similar to
`do'.
I should point to
http://pobox.com/~oleg/ftp/Computation/lightweight-dependent-typing.html
for further, more complex examples. We can also
Jan-Willem Maessen wrote:
In addition, we have this rather nice assembly of functions which
work on ordinary lists. Sadly, rewriting them all to also work on
NonEmptyList or MySpecialInvariantList is a nontrivial task.
That's an excellent question. Indeed, let us assume we have a
Huazhi (Hank) Gong wrote:
Like given a string list s=This is the string I want to test, I want to get
the substring. In ruby or other language, it's simple like s[2..10], but how
to do it in Haskell?
Quite simply, actually:
infixl 1 %%
str %% idxs = map (str !!) idxs
That is it. Not the
Nicolas Frisby wrote
The commented out signature is the signature that GHC infers for the
function. When I uncomment that signature, it will no longer type
check. Why does this happen? Even with the forall and the explicit
signatures in the where clause, it chokes.
Alas, this is the property
Marco Tu'lio Gontijo e Silva wrote:
is there a way to defined something as a map to use in tuples?
Yes, it is: and it is quite easy and straightforward.
Udo Stenzel
since c would be a variable that ranges over type classes, and that
doesn't exist.
Of course it does: please see below (as
Misha Aizatulin wrote
I am using existential boxes like
data Box cxt = forall a . Sat (cxt a) = Box a
here Sat is taken from [1]:
class Sat a where dict :: a
The result is a box type which can have variable context imposed on
its contents. What I noticed is that sometimes I want to
that is convertible to
typeclasses in the straightforward way, see for example,
http://pobox.com/~oleg/ftp/Haskell/GADT-interpreter.hs
Inn this particular example, GADT do not bring any
power. Incidentally, the typeclass encoding has an advantage: If the
submitted proof is invalid, the error
It has been already remarked that any algorithm of finding prime
numbers that uses division or `mod` operations cannot be called
(Eratosthenes) sieve. The insight of Eratosthenes is finding primes
without resorting to division or multiplication. In his time, doing
either of those operations was
We further simplify the previously posted genuine sieve algorithm and
generalize it to the finding of lucky numbers.
We observe that we only need to store marks _signifying_ the integers,
but never the integers themselves. Thus we arrive at the algorithm
that is distinguished from all
On 2/21/07, Alfonso Acosta alfonso.acosta at gmail.com wrote:
In my opinion adding Type-level lambdas would be the way to go, but
they unfortunately are not part of Haskell.
Type-level lambdas are already present in Haskell. Please see the
messages
On computable types. I. Typed lambda and
Alfonso Acosta wrote:
class Synchronous s f1 f2 | s - f1, s - f2 where
mapSY :: f1 a b - s a - s b
delaySY:: a - s a - s a
zipWithSY :: f2 a b c- s a - s b - s c
The goal of this class is to extend the name of the following
functions (which BTW are already
Perhaps you might want include in your test the following:
http://www.haskell.org/pipermail/haskell-cafe/2007-February/022437.html
It seems quite close to the genuine Eratosthenes sieve algorithm: it
employs the idea of marks, it can cross composite numbers off several
times, and it never
complaint.
That said, it is quite possible in Haskell to achieve genuine
class-based dispatch, with backtracking if necessary:
http://pobox.com/~oleg/ftp/Haskell/poly2.txt
However, it seems that your particular problem can be solved with
simpler means:
instance (HList
Stefan O'Rear wrote:
Personally I like the GADT approach best since it is very flexible and
convienient. I have never used a purpose-build computer proof system,
but (modulo _|_) it took me less than 10 minutes to answer
LoganCapaldo (on #haskell)'s challenge to proof that + was commutative
Steve Downey wrote:
In the last OO design in Haskell thread (and probably in every one
preceeding it), it was suggested that having some examples might be a good
idea.
Since most people with existing designs will have some familiarity with
Design Patterns, and those are typical building
uses the results of the analysis.
I wasn't able to find the definition of AllOf(But):
It is in the complete code
http://pobox.com/~oleg/ftp/Haskell/poly2.hs
It isn't that interesting:
data AllOfBut x y
{-# OPTIONS -fglasgow-exts #-}
{-# OPTIONS -fallow-undecidable-instances
Takusen permits on-demand processing on three different levels. It is
specifically designed for database processing in bounded memory with
predictable resource utilization and no resource leaks.
But first, about getContents. It has been mentioned a while ago that
getContents should be renamed to
After some fooling around, I came up with something I think makes
sense. Let me know if this is the right/wrong thing. It seems to
work for the examples I've tried so far.
instance (Floating f, MetricSpace e f
,MetricSpace e' f, HZip l l (HCons (e', e') l')
,HFoldr
Tom Hawkins wrote:
] My DSLs invariably define a datatype to capture expressions; something
] like this:
]
] data Expression
] = Add Expression Expression
] | Sub Expression Expression
] | Variable String
] | Constant Int
] deriving Eq
] The problem comes when I want to generate
Matthew Naylor wrote:
it's not immediately clear (to me at least) how efficient your method
will be in practice. Any method based on common sub-expression
elimination surely must inspect every node in the flattened graph. In
the worst case, an acyclic graph containing n nodes could have 2^n
Call-by-name lambda-calculus is strictly more expressive (in Felleisen
sense) than call-by-value lambda-calculus, and the call-by-need (aka, lazy)
lambda-calculus is observationally equivalent to the call-by-name.
One can add shift/reset to any of these calculi (CBV shift/reset is
most known;
Manuel M T Chakravarty:
Hugo Pacheco:
I would simply like the compiler not to use that instance if the
equality constraint does not hold, like some another instance
dependency constraint, but I assume that is not possible.
This is independent of type families. The selection of type
Sterling Clover wrote:
there's no standard way that I know of besides inspection to
determine if code might throw an exception, and this is particularly
the case with the dreaded lazy IO of prelude functions.
The following old message showed even two ways of doing exactly that
-- in Haskell,
Martin Hofmann wrote:
Thanks a lot, this helps a bit, but access to function bodies is exactly
what I need.
Then perhaps you might like the method of reconstructing bodies (of
possibly compiled) functions
http://okmij.org/ftp/Computation/Generative.html#diff-th
in the form of AST --
The following code solves exactly the problem of implementing
(restricted) MonadPlus in terms of Data.Set:
http://okmij.org/ftp/Haskell/DoRestrictedM.hs
The code is written to demonstrate the do-notation. We write the
monadic code as usual:
test1s_do () = do
x - return a
return
Eric Stansifer wrote:
I am using a bunch of empty type classes to categorize some objects:
class FiniteSolidObject o
class FinitePatchObject o
class InfiniteSolidObject o
Since solid objects are exactly finite solid objects plus
infinite solid objects, there is an obvious way to code
Luke Palmer wrote in response to Harald ROTTER
I also wonder if there is some kind of generalized foldr such that, e.g.
D1 $ D0 $ D0 $ Sz = specialFoldr ($) Sz [D1,D0,D0]
I think that this foldr must be some special foldr that augments the data
type of the result in each foldr step.
Actually it is possible to implement all three evaluation orders
within the same final tagless framework, using the same interpretation
of types and reusing most of the code save the semantics of lam. That
is where the three orders differ, by their own definition.
In call-by-name, we have
Perhaps it would be appropriate to point out the IFIP conference on
exactly that topic, DSL. The conference took place in July, here is
the permanent record:
http://dsl09.blogspot.com/
with pointers to the slides and the discussions.
The panel discussion has debated that very question,
It seems the applicative do is almost identical to the form ML and
Scheme has had since the beginning. Perhaps that semantic similarity
might inform the syntactic debate.
do a - f
g
b - h
pure $ foo a b
into this:
(\a b - pure $ foo a b) * (f * g * h)
This form, although very
Martin Sulzmann wrote:
Undecidable instances means that there exists a program for which there's
an infinite reduction sequence.
I believe this may be too strong of a statement. There exists patently
terminating type families that still require undecidable
instances in GHC. Here is an example:
In hindsight it occurred to me that the algorithm can be abstractly
expressed in terms of relational algebra for which I need an EDSL.
One concrete implementation could then be an interpreter / compiler to
SQL, if I choose to use a database backend, and another implementation
could be a
Something I wonder from time to time if it would be a good thing or
not is to allow
a `f g` b
to mean
f g a b
You don't have to wonder:
http://www.haskell.org/haskellwiki/Infix_expressions
Granted, you have to use different characters rather than the
backquote. On the other
and Caml lists).
P.S.
I'm still digesting the Finally Tagless approach from Oleg, Jacques
and Chen.
You probably mean Chung-chieh Shan, whose last name is Shan and the
first name is Chung-chieh.
http://en.wikipedia.org/wiki/Chinese_name
Magicloud Magiclouds wrote
In OOP, when I inherit a class, I also got the members of it.
But in haskell, how to inherit a data?
Although any OOP system has by definition, objects, not all of them
have classes. The best example of a classless (also called 1-level, or
prototype-based) OO
Brent Yorgey wrote:
This email is literate Haskell. I'm struggling to come up with the
right way to add a fixpoint constructor to an expression language
described by a type-indexed GADT (details below).
but since Haskell doesn't have type-level lambdas, I don't see how
to make that work.
Valery V. Vorotyntsev wrote:
The following pattern appears quite often in my code:
results - map someConversion `liftM` replicateM nbytes Iter.head
The meaning is: take `nbytes' from stream, apply `someConversion' to
every byte and return the list of `results'.
But there's more than one
There are at least two parser combinator libraries that can deal with
*any* left-recursive grammars. That said, Prof. Swierstra's advice to
try to get rid of left recursion is still well worth to follow.
The first library is described in
Frost, Richard, Hafiz, Rahmatullah, and
Andrew Coppin wrote:
What we're really trying to do here is attach additional information to a
value - information which exists only in the type checker's head, but has no
effect on runtime behaviour (other than determining whether we *get* to
runtime). As far as I can tell, Haskell does not
Dale Jordan wrote:
The motivation for iterateR is to be able to have the ultimate
consumer determine how many random values to force, but still have a
single random generator used throughout the computation.
My intuition tells me that since the infinite list is produced in
finite batches,
Here is a bit more simplified version of the example. The example has
no value level recursion and no overt recursive types, and no impredicative
polymorphism. The key is the observation, made earlier, that two types
c (c ()) and R (c ())
unify when c = R. Although the GADTs R c below is
We explain the technique of systematically deriving absurd terms and
apply it to type families.
Indeed I should have said that there is no _overt_ impredicative
polymorphism in the example posted earlier: it is precisely the
impredicative polymorphism that causes the paradox. As everybody
HList (and OOHaskell, for that matter) are now hosted on
community.haskell.org, in the directories
/srv/code/HList
/srv/code/OOHaskell
The repositories are also available at these URLs:
http://code.haskell.org/HList/
http://code.haskell.org/OOHaskell/
Many
Sean Leather wrote:
(...) :: (c - d) - (a - b - c) - a - b - d
(...) f g x y = f (g x y)
Does anybody else care about this? What are some alternative
solutions?
Here is a different solution:
http://okmij.org/ftp/Haskell/polyvariadic.html#polyvar-comp
f:: a1-a2- -cp (where
contains the type signature to increase
comprehension:
prod:: (MCompose a b (c - d) e, MCompose f g (b,g) d) =
(h - a) - (c - f) - h - e
prod = (. ((. (,)) . mcomp)) . mcomp
Here `prod' is indeed the categorical product. The second example is
taken from
http://pobox.com/~oleg/ftp
This message is a literate Haskell98 code for translating proper
linear combinators into a point-free style. That is, we will be
converting (closed, albeit that is not strictly a requirement) terms
of the form ``\x1 ... xn - term'' where each variable xi has at most
one occurrence in term. The
Bryce Bockman wrote:
How would you guys memoize the following code.
simpleCalc :: (Int,Int) - (Int,Int)
simpleCalc (1,l) = (1,l+1)
simpleCalc (x,l) | (odd x) = simpleCalc (((3*x) + 1), 1 + l)
| otherwise = simpleCalc ((x `div` 2), 1 + l)
sCalc x = simpleCalc (x,0)
Benjamin Pierce wrote:
For someone coming to Haskell from an OCaml background, one of the hardest
things to get used to is the somewhat more bare bones module system that
Haskell provides.
...
This works fine as long as what you're exporting is just values, but it's
awkward for types, since
Alistair Bayley wrote:
There's a small problem: how to write a factory function that returns values
of various subtypes. The makeSubType function below won't compile, obviously
because the returns types are different (they're not the same 'm').
Indeed, expressions in both branches of an `if'
program). The CC monad transformer (derived from the CC library by
Sabry, Dybvig, Peyton-Jones), freely available from
http://pobox.com/~oleg/ftp/packages/LogicT.tar.gz
is free from that drawback.
BTW, with that monad transformer, the example looks as follows (again,
in a de-sugared way
Daniel Brown wrote:
class Baz a b | a - b
instance Baz (a - b) (a - [b])
instance Baz a a
...but Baz fails with this error...
When confronted with overlapping instances, the compiler chooses the
most specific one (if it is unique), e.g. `Baz (a - b) (a - [b])` is
more specific
of that derivation is a note `How to take a TAIL of a
functional stream'
http://pobox.com/~oleg/ftp/Computation/Continuations.html#cdr-fstream
The higher-rank type is needed only to express the polymorphic
answertype.
___
Haskell-Cafe mailing list
Haskell-Cafe
Regarding the law of mif (aka ifte, aka soft-cut, aka logical
conditional)
mif (mif c t' e') t e = mif c (\x - mif (t' x) t e) (mif e' t e)
You're right of course: mode matters for the predicates that involve
negation, such as mif. However, I believe that the mode is orthogonal
to the
Jonathan Cast wrote:
] You can't define most initial models without recursive (or
] inductive) data types in general, because initial models are defined
] inductively.
] You can't define head, tail, or foldr using the MonadPlus
] signature
] OK. Right. I forgot about the Church
On Thu, Jul 07, 2005 at 07:08:23PM +0200, Tomasz Zielonka wrote:
Some time ago I wanted to return the escape continuation out of the
callCC block, like this:
getCC = callCC (\c - return c)
It seems using shift/reset is better not only in principle but in
practice as well.
module Foo
1 - 100 of 400 matches
Mail list logo
