KwangYul Seo | 1 Mar 13:35 2014
Picon

Type checking string literal in Haskell?

In Java, the Checker Framework (http://types.cs.washington.edu/checker-framework/) provides a way to type check string literals. For example, Java signatures type system differentiates strings literals in different forms:

1. Unqualified strings : 
"Hello, world!" -> <at> Unqualified String

2. Fully qualified names: 
"package.Outer.Inner" -> <at> FullyQualifiedString String

3. Binary names: 
"package.Outer$Inner" -> <at> BinaryName String

4. Field descriptors: 
"Lpackage/Outer$Inner;" -> <at> FieldDescriptor String

It can do the similar checks with regular expressions or SQL statements.

Is it possible to type check string literals in Haskell? I think it would be nice if we can check if a given string literal is a valid URL or an email address at compile time.

Regards,
Kwang Yul Seo

_______________________________________________
Haskell-Cafe mailing list
Haskell-Cafe <at> haskell.org
http://www.haskell.org/mailman/listinfo/haskell-cafe
Niklas Haas | 1 Mar 13:45 2014
Picon

Re: Type checking string literal in Haskell?

On Sat, 1 Mar 2014 21:35:09 +0900, KwangYul Seo <kwangyul.seo <at> gmail.com> wrote:
> In Java, the Checker Framework (
> http://types.cs.washington.edu/checker-framework/) provides a way to type
> check string literals. For example, Java signatures type system
> differentiates strings literals in different forms:
> 
> 1. Unqualified strings :
> "Hello, world!" ->  <at> Unqualified String
> 
> 2. Fully qualified names:
> "package.Outer.Inner" ->  <at> FullyQualifiedString String
> 
> 3. Binary names:
> "package.Outer$Inner" ->  <at> BinaryName String
> 
> 4. Field descriptors:
> "Lpackage/Outer$Inner;" ->  <at> FieldDescriptor String
> 
> It can do the similar checks with regular expressions or SQL statements.
> 
> Is it possible to type check string literals in Haskell? I think it would
> be nice if we can check if a given string literal is a valid URL or an
> email address at compile time.
> 
> Regards,
> Kwang Yul Seo
Non-text part: text/html
> _______________________________________________
> Haskell-Cafe mailing list
> Haskell-Cafe <at> haskell.org
> http://www.haskell.org/mailman/listinfo/haskell-cafe

I think QuasiQuoters were designed for pretty much this purpose. They're
basically functions from Strings to expressions (or
types/declarations/patterns, depending on the context).

A quasiquoter like [url|http://example.com] could parse the string
passed to it ("http://example.com") at compile time and return an
expression of type URL (or throw an error or something else), or maybe
even some other data structure that will end up being useful.
John Lato | 3 Mar 04:59 2014
Picon

Re: Type checking string literal in Haskell?

Yes.  In Haskell, types are your friends.  You should define new types liberally.

I think the usual approach is to create newtype wrapper:

> module EmailAddr (EmailAddr, mkEmailAddr) where
>
> newtype EmailAddr = EmailAddr String
>
> mkEmailAddr :: String -> Maybe EmailAddr
> mkEmailAddr str = if isEmailAddr then Just (EmailAddr str) else Nothing

The only way to make an EmailAddr is via the mkEmailAddr function, which checks that the string is actually a valid address (implementation omitted).  Therefore, there's a guarantee that any EmailAddr is actually a well-formed email address, and any functions that operate on an EmailAddr can rely upon this.

Of course, it might be useful to create an actual algebraic type instead:

> data EmailAddr = EmailAddr { address :: String, domain :: String }

(and the domain could similarly be an algebraic type instead of a plain string)

In general, you should be working with types that closely reflect the domain you're working in.  This will make your functions more clear, and the compiler/type checker will be able to provide more help during development.

John L.


On Sat, Mar 1, 2014 at 4:35 AM, KwangYul Seo <kwangyul.seo <at> gmail.com> wrote:
In Java, the Checker Framework (http://types.cs.washington.edu/checker-framework/) provides a way to type check string literals. For example, Java signatures type system differentiates strings literals in different forms:

1. Unqualified strings : 
"Hello, world!" -> <at> Unqualified String

2. Fully qualified names: 
"package.Outer.Inner" -> <at> FullyQualifiedString String

3. Binary names: 
"package.Outer$Inner" -> <at> BinaryName String

4. Field descriptors: 
"Lpackage/Outer$Inner;" -> <at> FieldDescriptor String

It can do the similar checks with regular expressions or SQL statements.

Is it possible to type check string literals in Haskell? I think it would be nice if we can check if a given string literal is a valid URL or an email address at compile time.

Regards,
Kwang Yul Seo


_______________________________________________
Haskell-Cafe mailing list
Haskell-Cafe <at> haskell.org
http://www.haskell.org/mailman/listinfo/haskell-cafe


_______________________________________________
Haskell-Cafe mailing list
Haskell-Cafe <at> haskell.org
http://www.haskell.org/mailman/listinfo/haskell-cafe
Richard A. O'Keefe | 3 Mar 21:29 2014
Picon

Re: Type checking string literal in Haskell?


On 3/03/2014, at 4:59 PM, John Lato wrote:

> Yes.  In Haskell, types are your friends.  You should define new types liberally.

I believe the original poster was asking about a *static* check.

Newtypes with "smart constructors" are a good way to plug in
a *dynamic* check, which is valuable but different.
John Lato | 4 Mar 00:46 2014
Picon

Re: Type checking string literal in Haskell?

Ah yes, I'd missed the "string literal" part.  In that case, I agree with Niklas that quasi-quoters seem the best option.  Although, they require pretty much the same framework to operate (a custom data type and parser), so once you have a quasi-quoter it's usually easy to implement dynamic checks with the same tooling.


On Mon, Mar 3, 2014 at 12:29 PM, Richard A. O'Keefe <ok <at> cs.otago.ac.nz> wrote:

On 3/03/2014, at 4:59 PM, John Lato wrote:

> Yes.  In Haskell, types are your friends.  You should define new types liberally.

I believe the original poster was asking about a *static* check.

Newtypes with "smart constructors" are a good way to plug in
a *dynamic* check, which is valuable but different.



_______________________________________________
Haskell-Cafe mailing list
Haskell-Cafe <at> haskell.org
http://www.haskell.org/mailman/listinfo/haskell-cafe

Gmane