株式会社GGG Forall

株式会社GGG Forallのプレスリリース 美容家への調査でブランド支持率81％、成分推奨度85％を獲得。サクラン®・ヒト幹細胞培養エキスへのこだわりを継承し、ナイアシンアミド・バクチオール・エクソソームを新配合。20 ...

美容家への調査でブランド支持率81％、成分推奨度85％を獲得。サクラン(R)・ヒト幹細胞培養エキスへのこだわりを継承し、ナイアシンアミド・バクチオール・エクソソームを新配合。2026年12月発売予定。 容器イメージ画像 株式会社GGG Forall（本社：福岡県豊前市）は、自社プライベートブランド化粧品「Line

美容家への調査でブランド支持率81％、成分推奨度85％を獲得。サクラン(R)・ヒト幹細胞培養エキスへのこだわりを継承し、ナイアシンアミド・バクチオール・エクソソームを新配合。2026年12月発売予定。容器イメージ画像株式会社GGG Forall（本社:福岡県豊前市）は、自社プライベートブランド化粧品「Line

Thank, that was a kind of Freudian slip because I think newtypes are the best solution to deal with these cases. You can define a newtype with a `forall` in it: newtype Application = MkApplication { serve :: forall a. Request -> (Response -> IO a) -> IO a } This has much fewer issues with type inference and type checking in my experience. The cost is that you now need to wrap and unwrap this newtype, but ideally you’d hide that under a nice clean API.

rini: > From the documentation of that extension, `Rank2Types` used to mean a different restriction, and I also can’t see why this type isn’t a rank-1 type. You’re technically right and the type `forall r. Request -> (Response -> IO r) -> IO r` is itself not a higher rank type. However, there are a few nuances: 1. GHC used to only allow the keyword `forall` if `RankNTypes` (or `Rank2Types`) was enabled. Nowadays you can use `ExplicitForAll` and write a function signature like this: foo :: forall r. Request -> (Response -> IO r) -> IO r 2. Even so, using `forall` in a type synonym is still syntactically disallowed by GHC even with `ExplicitForAll`; it requires `RankNTypes`. 3. Even if GHC would allow defining the type synonym, most uses of it would be a higher rank type. For example, `Application -> Foo` would then expand to `(forall r. Request -> (Response -> IO r) -> IO r) -> Foo` which is a higher rank type. Technically, types like `Foo -> Application` are not really higher rank because the quantifier appears only to the right of the function arrow, but GHC rejects these anyway probably because of historical reasons mentioned in point 1.

> Consider > > > read :: forall a. Read a => String → a > > > The forall’d type is the output type. Even if it looks like a return type, but first BEFORE the computation during compile time (except 1 case) it was used as INPUT type. > Haskell is a statically-typed language. Inference can’t wait ‘til runtime to find out what some return type is. Hopefully, Haskell ALREADY support Runtime for types (this 1 exception) data E = forall a. MkE [a] lengthE :: E -> Int lengthE (MkE @e xs) = L.length @e xs What I try - split this function in 2: unE :: E -> exists a. [a] unE (Mk @e xs) = therefore @e in xs lengthE = L.length . unE

> And a clear limitation is that you can’t do things like [Application] (putting applications in a list) if Application is a **newtype** with a forall in it, unless you also enable the ImpredicativeTypes extension. Did you mean “type synonym” here?

> And a clear limitation is that you can’t do things like [Application] (putting applications in a list) if Application is a **newtype** with a forall in it, unless you also enable the ImpredicativeTypes extension. Did you mean “type synonym” here?

> And a clear limitation is that you can’t do things like [Application] (putting applications in a list) if Application is a **newtype** with a forall in it, unless you also enable the ImpredicativeTypes extension. Did you mean “type synonym” here?

VitWW: > In Haskel `forall` quantifier is stands for … input type! I think this is not true. (Or I don’t understand what you’re claiming.) Consider * read :: forall a. Read a => String → a The forall’d type is the output type. And it must be Universally quantified, so that whatever calls `read` can type-safely consume that type. VitWW: > during runtime it could be substituted to Monomorphic type. Haskell is a statically-typed language. Inference can’t wait ‘til runtime to find out what some return type is. Because whatever consumes that result then has no guarantees for type safety. A GADT wraps a unknown/constrained type inside a Constructor. Its type only gets exposed within code that explicitly `case`-matches on that constructor. The type can’t escape that scope, because that would destroy type safety. Perhaps those who’ve hearted the post could explain what merit they see?

With Output Existentials it is possible to write Nat-Vectors: data Nat = Zero | Succ Nat type Vec :: Nat -> Type -> Type data Vec n a where VNil :: Vec Zero a (:>) :: a -> Vec n a -> Vec (Succ n) a infixr 5 :> toVec :: forall a. [a] -> exists (n::Nat). Vec n a toVec [] = therefore @Zero in VNil toVec (x:xs) = therefore @(Succ m) in x :> tvxs where tvxs :: exists m. Vec m a tvxs = toVec xs filterVec :: forall a (n::Nat). (a -> Bool) -> Vec n a -> exists (m::Nat). Vec m a filterVec p VNil = therefore @Zero in VNil filterVec p (x :> xs) = if | p x -> therefore @(Succ r) in x :> fpxs | otherwise -> therefore @r in fpxs where fpxs :: exists r. Vec r a fpxs = filterVec p xs

Wow! So many good questions! > Furthermore, `maximum` needs `Ord`. How to push that inside `MkE`? Or might `maximumE` just fail at runtime? You are right - we cannot guarantee, that `MkE` has a type which is bounded by `Ord`! That’s why such code `maximum . unE` fails during a compile time! Yes, we need to push boundaries inside the `data` first and transitively preserve them: data E' = forall a. Ord a => MkE' [a] unE' :: E' -> exists a. Ord a => [a] unE' (MkE' @e xs) = therefore @e in xs > Or must I create a different version of `maximum`? And presumably of every other function/method that wants to consume an existential. No-no, `maximum` and other functions works perfecly fine with existentials. Code `maximum . unE'` is right! > So with `maximum . unE`, `unE`’s output existential is to be `maximum`’s input _and_ its output. Does this mean `maximum` must output an existential? How does that work? As I wrote, existential type FITS INTO forall type by substitutional hirarchy. Like `[Int]` is a valid input type for `forall a. Ord a => [a]`, with same substitutional logic `exists b. Ord b => [b]` is also valid for input (but not vice versa). Yes, total return type of such expression is also existential and it is typechecked so. But we must remember, that during Runtime type would become monomorphic and instance would be chosen correctly.

jaror: > 3. Even if GHC would allow defining the type synonym, most uses of it would be a higher rank type. For example, `Application -> Foo` would then expand to `(forall r. Request -> (Response -> IO r) -> IO r) -> Foo` which is a higher rank type. Technically, types like `Foo -> Application` are not really higher rank because the quantifier appears only to the right of the function arrow, but GHC rejects these anyway probably because of historical reasons mentioned in point 1. > That does explain my confusion I think. `Middleware` being `Application -> Application` would clearly turn into a rank-2 type Speaking of, poking wai directly leads me to write: middlewares app = foldl' (flip ($)) app $ [ middleware1 , middleware2 , middleware3 ] …which, GHC really does not like when `Middleware` is rank-2

Specifically, the documentation states “This is to avoid the need for Rank2Types in the definition of Application.” I do vaguely remember why the Application type cannot be simply `Request -> IO Response`, the explanation being in a talk about `wai`, but first thing that comes to my mind is changing the type into this: type Application = forall r. Request -> (Response -> IO r) -> IO r Without enabling any extensions, this works on GHC 9.10.3. But seemingly using `NoRankNTypes` makes it not work, so is that what is being suggested? From the documentation of that extension, `Rank2Types` used to mean a different restriction, and I also can’t see why this type isn’t a rank-1 type. when writing this post I did not realise `RankNTypes` was on by default so my question changed a bit Would or could a newer version of `wai` use this? Is there a reason to avoid the extension with it being default? I want to design a generic API for Discord gateway bots, so `wai` has come to my mind with it